#include <iostream>
using namespace std;
class Test
{
public:
Test(int a = 0)
{
Test::a = a;
}
Test(Test &temp)
//运算符重载函数为值返回的时候会产生临时变量，临时变量与局部变量result的复制会调用拷贝构造函数，//add by ralf 这里是自动调用的
//临时变量的生命周期是在拷贝构造函数运行完成后才结束，但如果运算符重载函数返回的是引用，那么不会产生临时变量，
//而局部变量result的生命周期在运算符重载函数退出后立即消失，它的生命周期要比临时变量短，
//所以当外部对象获取返回值的内存地址所存储的值的时候，获得是一个已经失去效果的内存地址中的值，
//在这里的值返回与引用返回的对比，证明了临时变量的生命周期比局部变量的生命周期稍长。
{
cout<<"载入拷贝构造函数"<<"|"<<temp.a<<endl;//注意这里，如果修改运算符重载函数为返回引用，这里就会出现异常，temp.a将获得一个随机值。但是我没有证实？？？ 只是如果返回引用后，那么我们自定义的运算符重载将不再调用此拷贝函数，但是原来=运算符还会调用，而且赋值结果不会错！！
Test::a = temp.a;
}
~Test()//在mian()内析构的过程是result局部变量产生的
{
cout<<"载入析构函数!"<<endl;
//cin.get();
}
Test operator +(Test& temp2)//+运算符重载函数
{
//cout<<this->a<<endl;
Test result(this->a+temp2.a);
return result;
}
//可以试试用这句代码替换下面的。Test& operator ++()
//特别注意如果不要引用，那么返回值会在函数结束后立马就析构了……如果用引用那么产生的临时对象变量最后才后析构!!!!!
Test operator ++()//++运算符重载函数
//递增运算符是单目运算符，使用返回引用的运算符重载函数道理就在于它需要改变自身。
//在前面我们学习引用的单元中我们知道，返回引用的函数是可以作为左值参与运算的，这一点也符合单目运算符的特点。
//如果把该函数改成返回值，而不是返回引用的话就破坏了单目预算改变自身的特点，程序中的++(++c)运算结束后输出c.a，
//会发现对象c只做了一次递增运算，原因在于，当函数是值返回状态的时候括号内的++c返回的不是c本身而是临时变量，
//用临时变量参与括号外的++运算，当然c的值也就只改变了一次。
{ his->a++; return *this; }
public: int a; };
int main() {
Test a(100);
Test c=a+a;
cout<<c.a<<endl;
c++;
cout<<c.a<<endl;
++c;
cout<<c.a<<endl;
++(++c);
cout<<c.a<<endl;
// cout<<a.a<<endl;
system("pause"); }
__________________________________________________________________
例子程序：
#include <iostream>
using namespace std;
class com{
private:
int real;
int img;
public:
com(int real = 0, int img = 0){
this->real = real;
this->img = img;
}
void com_add(com &x, com &y, com &z){
z.real = x.real + y.real;
z.img = x.img + y.img;
}
com operator + (com x){
return com(this->real + x.real, this->img + x.img);
}
/*
com operator + (com & x){
return com(this->real + x.real, this->img + x.img);
}
*/
/*
//warning C4172: returning address of local variable or temporary
com & operator + (com & x){
return com(this->real + x.real, this->img + x.img);
}
*/
com operator + (int x){
return com(this->real + x, this->img);
}
friend com operator + (int x, com y);
void show(){
cout << real << "," << img << endl;
}
};
com operator +(int x, com y){
return com(x + y.real, y.img);
}
int main()
{
com a, b(1, 2), c(2, 3);
a = b + c;
a.show();
a.com_add(b, c, a);
a.show();
a = b + 3;
a.show();
a = 3 + c;
a.show();
}
注意：com & operator + (com & x)
在类成员函数中重载运算符是不允许返回引用的，会出现“返回局部变量的地址”警告。
但是对于函数 void com_add(com &x, com &y, com &z)则可以。
C++中预定义的运算符的操作对象只能是基本数据类型。但实际上，对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引人的特性之一。
运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似，惟一的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。运算符函数定义的一般格式如下：
<返回类型说明符> operator <运算符符号>(<参数表>)
...{
<函数体>
}
运算符重载时要遵循以下规则：
(1) 除了类属关系运算符"."、成员指针运算符".*"、作用域运算符"::"、sizeof运算符和三目运算符"?:"以外，C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
(3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造，重载的功能应当与原有功能相类似，避免没有目的地使用重载运算符。
运算符函数重载一般有两种形式：重载为类的成员函数和重载为类的非成员函数。非成员函数通常是友元。（可以把一个运算符作为一个非成员、非友元函数重载。但是，这样的运算符函数访问类的私有和保护成员时，必须使用类的公有接口中提供的设置数据和读取数据的函数，调用这些函数时会降低性能。可以内联这些函数以提高性能。）
成员函数运算符
运算符重载为类的成员函数的一般格式为：
<函数类型> operator <运算符>(<参数表>)
...{
<函数体>
}
当运算符重载为类的成员函数时，函数的参数个数比原来的操作数要少一个（后置单目运算符除外），这是因为成员函数用this指针隐式地访问了类的一个对象，它充当了运算符函数最左边的操作数。因此：
(1) 双目运算符重载为类的成员函数时，函数只显式说明一个参数，该形参是运算符的右操作数。
(2) 前置单目运算符重载为类的成员函数时，不需要显式说明参数，即函数没有形参。
(3) 后置单目运算符重载为类的成员函数时，函数要带有一个整型形参。
调用成员函数运算符的格式如下：
<对象名>.operator <运算符>(<参数>)
它等价于
<对象名><运算符><参数>
例如：a+b等价于a.operator +(b)。一般情况下，我们采用运算符的习惯表达方式。
友元函数运算符
运算符重载为类的友元函数的一般格式为：
friend <函数类型> operator <运算符>(<参数表>)
...{
<函数体>
}
当运算符重载为类的友元函数时，由于没有隐含的this指针，因此操作数的个数没有变化，所有的操作数都必须通过函数的形参进行传递，函数的参数与操作数自左至右一一对应。
调用友元函数运算符的格式如下：
operator <运算符>(<参数1>,<参数2>)
它等价于
<参数1><运算符><参数2>
例如：a+b等价于operator +(a,b)。
两种重载形式的比较
在多数情况下，将运算符重载为类的成员函数和类的友元函数都是可以的。但成员函数运算符与友元函数运算符也具有各自的一些特点：
(1) 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。
(2) 以下一些双目运算符不能重载为类的友元函数：=、()、[]、->。
(3) 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。
(4) 若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。
(5) 若运算符所需的操作数（尤其是第一个操作数）希望有隐式类型转换，则只能选用友元函数。
(6) 当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运算符类的一 个类对象（或者是对该类对象的引用）。如果左边的操作数必须是一个不同类的对象，或者是一个内部 类型的对象，该运算符函数必须作为一个友元函数来实现。
(7) 当需要重载运算符具有可交换性时，选择重载为友元函数。
________________________________________________________________
运算符重载是C++的重要组成部分，它可以让程序更加的简单易懂，简单的运算符使用可以使复杂函数的理解更直观。
对于普通对象来说我们很自然的会频繁使用算数运算符让他们参与计算，但是对于自定义类的对象来说，我们是无论如何也不能阻止写出像下面的代码一样的程序来的。
例子如下：
class Test
{
//过程省略
}
int main() {
Test a,c;
c=a+a; }
当然这样的代码是不能够通过编译的，c++对自定类的算术运算部分保留给了程序员，这也是符合c++灵活特性的。
在c++中要想实现这样的运算就必须自定义运算符重载函数，让它来完整具体工作。
在这里要提醒读者的是，自定义类的运算符重载函数也是函数，你重载的一切运算符不会因为是你自己定义的就改变其运算的优先级，自定义运算符的运算优先级同样遵循与内部运算符一样的顺序。
除此之外，c++也规定了一些运算符不能够自定义重载，例如.、::、.*、.->、?:。
下面我们来学习如何重载运算符，运算符重载函数的形式是：
返回类型 operator 运算符符号 (参数说明)
{
//函数体的内部实现
}
运算符重载函数的使用主要分为两种形式，一种是作为类的友元函数进行使用，另一种则是作为类的成员函数进行使用。
下面我们先看一下作为类的友元函数使用的例子：
//程序作者:管宁
//站点:www.cndev-lab.com
//所有稿件均有版权,如要转载,请务必著名出处和作者
#include <iostream>
using namespace std;
class Test
{
public:
Test(int a = 0)
{
Test::a = a;
}
friend Test operator +(Test&,Test&);
friend Test& operator ++(Test&);
public:
int a;
};
Test operator +(Test& temp1,Test& temp2)//+运算符重载函数
{
//cout<<temp1.a<<"|"<<temp2.a<<endl;//在这里可以观察传递过来的引用对象的成员分量
Test result(temp1.a+temp2.a);
return result;
}
Test& operator ++(Test& temp)//++运算符重载函数
{
temp.a++;
return temp;
}
int main()
{
Test a(100);
Test c=a+a;
cout<<c.a<<endl;
c++;
cout<<c.a<<endl;
system("pause");
}
在例子中，我们对于自定义类Test来说，重载了加运算符与自动递增运算符，重载的运算符完成了同类型对象的加运算和递增运算过程。
重载运算符函数返回类型和形式参数也是根据需要量进行调整的，下面我们来看一下修改后的加运算符重载函数。
代码如下：
//程序作者:管宁
//站点:www.cndev-lab.com
//所有稿件均有版权,如要转载,请务必著名出处和作者
#include <iostream>
using namespace std;
class Test
{
public:
Test(int a = 0)
{
Test::a = a;
}
friend Test operator +(Test&,const int&);
public:
int a;
};
Test operator +(Test& temp1,const int& temp2)//+运算符重载函数
{
Test result(temp1.a * temp2);
return result;
}
int main()
{
Test a(100);
Test c = a + 10;
cout<<c.a<<endl;
system("pause");
}
上面修改后的例子中，我们让重载后的加运算符做的事情，事实上并不是同类型对象的加运算，而是自定义类对象与内置int常量对象的乘法运算。
值得注意的是，对于运算符重载来说，我们并不一定要用它一定要做同类型对象的加法或者是其它运算，运算符重载函数本身就是函数，那么在函数体内部我们是可以做任何事情的，但是从不违背常规思维的角度来说，我们没有必要让重载加运算的函数来做与其重载的符号意义上完全不相符的工作，所以在使用重载运算符脱离原意之前，必须保证有足够的理由。
下面我们讨论一下作为类成员函数的运算符重载函数的使用，及其函数的值返回与引用返回的差别。
下面我们先看实例，而后逐步分析。
代码如下(重要部分做了详细的注解)：
//程序作者:管宁
//站点:www.cndev-lab.com
//所有稿件均有版权,如要转载,请务必著名出处和作者
#include <iostream>
using namespace std;
class Test
{
public:
Test(int a = 0)
{
Test::a = a;
}
Test(Test &temp)
//运算符重载函数为值返回的时候会产生临时变量，临时变量与局部变量result的复制会调用拷贝构造函数，临时变量的生命周期是在拷贝构造函数运行完成后才结束，但如果运算符重载函数返回的是引用，那么不会产生临时变量，而局部变量result的生命周期在运算符重载函数退出后立即消失，它的生命周期要比临时变量短，所以当外部对象获取返回值的内存地址所存储的值的时候，获得是一个已经失去效果的内存地址中的值，在这里的值返回与引用返回的对比，证明了临时变量的生命周期比局部变量的生命周期稍长。
{
cout<<"载入拷贝构造函数"<<"|"<<temp.a<<endl;//注意这里，如果修改运算符重载函数为返回引用，这里就会出现异常，temp.a将获得一个随机值。
Test::a = temp.a;
}
~Test()//在mian()内析构的过程是result局部变量产生的
{
cout<<"载入析构函数!"<<endl;
cin.get();
}
Test operator +(Test& temp2)//+运算符重载函数
{
//cout<<this->a<<endl;
Test result(this->a+temp2.a);
return result;
}
Test& operator ++()//++运算符重载函数
//递增运算符是单目运算符，使用返回引用的运算符重载函数道理就在于它需要改变自身。
//在前面我们学习引用的单元中我们知道，返回引用的函数是可以作为左值参与运算的，这一点也符合单目运算符的特点。
//如果把该函数改成返回值，而不是返回引用的话就破坏了单目预算改变自身的特点，程序中的++(++c)运算结束后输出c.a，会发现对象c只做了一次递增运算，原因在于，当函数是值返回状态的时候括号内的++c返回的不是c本身而是临时变量，用临时变量参与括号外的++运算，当然c的值也就只改变了一次。
{
this->a++;
return *this;
}
public:
int a;
};
int main()
{
Test a(100);
Test c=a+a;
cout<<c.a<<endl;
c++;
cout<<c.a<<endl;
++c;
cout<<c.a<<endl;
++(++c);
cout<<c.a<<endl;
system("pause");
}
上例中运算符重载函数以类的成员函数方式出现，细心的读者会发现加运算和递增运算重载函数少了一个参数，这是为什么呢？
因为当运算符重载函数以类成员函数身份出现的时候，C++会隐藏第一个参数，转而取代的是一个this指针
接下来我们具体分析一下运算符重载函数的值返回与引用返回的差别。
当我们把代码中的加运算重载函数修改成返回引用的时候：
Test& operator +(Test& temp2)//+运算符重载函数
{
Test result(this->a+temp2.a);
return result;
}
执行运算符重载函数返回引用将不产生临时变量，外部的Test c=a+a; 将获得一个局部的，栈空间内存地址位置上的值，而栈空间的特性告诉我们，当函数退出的时候函数体中局部对象的生命周期随之结束，所以保存在该地址中的数据也将消失，当c对象去获取存储在这个地址中的值的时候，里面的数据已经不存在，导致c获得的是一个随机值，所以作为双目运算的加运算符重载函数是不益采用返回引用方式编写的，当然如果一定要返回引用，我们可以在堆内存中动态开辟空间存储数据，但是这么做会导致额外的系统开销，同时也会让程序更难读懂。
对于递增运算符来说，它的意义在于能够改变自身，返回引用的函数是可以作为左值参与运算的，所以作为单目运算符，重载它的函数采用返回引用的方式编写是最合适的。
如果我们修改递增运算符重载函数为值返回状态的时候，又会出现什么奇怪的现象呢？
代码如下：
Test operator ++()
{
return this->a++;
}
表面上是发现不出什么特别明显的问题的，但是在main()函数中++(++c);的执行结果却出乎意料，理论上应该是204的值，却只是203，这是为什么呢？
因为当函数是值返回状态的时候括号内的++c返回的不是c本身而是临时变量，用临时变量参与括号外的++运算，当然c的值也就只改变了一次。结果为203而不是204。
对于运算符重载函数来说，最后我们还要注意一个问题，当运算符重载函数的形式参数类型全部为内部类型的时候，将不能重载。
评论