关于c++的运算符重载那些事

搞c++有一段时间了，今天突然要重载一个运算符，发现自己有点忘了，遂查查资料做一下c++运算符重载的小总结。

一、何为运算符重载

运算符的重载是c++语言特有的，java什么的是没有运算符重载的，所以运算符重载在笔试面试中有可能成为c++的高频考点。运算符重载就是重新定义运算符的意义，如常用的+，-，×，÷都是可以重载的。运算符重载使用的是关键字operator，表现形式是：

                                                               返回值 operator重载的运算符（函数参数列表）

举一个简单的例子，有一个分数类，定义如下：

class Fraction{public:int x;//分子int y;//分母Fraction(int x = 0,int y = 1):x(x),y(y){}        void show(){cout << x <<"/" << y << endl;}}

比如定义了两个类Fraction fa，fb，你做一个fa+fb肯定是错误的，因为编译器会提示你+它不认识，但是这种分数相加在现实中又是非常合理的事情。所以我们必须要重新定义+的意思，以满足+在这种情况下的使用。在这里就该被这样定义;

                                                      Fraction operator+(const Fraction& fa,const Fraction& fb)

那么现在我们要明白的是，当编译器遇到fa+fb这种情况，编译器是如何去解析的？解析的规则如下：

碰到fa + fb的两种解析规则，首先去类的成员函数中找一个函数operator+(constFraction& fb),找不到则去全局区找一个全局函数operator+(constFraction& fa, const Fraction& fb)，这里的意思就是说，我们可以把重载函数写成成员函数的形式，也可以写成全局函数的形式，博主建议，能写成成员函数的就不要写成全局函数，而且最好只选取一种方案。上面的红色字体部分就是全局形式的+重载。

知道了上面的原理之后，我们首先来采用全局形式的重载。

Fraction addFraction(const Fraction& fa,const Fraction& fb){Fraction fc;fc.x = fa.x * fb.y + fa.y * fb.x;fc.y = fa.y * fb.y;return fc;//return Fraction(fa.x * fb.y + fa.y * fb.x,fa.y * fb.y);//简写}

/*下面的代码将提供对分数类Fraction的+,-,*,/的重载*/

/*运算符重载，分数类的运算符重载*/#include <iostream>using namespace std;class Fraction{public:int x;int y;Fraction(int x = 0,int y = 1):x(x),y(y){}/*只要能写成员函数就不写全局函数,编译器遇到fa+fb的时候，首先是fa，然后碰到+号所以说是按照顺序来的，即是fa调用了重载的成员函数，所以里面的this就是fa对象*/Fraction operator+(const Fraction& fb){Fraction c ;cout << this->x << this->y << fb.x << fb.y << endl;c.x = this->x * fb.y + this->y * fb.x;c.y = this->y * fb.y;return c;//return Fraction(this->x * fb.y + this->y * fb.x,this->y * fb.y);}/*设计成员函数完成两个分数的相减*/Fraction operator-(const Fraction& fb){return Fraction(this->x * fb.y - this->y * fb.x,this->y * fb.y);}/*设计成员函数实现两个分数相乘*/Fraction operator*(const Fraction& fb){//可以设计成任意返回值类型return Fraction(this->x * fb.x,this->y * fb.y);}/*完成两个分数*=*/void operator*=(const Fraction& fb){this->x *= fb.x;this->y *= fb.y;}void show(){cout << x <<"/" << y << endl;}};/*设计一个分数相加的函数，全局形式的重载*///Fraction addFraction(const Fraction& fa,const Fraction& fb){///*Fraction fc;//fc.x = fa.x * fb.y + fa.y * fb.x;//fc.y = fa.y * fb.y;//return fc;*///return Fraction(fa.x * fb.y + fa.y * fb.x,fa.y * fb.y);//简写//}/*设计一个函数返回double让一个分数和一个整数相加*/double operator+(const Fraction& fa,int x){double c;c = x+1.0*( fa.x / fa.y);cout << c << endl;return c;}void main(){Fraction fa(1,3);fa.show();Fraction fb(1,2);fb.show();//addFraction(fa,fb).show();Fraction fc = fb + fa;fc.show();//cout << &addFraction(fa,fb);//这句话说明了什么//Fraction fd = fa - fb;//fd.show();//Fraction fe = fa * fb;//fe.show();//fa *= fb;//fa.show();/////////////////////double res = fb + 100;//cout << res;}

二、输入、输出流运算符的重载<<,>>

以一个整数包装类Integer类为例

class Integer{
int data;
public:
Integer(int data = 0):data(data){}

}

如果对象是一个自定义类，则cin >> fa,cout << fa同样会让编译器报错。那么则需要重载这两个运算符。在上一节中我们说到，重载运算符有两种解析规则，首先在类的成员函数中找，然后才去找全局的重载函数。比如重载输出流运算符>>，先去ostream类型中，找一个成员函数叫做：operator<<(const Integer& i)，那么我们想一想，这个能找得到吗？ostream是系统提供的类，你的到ostream类中去添加这样一个成员函数，显然是非常困难的，所以输出，输出运算符最好的形式就是重载成全局形式。

/*采用全局函数重载<<运算符*/ostream& operator<<(ostream& os,const Integer& i){//如果以void作为输出不支持连续输出//return os << i.data;os << i.data;return os;}/*写出自己的输入流函数>>*/istream& operator>>(istream& is,Integer& i){//这里不能写const，输入就是的改这个对象is >> i.data;return is;}

三、关于对运算符重载的几点说明
包括二元运算符的重载，一元运算符的重载，明确重载的规则，明确哪些运算符可以重载，哪些不可以，哪些只能重载成成员形式，哪些又只能重载成全局形式。

一元运算符的重载的解析规则：首先去a对象找一个成员函数operator#(),如果找不到，就去全局找一个全局函数叫做operator#(a)，#代表所需要重载的一元运算符 ，在重载++，--时需要注意，前++和后++代表的意思是不同的，产生的效果也是不同的，所以是分别重载的，还有是否能连续的++，例如++（++a）这种形式。

/*几个一元运算符的重载*/#include <iostream>using namespace std;class Integer{int data;public:Integer(int data = 0):data(data){}/*！运算符的重载*/Integer operator!(){return Integer(!data);//return !data; 当一个类型中出现了单参构造函数时，这里有默认的类型转换}/*-,~,++,--运算符的重载*/Integer operator-(){return Integer(-data);}/*++运算符的重载，默认是前++*/Integer& operator++(){     //注意，如果这里返回的不是引用，main函数中有什么效果data++;return *this;}/*设计后++的重载*/const Integer operator++(int)   //哑元{return Integer(data++);}friend Integer& operator--(Integer& i);friend const Integer operator--(Integer& i,int);friend ostream& operator<<(ostream& os,const Integer& i){return os << i.data;}};/*现在考虑重载全局形式的前--和后--*/Integer& operator--(Integer& i){i.data--;return i;}const Integer operator--(Integer& i,int){return Integer(i.data--);}int main(){Integer ia(100);cout << !ia << endl;cout << !!ia<< endl;cout << -ia << endl;cout << ++(++ia)<< endl;     //返回void则不支持连续++cout << ia << endl; //cout <<  ia++ << endl;在没有重载后++，这句话在Ubuntu下是通不过的，不支持后++，vs可以通过，但是结果不对//重载了后++之后cout << ia++<< endl;//加上const后可以防止连续的后++cout << ia<< endl;/*那么连续的后++有没有意义，连续的后++在c语言中是编译不过的，支持连续的前++*//*全局形式的前--后--的重载*/cout << --ia<<endl;cout << ia << endl;cout << ia--<<endl;cout << ia<< endl;}

四、运算符重载的限制

不能重载的运算符包括

                  1、 ::(作用域)

                  2、.(成员运算符)

                  3、.*成员指针解引用

                  4、Sizeof（类型大小）

                  5、? :三元运算符

                  6、Typeid 获取类型的信息（返回值类型typeinfo）

只能对已有的运算符进行重载，不能发明新的运算符；

不能对基本类型进行运算符重载（运算符重载中至少有一个类型是非基本类型）；

不能改变运算符的运算特性；不能把一元的改成二元的；

五、只能是重载成成员形式的运算符：=，[],()（最好是成员+=，-=，/= ,*,->等。

赋值运算符=的重载有些麻烦，因为这里必须涉及到内存的操作，以及深浅拷贝的问题。看下面的代码

#include <iostream>using namespace std;class Array{int size;    //用于记录最后有数据的空间的实际大小int len;     //用于标记分配的空间大小int *datas;public:explicit Array(int len = 5):len(len),size(0){//explicit防止隐式转换//分配内存datas = new int[len];}~Array(){delete[] datas;datas = NULL;}//拷贝构造函数Array(const Array& arr){//处理内存独立性size = arr.size;len = arr.len;//申请新内存datas = new int[len];for (int i = 0; i < size; i++){datas[i] = arr.datas[i];}}void push_data(int d){if (size >= len){//扩容expend();//expend为什么没有前置声明就可调用，记住在类内进行操作的函数不需要进行前置声明}datas[size++] = d;//如果size大于了预分配空间，则要进行扩容操作}void expend(){int *temp = datas;                       //保留机制len = 2 * len + 1;datas = new int[len];                    //datas被重新分配空间for (int i = 0; i < size; i++){datas[i] = temp[i];}delete[] temp;                           //释放掉中间值，这个过程注意}void show(){if (0 == size){cout << "[]" << endl;return;}for (int i = 0; i < size - 1; i++){cout << datas[i] << ',';}cout << datas[size - 1] << endl;}//重载=运算符Array& operator=(const Array& arr){if (this != &arr){//防止把自己赋值给自己size = arr.size;len = arr.len;int *temp = datas;//重新申请内存datas = new int[len];//赋值数据for (int i = 0; i < size; i++){datas[i] = arr.datas[i];}//释放原来自己的内存delete[] temp;}return *this;}//重载[]运算符,根据下标取数据int operator[](int ind)const{//并不对这个对象进行修改，可以加上constreturn datas[ind];}};void main(){//Array arra = 20;//防止了隐式转换，编译不过，如果不加explicit就编译过了Array arra;arra.push_data(9);arra.push_data(5);arra.push_data(2);arra.push_data(7);cout << arra[0] << endl;cout << arra[10] << endl;//越界//Array arrb = arra;这种解析方式会去找拷贝构造函数//arrb.show();Array arrb;arrb = arra;//会用运算符重载的方式解析，如果没有提供=重载，会用系统提供的逐字节拷贝方式arrb.show();//程序崩了,被重载了之后不会报错，也不会崩溃}

在上面的代码中，如果遇到arrb= arra且我们没有提供赋值运算符重载的时候，那么编译器会采用默认的处理方式，就是逐字节拷贝，那么这种拷贝方式在处理datas堆内存时会遇到什么问题呢？len，size，datas等成员变量依次被覆盖掉，那么此时arrb的成员datas所指向的堆内存就和arra的datas指向的堆内存一样了，那么原来arrb的datas所指向的堆内存就泄露了。这就是这里比较严重的问题。

六、圆括号运算符()的重载

我们在写程序的时候经常喜欢这样用int x = (int)y,这里的y不是int类型，这是强制的类型转换，但是如果我们定义了一个产品类Product，它拥有成员int count代表产品的数量，double price代表产品的价格，如果在开发中我们想把这个Product转换成int类型，那么显而易见，对于开发者来说我们想要取得的是产品的数量。如果我们想把Product转成double型，同样我们肯定是希望获得其价格。

所以圆括号的重载在开发中用途广泛，它的作用就是把一个单参类型转换成当前对象类型。

语法格式：圆括号既然只能是成员形式，那么我们肯定这样想：int operator()(){},但是这是不行的，编译器不认可，圆括号的重载有固定的格式：operator 类型(){

             return 对象类型

       }

如果要重载圆括号返回int的话，就得这样写：

operator int(){

return count;

}

/*圆括号运算符的重载，把一个单参类型转换成当前对象类型*//*圆括号运算符的重载*//*operator 类型(){return 类型的对象}*/#include <iostream>using namespace std;class Product{int count;double price;public:Product(int count = 0, double price = 0.0) :count(count), price(price){}/*重载()运算符*///我们一般会这样写,这种写法编译器不会认可的//int operator()(){//return count;//}//但是得这样写,固定形式，没有为什么operator int(){return count;}/*转换成double的圆括号重载*/operator double(){return price;}};int main(){Product product(100, 1.15);/*现在如果我们想把这个product变成整数，我们想要的肯定是数量*/int count = (int)product;cout << count << endl;double price = (double)product;cout << price << endl;}

七、new delete运算符的重载

首先的明白一个问题就是new和delete比malloc和free多做了那些事

如果类的成员变量是类类型，则自动创建这个成员，自动调用构造函数。

delete 会去调用析构函数，free不会.

#include <iostream>using namespace std;/*这种情况下如果c的编译器求sizeof（A）其大小是0而用c++的编译器求siziof（A）则是1.这里表现出了编译器对待内存分配的差异,我觉得这些细小的知识点展现出了一名优秀c++程序设计的人员的素质*/class A{public:A(){ cout << "A()" << endl; }~A(){ cout << "~A()" << endl; }};class B{A a;public:B(){ cout << "B()" << endl; }~B(){ cout << "~B()" << endl; }};int main(){B* pb = static_cast<B*>(malloc(sizeof(B)));B * pb2 = new B();free(pb);delete pb2;}

重载new delete：

固定写法：void * operator new(size_t size)

                  void operator delete(void * ptr)

#include <iostream>#include <cstdlib>using namespace std;class Date{int year;int month;int day;public:Date(int year = 0, int month = 0, int day = 0) :year(year), month(month), day(day){cout << "Date()" << endl;}~Date(){ cout << "~Date()" << endl; }};/*放到成员和全局是一样的*/void* operator new(size_t size){//具有自动识别大小的功能cout << "my operator new" << size << endl;return malloc(size);}void operator delete(void* ptr){cout << "operator delete" << endl;free(ptr);}int main(){Date * date = new Date();delete date;}