c++ &运算符的重载函数

运算符的重载实际上是一种特殊的函数重载，必须定义一个函数告诉c++编译器，当遇到该重载的运算符时运用此函数，这个函数叫做运算符重载函数，通常为类的成员函数。
赋值运算符的重载函数的一般格式为：
返回值类型 类名::operator重载的运算符（参数表）{}

首先我们来设计一个Int的类，写一个简单的对对象里的成员属性进行相加的操作：

class Int
{
private:
	int value;
public:
	Int(int x=0):value(x){}
	Int(const Int & it):value(it.value){}
	~Int(){}
	int Getvalue()//得到对象的value值
	{
		return value;
	}
	void Setvalue(int x)//修改对象的value值
	{
		value=x;
	}
	//改写；Int Add(Int * const this,Int x)
	Int Add(Int x)
	{
		this->value+=x.value;
		return *this;
	}
};
int main()
{
	Int a(10),b(20),c;
	c=a.Add(b);
	//改写：c=Add(&a,b)
	cout<<"a:"<<a.Getvalue()<<endl;
	cout<<"b:"<<b.Getvalue()<<endl;
	cout<<"c:"<<c.Getvalue()<<endl;
	return 0;
}

从这个运行结果来看，对象c的value值确实为30，但是同时我们也可以看到对象a初始化的value值是10，进行相加操作以后它的值确变成了30，在内置类型中，比如说int类型，做完两个数的相加之后，原本的两数的值不会变，在这里面向对象编程也要和内置类型保持一致。因此上面那种写法是不正确的，我们对Add这个成员函数作如下的修改：

Int Add(Int x)
	{
		int value=this->value+x.value;
		Int tmp(value);
		return tmp;
	}

这个成员函数最终返回一个对象，但在返回时我们在上一条博客《c++ &拷贝构造函数》中讲到的，它需要调用拷贝构造函数在主函数的栈帧上生成一个临时对象，但是在return之前，又要调用构造函数在Add函数的栈帧上创建tmp对象，整个过程创建了两次对象。下面我们将对这个Add函数再次进行改写，使得对象被创建依次就可以达到同样的效果：

//改写：Add(const Int * const this,const Int &x)
Int Add(const Int &x) const
	{
		int val=this->value+x.value;
		return Int(val);
	}
int main()
{
	Int a(10),b(20),c;
	c=a.Add(b);
	//改写：c=Add(&a,b)
	return 0;
}

我们可以看到，首先对参数x加了引用，这样做可以使得系统不会再去调动拷贝构造函数创建x这个对象，而是实参的一个别名；除此之外，我们还可以发现，在return之前系统不会在Add函数的栈帧上去创建对象了，而是直接在主函数的栈帧创建临时对象，提高程序的效率。
给形参加上const关键字是为了防止通过对x对象的修改而修改了b对象.第二个const指的是这个类的成员方法是一个常方法，所谓常方法就是对象在调动这个常方法时不能改变对象属性的值,只能读取对象的属性值。
要注意的一点是，不能对外部函数加const,外部函数不是类的成员没有this指针，常性方法是对this指针的修饰。

了解完这个之后，我们将两个对象的加法写成运算符重载形式，如下所示：

class Int
{
private:
	int value;
public:
	Int(int x=0):value(x){}
	Int(const Int & it):value(it.value){}
	~Int(){}
	int Getvalue()
	{
		return value;
	}
	void Setvalue(int x)
	{
		value=x;
	}
	Int operator+(const Int & x) const
	//operator+整体相当于函数名
	{
		int val=this->value+x.value;
		return Int(val);
	} 
	Int operator+(int x) const
	{
		int val=this->value+x;
		return Int(val);
	}
};
int main()
{
	Int a(10),b(20),c;
	//对象+对象
	c=a+b;//与内置类型保持一致
	//还可以写成函数形式如下：
	//c=a.operator+(b);
	//编译器将其改写为c=operator+(&a,b);
	int x=100;
	Int d=a+x;//对象+内置类型
	cout<<"a:"<<a.Getvalue()<<endl;
	cout<<"b:"<<b.Getvalue()<<endl;
	cout<<"c:"<<c.Getvalue()<<endl;
	return 0;
}

从运行结果来看，没有出现首次a对象的成员属性值被改变成30的情况。

实际上，在C语言中也是存在运算符的重载的，比如说我们今天主要讲到的加法重载，C语言中可以对两个整型数据相加，可以对两个double类型数据相加，也可以对两个float类型数据相加，只是这种重载是由系统控制的，而程序员控制不了。

需要注意的是，若运算符重载函数是类的成员函数时，不能让内置类型的变量和一个对象进行加减法等操作，会造成参数过多而编译出错。也就是说当重载的运算符为双目运算符时，重载函数的第一个参数必须是对象，而不能是变量。如下分析。

解决这种参数过多的问题需要将这个函数设为全局函数，然后返回的时候以”对象+变量“的形式返回，这样就可以调用类成员函数中的运算符重载函数了。

//全局函数
Int operator+(int x,const Int &y)
{
    return y+x;//调用类成员函数中的赋值运算符重载函数
}

接下来我们来看一下单目运算符前置++和后置++的重载，在c++中，为了区分前置++和后置++，前置++不需要参数，后置++多了一个参数。代码如下：

	Int &operator++()
	{
		this->value+=1;
		return *this;
	}
	//x++
	Int operator++(int)
	{
		int val=this->value;
		this->value+=1;
		return Int(val);
	}

在c++中只有极少数运算符不允许重载，如下表列出的：

还比如说#、//、##、/**/等一些注释符不允许重载。