注意：操作符重载可以当做==“自定义类的运算”==

1 为什么需要操作符重载？
对于基础的变量，int等，不需要重载就知道如何做，但是对于自定义类，就无法进行运算，比如复数类。

2 操作符重载总结
1）操作符重载本质上是一个函数，可以采用 友元函数或者成员函数实现。但是采用这两种函数传递参数、实现代码、应用场合均不同。

全局函数与成员函数的比较：
传递参数：全局函数中不传递this指针，成员函数默认传递this指针，因此成员函数可以少一个参数；
属性访问：成员函数可以访问私有变量，全局函数需要转化为友元函数才可以。
应用场合：正常写法采用成员函数。必须采用全局函数重载的运算符有<<和>>，必须采用成员函数重载的运算符有=、()、[ ]、->四个。

2）操作符重载的格式：

#全局函数
int operator+(const A& a1, const A& a2)
#成员函数
int operator+(const A& obj)

函数名为operator与运算符的组合（可变）；
输入为对象（可变，友元函数或成员函数实现）；
返回值可以为元素、对象或者引用（可变）。

3）可以重载的运算符

3 实例：实现complex类的±运算符重载

注意：
1）使用友元函数重载需要注意的是，二元运算则传递两个参数，同时添加friend关键字，使用成员函数只需要一个参数。

#include <iostream>
using namespace std;class Complex
{
public:Complex(int a, int b){this->a = a;this->b = b;}friend Complex operator+(const Complex& x1, const Complex& x2);void printC(){cout << "a: " << this->a << "b:" << this->b << endl;}Complex operator-(const Complex& obj){Complex tmp(this->a - obj.a, this->b - obj.b);return tmp;}
private:int a;int b;
};//友元函数重载
Complex operator+(const Complex& x1, const Complex& x2)
{Complex tmp(x1.a + x2.a, x1.b + x2.b);return tmp;
}
void main()
{Complex x1(1, 2);Complex x2(3, 4);Complex x3 = x1 + x2;x3.printC();Complex x4 = x2 - x1;x4.printC();cout << "hello,world..." << endl;system("pause");
}

4 实例：基于3实现Complex类的前置–以及后置++

注意：
1）后置++需要在参数列表中增加占位符int，Complex operator++(Complex& obj, int)。
2）后置++先使用后++，如a++，在具体实现时就要先使用临时变量tmp暂存输入，而后++，最后返回临时变量。
3）使用成员函数实现比友元函数实现少一个参数，这个参数通过this指针传递。
4）传递的变量最好在引用&前使用const，保持变量的内存空间不能改变。

#include <iostream>
using namespace std;class Complex
{
public:friend Complex operator+(const Complex& x1, const Complex& x2);friend Complex operator++(Complex& obj, int);Complex(int a, int b){this->a = a;this->b = b;}void printC(){cout << "a: " << this->a << "b:" << this->b << endl;}Complex operator-(const Complex& obj)//-{Complex tmp(this->a - obj.a, this->b - obj.b);return tmp;}//成员函数实现前置--Complex& operator--(){this->a++;this->b++;return *this;}
private:int a;int b;
};Complex operator+(const Complex& x1, const Complex& x2)
{Complex tmp(x1.a + x2.a, x1.b + x2.b);return tmp;
}//友元函数实现后置++,后置需要增加占位符
Complex operator++(Complex& obj, int)
{Complex tmp = obj;//其中如果有指针，那么需要注意浅拷贝obj.a++;obj.b++;return tmp;
}
void main()
{Complex x1(1, 2);Complex x2(3, 4);Complex x3 = x1 + x2;x3.printC(); //4,6--x3;Complex x4 = x2 - x1;x4.printC();//2,2Complex x5 = x4++;x4.printC();//3,3x5.printC();//2,2cout << "hello,world..." << endl;system("pause");
}

5 实例：实现Complex左移<<和>>右移操作符重载 （二元运算符两个参数不同的情况）

注意：
1）类似<<操作符重载，其为二元运算符，两个操作数类型不同，分别为ostream和Complex（比如）。
2）实现两个操作数类型不同的运算符重载要使用友元函数。

• 原因是，成员函数重载operator+，调用a+1时相当于调用的a.operator(1)，只能保证一种参数顺序的运算，两个参数更换位置就失败，如a+1，(a为Complex)，1+a就会报没有对应的运算符重载。
• 友元函数可以通过重载友元函数来实现，只调换换参数位置即可实现。

3）要实现链式编程，返回引用。cout<<a<<endl。

