第一节 运算符重载的基本概念
C++预定义的运算符，只能用于基本数据类型的运算。基本数据类型包括：整型、实型、字符型、逻辑型等。
在数学上，两个复数可以直接进行+、-运算，但是在C++中，直接将+、-用在复数对象是不允许的。
有时候也会希望让对象也能通过运算符进行运算，这样代码更简洁、更容易理解，这个时候就需要运算符的重载了。
运算符重载的目的是：扩展C++中提供的运算符的适用范围，使之能作用于对象。
它的实质是函数重载。可以重载为普通函数，也可以成员函数。
把含运算符的表达式转换成对运算符函数的调用，把运算符的操作数转换成运算符函数的参数。
运算符被多次重载时，根据实参的类型决定调用哪个运算符函数。
运算符重载的形式：
返回值类型 operator 运算符(形参表)
{
//函数体
}
如下例：
class Complex{
public:
double real,imag;
Complex(double r = 0.0, double i = 0.0):real(r),imag(i){ }
Complex operator-(const Complex & c);
};
Complex operator+(const Complex &a, const Complex &b){
return Complex(a.real + b.real,a.imag + b.imag);//返回一个临时对象
}
Complex Complex::operator-(const Complex &c)
{
return Complex(real – c.real, imag – c.imag);//返回一个临时对象
}
int main(){
Complex a(4,4),b(1,1),c;
c = a + b;//等价于c = operator+(a,b);
cout << c.real <<“,” <<c.imag << endl;
cout<<(a-b).real << “,” << (a-b).imag << endl;
//a-b等价于a.operator-(b)
return 0;
}注意：重载为成员函数时，参数个数为运算符目数减一（另一个就是我调用这个成员函数的对象）；重载为普通函数时，参数个数为运算符目数。
第二节 赋值运算符的重载
1.赋值运算符“=”的重载
有时候希望赋值运算符两边的类型可以不匹配，此时就需要重载赋值运算符“=”。赋值运算符“=”只能重载为成员函数。
例程如下：
class String{
private:
char * str;//指向动态分配的数组
public:
String():str(new char[1]){str[0] = 0;}
const char * c_str(){return str;};
String & operator = (const char*s);
String::~String(){delete [] str;}
};
String &String::operator = (const char *s)
{
//重载=以使obj=”hello”能够成立
delete[] str;
str = new char[strlen(s)+1];
strcpy(str,s);
return * this;
}
int main()
{
String s;
s = “Good luck,”;//等价于s.operator=(“Good Luck,”);
cout<<s.c_str()<<endl;
//String s2 = “hello!”;//这条语句不注释掉就会出错
s = “Shenzhou 8!”;//等价于s.operator=(“Shenzhou 8!”);
cout <<s.c_str()<<endl;
return 0;
}
对重载函数进行解释。首先把str给delete掉，然后给str重新分配一个空间，大小为s字符串的大小+1，然后把s的值复制给str，返回一个本身的引用。要注意，“=”已经被重载，再编写String s2 = “hello!”后，=已经不是赋值语句，所以必然会出错。
2.相关其它内容
如下代码：
class String{
private:
char * str;//指向动态分配的数组
public:
String():str(new char[1]){str[0] = 0;}
const char * c_str(){return str;};
String & operator = (const char*s){
delete [] str;
str = new char[strlen(s)+1];
strcpy(str,s);
return * this;
};
String::~String(){delete [] str;}
};
我们在主函数里面要实现下面功能：
String S1,S2;
S1=”this”;
S2=”that”;
S1=S2;
在没有重载“=”的时候，S1=S2也可以编译通过，因为它们类型完全相同的。但是，这个“=”会使S1每一点都和S2一样。那么，这会有什么问题呢？让我们一步一步分解来看。
首先执行String S1,S2；S1=”this”;S2=”that”;那么就会实现这样的效果：
图2.1 S1=”this”;S2=”that”;
再执行S1=S2，我们发现成了这个样子：
图2.2 S1=S2的结果
即S1实际上是指向了S2，两者实际上只指向的一个，原来S1的空间失去了指向，与我们想让S1中的内容（所指向的空间的内容）和S2一样的想法完全不一样。
如果S1对象消亡，析构函数将释放 S1.str 指向的空间，则S2消亡时还要释放一次，相当于delete S2了两次。
如果执行S1=”other”，会导致S2.str指向的地方被delete掉。所以重载之后，可以避免这样的问题。
考虑下面的语句：
String s;
s = “Hello”;
s = s;
会有什么问题呢？我们重新看重载“=”的成员函数，发现函数第一句和就是把等号左侧对象的空间给delete掉了，这在普通的语句下没有什么问题，但是在这里，赋给等号左边对象值的那个对象也是它本身，这样delete掉之后，后面的strcpy函数就无法复制正确的值给左侧的对象了。为了解决这个问题，需要在这个重载成员函数的函数体开头添加以下语句：
if(this == &s)
return *this;
接下来对operator=的返回值类型进行讨论。当对运算符进行重载的时候，好的风格是应该尽量保留运算符原来的特性。
我们考虑a=b=c，若是void，那么b=c返回值类型就是void，就没办法再执行a=操作了，所以可以用String类型。
再考虑(a=b)=c。先执行a=b，在C++里面，执行=的返回值是左侧元素的引用，所以(a=b)的结果是一个a的引用，对a的引用赋值为c，那么这个b毫无用处。因此不能用String，而是用String &这样一个引用格式。this是当前对象的地址，那么*this就是当前对象，这解释了为什么要用*this的原因。
为String类编写复制构造函数的时候，会面临和“=”同样的问题（两个对象指向同一个空间），用他同样的方法处理：
String(String &s)
{
str = new char[strlen(s.str)+1];
strcpy(str,s.str);
}
关于浅拷贝和深拷贝待补充
第三节 运算符重载为友元
一般情况下，将运算符重载为类的成员函数是较好的选择。但有时，重载为成员函数并不能满足使用要求，重载为普通函数，又不能访问类的私有成员，所以需要将运算符重载为友元。
如下代码：
class Complex
{
double real,imag;
public:
Complex(double r, double i):real(r),imag(i){};
Complex operator+(double r);
};
Complex Complex::operator+(double r)
{
return Complex(real+r,imag);
}
经过重载以后，c=c+5有意义，相当于c=c.operator+(5)
但是，c=5+c就会出错。所以，为了使得上述表达式成立，需要将+重载为普通函数，这样c=5+c就可以通过了。但是普通函数又不能访问私有成员，即不能计算c=c+5。这样，我们只能用重载为友元函数了。如下：
class Complex
{
double real,imag;
public:
Complex(double r, double i):real(r),imag(i){};
friend Complex operator + (double r, const Complex & c);
};
Complex Complex::operator+(double r)
{
return Complex(real+r,imag);
}
第四节 运算符重载实例：可变长整型数组
如下代码：
int main(){//要编写可变长整型数组类，使之能如下使用
CArray a;//开始数组是空的
for(int i = 0; i < 5;++i)
a.push_back(i);//要用动态分配的内存来存放数组元素需要一个指针成员变量
CArray a2,a3
a2 = a;//要重载”=”，把a中的值复制给a2
for(int i = 0; i<a.length;++i)
cout<<a2[i]<<“”;//要重载[]，因为a2原来是一个对象
a2 = a3;//a2是空的，因为原来的空间被释放了
for(int i = 0;i<a2.length;++i)//a2.length()返回0
cout<<a2[i]<<“”;
cout<<endl;
a[3]=100;
CArray a4(a);
CArray A4(A);//要自己写复制构造函数
for(int i = 0; i<a4.length;++i)
cout<<a4[i]<<“”;
return 0;
}
class CArray{
int size;//数组元素的个数
int *ptr;//指向动态分配的数组
public:
CArray(int s = 0);//s代表数组元素的个数
CArray(CArray &a);
~CArray();
void push_back(int v);//用于在数组尾部添加一个元素v
CArray & operator=(const CArray &a);
//用于数组对象间的赋值
int length(){return size;}//返回数组元素个数
int & CArray::operator[](int i)
//返回值不能为int，不支持a[i]=4，双目运算符，但是在类内，只有一个运算符
{//用以支持根据下标访问数组元素，如n=a[i]和a[i]=4这样的语句
return ptr[i];
}
};
CArray::CArray(int s):size(s)
{//构造函数
if(s ==0)
ptr = NULL;
else
ptr = new int[s];
}
CArray::CArray(CArray &a){//复制构造函数，要实现深复制
if(!a.ptr){
ptr = NULL;
size = 0;
return;
}
ptr = new int [a.size];
memcpy(ptr,a.ptr,sizeof(int)*a.size);
size = a.size;
}
CArray：：~CArray()
{
if(ptr) delete [] ptr;
}
CArray & CArray::operator=(const CArray &a)//深拷贝，而不是浅拷贝
{//赋值号的作用是使“=”左边对象里存放的数组，大小和内容都和右边的对象一致。
if(ptr == a.ptr)
return *this;//防止前文所述的出错
if(a.ptr == NULL){//如果a里面的数组是空的
if(ptr) delete[] ptr;
ptr = NULL;
size =0;
return *this;
}
if(size <a.size){//如果原有空间不够，则新建一个足够大的空间
//如果足够大，就不分配新的空间直接执行if后面的语句
if(ptr)
delete [] ptr;
ptr = new int[a.size];
}
memcpy(ptr,a.ptr,sizeof(int)*a.size);//空间大小为数目*一个int的字节数
size = a.size;
return *this;
}
void CArray::push_back(int v)
{//在数组尾部添加一个元素。先判断原来是否有元素，如果有元素，就新建一个临时空间，
//然后把原来的元素复制过来，然后删除原来的空间，然后把ptr指针指向了tmpPtr这个临时空间
//这个元素非常浪费资源
if(ptr){
int *tmpPtr = new int[size+1];//重新分配空间
memcpy(tmpPtr,ptr,sizeof(int)*size);//拷贝原数组内容
delete[] ptr;
ptr = tmpPtr;
}
else
ptr = new int[1];//数组原来是空的
ptr[size++] = v;//加入新的数组元素
}
第五节 流插入运算符和流提取运算符的重载
问题1：cout<<5<<”this”为什么能够成立？
问题2：cout是什么？<<为什么能用在cout上？
1.流插入运算符的重载
cout是在iostream中定义的ostream类的对象。之所以<<能用在cout上是因为，在iostream中对<<进行了重载。
考虑到我们要执行对5的操作也要执行对this的操作，如果我们定义的重载函数返回值为void或者int类型，都无法保证后面的两次甚至更多输出能够成立。但是如果我们将其定义为ostream类型的话，那么对5操作后，还是ostream类型，那么就可以继续对this操作了，因此要把返回值类型定义为ostream。即下面的格式：
ostream & ostream::operator<<(int n)
{
//代码
return *this;
}
ostream & ostream::operator<<(const char *s)
{
//代码
return *this;
}
cout<<5<<”this”本质上的函数调用形式是：
cout.operator<<(5).operator<<(“this”);
例1：假定下面程序输出为5hello，该补写些什么？
class CStudent{
public: int nAge;
};
int main(){
CStudent s;
s.nAge = 5;
cout << s <<“hello”;
return 0;
}
需要重载左移运算符，如下：
由于<<已经在ostream中成员函数重载，因此在这里我们只能定义为全局函数进行重载，所以需要两个参数。如下面代码所示，o其实就是对象cout。
ostream & operator<<(ostream & o, const CStudent & s){
o<<s.nAge;
return o;
}
例题2：假定c是Complex复数类对象，现在希望写”cout << c;”，就能以”a+bi”的形式输出c的值；写“cin>>c”就能从键盘接受“a+bi”形式的输入，并且使得c.real = a，c.imag = b。
int main(){
Complex c;
int n;
cin >> c >> n;
cout << c << “,” <<n;
return 0;
}
程序运行结果可以如下：
输入：13.2+133i 87
输出：13.2+133i,87
代码如下：
#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
class Complex{
double real,imag;
public:
Complex(double r=0,double i =0):real(r),imag(i){};
friend ostream & operator<<(ostream & os, const Complex &c);
friend istream & operator >>(istream & is, Compex & c);
};
ostream & operator <<(ostream & os, const Complex & c)
{
os<<c.real<<“+”<<c.imag<<“i”;
return os;
}
istream & operator >>(istream & is, Complex & c)
{
string s;
is >> s;//将”a+bi”作为字符串读入，中间不能有空格
int pos = s.find(“+”,9);
string sTmp = s.substr(0,pos);//分离出代表实部的字符串
c.real = atof(sTmp.c_str());//atof库函数能讲const char*指针指向的内容转换成float
sTmp = s.substr(pos+1,s.length()-pos-2);//分离出代表虚部的字符串
c.imag = atof(sTmp.c_str());
return is;
}
int main(){
Complex c;
int n;
cin >> c >> n;
cout << c << “,” <<n;
return 0;
}
选择题：重载“<<”用于将自定义的对象通过cout输出时，以下说法正确的是：
C 可以将“<<”重载为全局函数，第一个参数以及返回值，类型都是ostream &。
第六节 类型转换运算符的重载
代码如下：
#include <iostream>
using namespace std;
class Complex{
double real,imag;
public:
Complex(double r=0,double i =0):real(r),imag(i){};
operator double(){return real;}//类型转换运算符重载时不写返回值类型，因为返回值类型就是它本身
};
int main()
{
Complex c(1.2,3.4);
cout << (double)c <endl;//输出1.2
double n = 2 + c;//c被自动用类型转换运算符，等价与double n = 2+c.operator double()
cout << n;//输出3.2
}
第七节 自增自减运算符的重载
自增运算符++、自减运算符–有前置/后置之分，为了区别所重载的是前置运算符还是后置运算符，C++规定：
（1）前置运算符作为一元运算符重载：
重载为成员函数时：
T & operator++()
T & operator—()
重载为全局函数时：
T1 & operator++(T2)
T1 & operator—(T2)
（2）后置运算符作为二元运算符重载，多写一个没用的参数int：
重载为成员函数时：
T operator++(int)
T operator–(int)
重载为全局函数时：
T1 operator++(T2, int)
T1 operator–(T2, int)
但是在没有后置运算符重载而有前置运算符重载的情况下，在vs中，obj++也调用前置重载，而dev则令obj++编译出错。
例题1：
int main()
{
CDemo d(5);
cout<(d++) <<“,”;//等价于d.operator++(0);
cout << d << “,”;
cout << (++d) << “,”;//等价于d.operator++();
cout << d << endl;
cout << (d–) << “,”;//等价于d.operator–(0);
cout << d << “,”;
cout << (–d) << “,”;//等价于d.operator–();
cout << d << endl;
return 0;
}
输出结果：
5,6,7,7
7,6,5,5
如何编写CDemo？
class CDemo{
int n;
public:
CDemo(int i=0):n(i){}
CDemo & operator++();//前置形式++n返回值就是n的引用，所以这里要用引用
CDemo operator++(int);//后置形式，n++返回的是一个临时变量，所以这里不能用引用
operator int(){return n;}
friend CDemo & operator–(CDemo &);
friend CDemo operator–(CDemo &, int);
};
CDemo & CDemo::operator++():
{//前置
n ++;
return *this;
}
CDemo CDemo::operator++(int k):
{//后置
CDemo tmp(*this);//记录修改前的对象
n++;
return tmp;//返回修改前的对象
}//s++即为s.operator++(0);
CDemo & operator–(CDemo & d){//前置
d.n–;
return d;
}
CDemo operator–(CDemo &d, int){//后置
CDemo tmp(d);
d.n–;
return tmp;
}//s–即为operator–(s,0)
可以看出，前置操作因为少一个步骤，所以运算速度快于后置操作。所以提倡写++i。
运算符重载的注意事项：
1.C++不允许定义新的运算符；
2.重载后运算符的含义应该符合日常习惯；
3.运算符重载不改变运算符的优先级；
4.以下运算符不能被重载：“.”、“.*”、“::”、“?:”、sizeof；
5.重载运算符()、[]、->或者赋值运算符=时，运算符重载函数必须生命为成员函数。
