搞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{//并不对这个对象进行修改，可以加上const
return 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;
}

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

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

相关推荐

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