1.运算符重载
运算符重载可以为运算符增加一些新的功能。
C++ 中绝大部分的运算符允许重载，不能重载的运算符有以下几个：
-
. 成员访问运算符
-
.* 成员指针访问运算符
-
:: 作用域运算符
-
sizeof 长度运算符
-
?: 条件运算符
有些运算符只能重载为成员函数，比如：
- 赋值运算符
=
- 下标运算符
[]
- 函数运算符
()
- 指针访问成员
->
2.重载为友元函数
友元运算符函数没有 this 指针，若重载的是双目运算符，则参数表中有两个操作符；若重载的是单目运算符，则参数表中只有一个操作符。
#include <iostream>
using namespace std;
class Point
{
int m_x;
int m_y;
friend Point operator+(const Point&, const Point&);
public:
// 带参构造函数
Point(int x, int y) : m_x(x), m_y(y)
{
}
// 拷贝构造函数
Point(const Point& point)
{
m_x = point.m_x;
m_y = point.m_y;
}
void display()
{
cout << "(" << m_x << ", " << m_y << ")" << endl;
}
};
// 重载加号
Point operator+(const Point& p1, const Point& p2)
{
return Point(p1.m_x + p2.m_x, p1.m_y + p2.m_y);
}
int main()
{
Point p1(10, 20);
Point p2 = p1;
Point p3 = p1 + p2;
p3.display();
Point p4 = p1 + p2 + p3;
p4.display();
return 0;
}
3.重载为成员函数
#include <iostream>
using namespace std;
class Point
{
int m_x;
int m_y;
public:
// 带参构造函数
Point(int x, int y) : m_x(x), m_y(y)
{
}
// 拷贝构造函数
Point(const Point& point)
{
m_x = point.m_x;
m_y = point.m_y;
}
void display()
{
cout << "(" << m_x << ", " << m_y << ")" << endl;
}
// 重载加号
const Point operator+(const Point& point) const
{
return Point(m_x + point.m_x, m_y + point.m_y);
}
// 重载减号
const Point operator-(const Point& point) const
{
return Point(m_x - point.m_x, m_y - point.m_y);
}
// 重载+=
Point& operator+=(const Point& point)
{
m_x += point.m_x;
m_y += point.m_y;
return *this;
}
// 重载==
bool operator==(const Point& point) const
{
return (m_x == point.m_x) && (m_y == point.m_y);
}
// 重载!=
bool operator!=(const Point& point) const
{
return (m_x != point.m_x) || (m_y != point.m_y);
}
// 重载负号
const Point operator-() const
{
return Point(-m_x, -m_y);
}
// 重载前缀++
Point& operator++()
{
m_x++;
m_y++;
return *this;
}
// 重载后缀++
const Point operator++(int)
{
Point old(m_x, m_y);
m_x++;
m_y++;
return old;
}
};
int main()
{
return 0;
}
4.插入和提取运算符
<< 左移运算符，因为被重载用于数据流的插入，所以又叫插入运算符；
>> 右移运算符，因为被重载用于从数据流中提取数据，所以又叫提取运算符；
插入运算符 << 和提取运算符 >> 不能重载为类的成员函数，可以重载为类的友元函数。
#include <iostream>
using namespace std;
class Point
{
int m_x;
int m_y;
friend ostream& operator<<(ostream&, const Point&);
friend istream& operator>>(istream&, Point&);
public:
// 带参构造函数
Point(int x, int y) : m_x(x), m_y(y)
{
}
// 拷贝构造函数
Point(const Point& point)
{
m_x = point.m_x;
m_y = point.m_y;
}
};
// 重载插入运算符<<
ostream& operator<<(ostream& cout, const Point& point)
{
cout << "(" << point.m_x << ", " << point.m_y << ")";
return cout;
}
// 重载提取运算符>>
istream& operator>>(istream& cin, Point& point)
{
cin >> point.m_x;
cin >> point.m_y;
return cin;
}
int main()
{
Point p1(10, 20);
Point p2 = p1;
cin >> p2;
cout << p2 << endl;
return 0;
}
5.拷贝赋值运算符
拷贝赋值运算符只能重载为类的成员函数，而不能把它重载为类的友元函数。
#include <iostream>
using namespace std;
class Point
{
int m_x;
int m_y;
public:
// 带参构造函数
Point(int x, int y) : m_x(x), m_y(y)
{
}
// 拷贝构造函数
Point(const Point& point)
{
m_x = point.m_x;
m_y = point.m_y;
}
// 拷贝赋值运算符
Point& operator=(const Point& point)
{
m_x = point.m_x;
m_y = point.m_y;
return *this;
}
};
int main()
{
Point p1(10, 20); // 带参构造函数
Point p2(30, 40); // 带参构造函数
Point p3 = p1; // 拷贝构造函数
p3 = p2; // 拷贝赋值运算符
return 0;
}
5.1 深拷贝
#include <iostream>
using namespace std;
class Car
{
private:
char* m_name;
public:
// 构造函数
Car(const char* name = NULL)
{
if (!name)
{
m_name = new char[1] {};
}
else
{
m_name = new char[strlen(name) + 1] {}; // 申请新的堆空间
strcpy(m_name, name); // 拷贝字符串数据到新的堆空间
}
}
// 拷贝构造函数
Car(const Car& car)
{
m_name = new char[strlen(car.m_name) + 1] {}; // 申请新的堆空间
strcpy(m_name, car.m_name); // 拷贝字符串数据到新的堆空间
}
// 拷贝赋值运算符
Car& operator=(const Car& car)
{
if (this == &car) return *this;
delete[] m_name; // 释放掉原区域
m_name = new char[strlen(car.m_name) + 1] {}; // 申请新的堆空间
strcpy(m_name, car.m_name); // 拷贝字符串数据到新的堆空间
return *this;
}
// 析构函数
~Car()
{
delete[] m_name;
m_name = NULL;
}
void display()
{
cout << "name is " << m_name << endl;
}
};
int main()
{
Car car1("bmw"); // 构造函数
Car car2("byd"); // 构造函数
Car car3 = car1; // 拷贝构造函数
car3 = car2; // 拷贝赋值运算符
car3.display();
return 0;
}
