标签：

搞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 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多做了那些事

#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;
}

#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++的运算符重载那些事

标签：

原文地址：http://blog.csdn.net/uestclr/article/details/51126112