#include <iostream>
using namespace std;class Complex
{
public:friend ostream& operator<<(ostream& out, const Complex& obj);friend Complex operator+(const Complex& x1, int i);friend Complex operator+(int i, const Complex& x1);friend istream& operator>>(istream& in, Complex& obj);Complex(int a, int b){this->a = a;this->b = b;}void printC(){cout << "a: " << this->a << "b:" << this->b << endl;}Complex operator-(int i) //成员函数重载-{Complex tmp(this->a - i, this->b - i);return tmp;}private:int a;int b;
};Complex operator+(const Complex& x1, int i) //友元函数重载+  （1）
{Complex tmp(x1.a + i, x1.b + i);return tmp;
}
Complex operator+(int i, const Complex& x1)//友元函数重载+   （2）
{Complex tmp(x1.a + i, x1.b + i);return tmp;
}//友元函数实现重载<<左移操作符，输出，且只能采用友元函数
ostream& operator<<(ostream& out, const Complex& obj)//此处将ostream类型的out变量本身返回，以便后续的连续操作
{cout << obj.a << " + " << obj.b << "i" << endl;return out;
}#原来自己是这么实现的，但是不支持cin>>x1>>x2的链式编程的情况
// void operator>>(istream& in, Complex& obj)
// {
// 	in >> obj.a;
// 	in >> obj.b;
// }
istream& operator>>(istream& in, Complex& obj)
{in >> obj.a;in >> obj.b;return in;
}
void main()
{Complex x1(1, 2);Complex x2(2, 3);cout << x1 + 1 << endl;cout << 1 + x1 << endl;cout << x1 - 2 << endl;cin >> x1 >> x2;cout << x1 << endl;cout << "hello,world..." << endl;system("pause");
}

6 重载=等号操作符
有指针的类定义的对象，在等号=赋值时，采用C++的赋值，进行的是浅拷贝，导致两个对象的指针指向同一个内存空间，释放的时候出现问题。

#include <iostream>
using namespace std;class Name
{
public:Name(const char* p)//“asdb”{if (p == NULL){this->m_len = 0;this->m_p = new char[this->m_len + 1];strcpy(this->m_p, "");}else{this->m_len = strlen(p);this->m_p = new char[this->m_len + 1];strcpy(this->m_p, p);}}Name(const Name& obj){this->m_len = obj.m_len;this->m_p = new char[this->m_len + 1];strcpy(this->m_p, obj.m_p);}~Name(){if (this->m_len != NULL){delete[] this->m_p;this->m_p = NULL;this->m_len = 0;}}Name& operator=(const Name& obj)//重载等号操作符，实现连等，返回一个引用{if (this->m_p!=NULL) //先释放旧的指针{delete[] this->m_p;this->m_p = NULL;this->m_len = 0;}this->m_len = obj.m_len;this->m_p = new char[this->m_len + 1];strcpy(this->m_p, obj.m_p);return *this; }
protected:
private:char* m_p;int m_len;
};void main()
{Name obj("asdf");//双引号代表字符串，单引号代表字符，并且其可转化为int的ASCII码Name obj2("sdgf");Name obj3 = obj2;obj2 = obj;cout << "hello,world..." << endl;system("pause");
}

注意：
字符串传递使用双引号；
定义字符串变量或者形参，都要使用const关键字修饰；
在进行赋值时，要先释放旧的指针指向的空间，再赋值。

7 数组类案例

链接：数组类

8 字符串类案例

链接：字符串类

9 重载（）操作符

重载()操作符，在定义对象后，可以使用f()，类似于f.operator()操作。这种重载和python中的__call_ _()函数很像，可以给对象传参数，输出结果。

#include <iostream>
using namespace std;
class F
{
public:int operator()(int a, int b){return a + b;}
};
void main()
{F f;f(2, 4);cout << "hello,world..." << endl;system("pause");
}

10 不要重载&&以及||

作用于基础类型的&&和||有短路规则，但是经过重载后，就没有短路规则了，原因是重载是一种函数。

class Test
{
public:Test(int i = 0){this->i = i;}Test&  operator+(const Test& obj){this->i = this->i + obj.i;return *this;}bool operator&&(const Test& obj){return this->i && obj.i;}int getData(){return this->i;}
private:int i;
};
void main()
{Test t1(1);Test t2(2);t1 && (t1 + t2);//重载&&cout << "hello,world..." << endl;system("pause");
}

此处重载&&，但是仍然先计算+加号重载的操作符，后计算&&重载，而不是先判断t1。