第一节 运算符重载的基本概念

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.重载运算符()、[]、->或者赋值运算符=时，运算符重载函数必须生命为成员函数。