intmain（）
{Complexc1（3,4）,c2（5,-10）,c3;
c3=c1+c2;//运算符+用于复数运算
cout<<″c1=″;c1.display（）;
cout<<″c2=″;c2.display（）;
cout<<″c1+c2=″;c3.display（）;
return0;
}
运行结果与例10.1相同：
c1=（3+4i）
c2=（5-10i）
c1+c2=（8,-6i）
请比较例10.1和例10.2，只有两处不同：
（1）在例10.2中以operator+函数取代了例10.1中的complex_add函数，而且只是函数名不同，函数体和函数返回值的类型都是相同的。
（2）在main函数中，以“c3=c1+c2;”取代了例10.1中的“c3=plex_add（c2）;”。
在将运算符+重载为类的成员函数后，C++编译系统将程序中的表达式c1+c2解释为
c1.operator+（c2）//其中c1和c2是Complex类的对象
即以c2为实参调用c1的运算符重载函数operator+（Complex&c2），进行求值，得到两个复数之和。
虽然重载运算符所实现的功能完全可以用函数实现，但是使用运算符重载能使用户程序易于编写、阅读和维护。
在实际工作中，类的声明和类的使用往往是分离的。
假如在声明Complex类时，对运算符+,-,*,/都进行了重载，那么使用这个类的用户在编程时可以完全不考虑函数是怎么实现的，放心大胆地直接使用+,-,*,/进行复数的运算即可，十分方便。
对上面的运算符重载函数operator+还可以改写得更简练一些：
ComplexComplex∷operator+（Complex&c2）
{returnComplex（real+c2.real,imag+c2.imag）;}
需要说明的是：
运算符被重载后，其原有的功能仍然保留，没有丧失或改变。
通过运算符重载，扩大了C++已有运算符的作用范围，使之能用于类对象。
运算符重载对C++有重要的意义，把运算符重载和类结合起来，可以在C++程序中定义出很有实用意义而使用方便的新的数据类型。
运算符重载使C++具有更强大的功能、更好的可扩充性和适应性，这是C++最吸引人的特点之一。
（1）C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载。
（2）C++允许重载的运算符
C++中绝大部分的运算符允许重载。
具体规定见书中表10.1。
不能重载的运算符只有5个：
.（成员访问运算符）
.*（成员指针访问运算符）
∷（域运算符）
sizeof（长度运算符）
?
:
（条件运算符）
10.3重载运算符的规则
前两个运算符不能重载是为了保证访问成员的功能不能被改变，域运算符和sizeof运算符的运算对象是类型而不是变量或一般表达式，不具重载的特征。
（3）重载不能改变运算符运算对象（即操作数）的个数。
（4）重载不能改变运算符的优先级别。
（5）重载不能改变运算符的结合性。
（6）重载运算符的函数不能有默认的参数，否则就改变了运算符参数的个数，与前面第（3）点矛盾。
（7）重载的运算符必须和用户定义的自定义类型的对象一起使用，其参数至少应有一个是类对象（或类对象的引用）。
也就是说，参数不能全部是C++的标准类型，以防止用户修改用于标准类型数据的运算符的性质。
（8）用于类对象的运算符一般必须重载，但有两个例外，运算符“=”和“&”不必用户重载。
①赋值运算符（=）可以用于每一个类对象，可以利用它在同类对象之间相互赋值。
②地址运算符&也不必重载，它能返回类对象在内存中的起始地址。
（9）应当使重载运算符的功能类似于该运算符作用于标准类型数据时所实现的功能。
（10）运算符重载函数可以是类的成员函数（如例10.2），也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数。
在本章例10.2程序中对运算符“+”进行了重载，使之能用于两个复数的相加。
在该例中运算符重载函数operator+作为Complex类中的成员函数。
“+”是双目运算符，为什么在例10.2程序中的重载函数中只有一个参数呢？
实际上，运算符重载函数有两个参数，由于重载函数是Complex类中的成员函数，有一个参数是隐含的，运算符函数是用this指针隐式地访问类对象的成员。
10.4运算符重载函数作为类成员函数和友元函数
可以看到，重载函数operator+访问了两个对象中的成员，一个是this指针指向的对象中的成员，一个是形参对象中的成员。
如this->real+c2.real，this->real就是c1.real。
在10.2节中已说明，在将运算符函数重载为成员函数后，如果出现含该运算符的表达式，如c1+c2,编译系统把它解释为
c1.operator+（c2）
即通过对象c1调用运算符重载函数，并以表达式中第二个参数（运算符右侧的类对象c2）作为函数实参。
运算符重载函数的返回值是Complex类型，返回值是复数c1和c2之和（Complex（c1.real+c2.real,c1.imag+c2.imag））。
运算符重载函数除了可以作为类的成员函数外，还可以是非成员函数。
可以将例10.2改写为例10.3。
例10.3将运算符“+”重载为适用于复数加法，重载函数不作为成员函数，而放在类外，作为Complex类的友元函数。
#include
usingnamespacestd;
classComplex
{public:
Complex（）{real=0;imag=0;}
Complex（doubler,doublei）{real=r;imag=i;}
friendComplexoperator+（Complex&c1,Complex&c2）;//重载函数作为友元函数
voiddisplay（）;
private:
doublereal;
doubleimag;
};
Complexoperator+（Complex&c1,Complex&c2）//定义作为友元函数的重载函数
{returnComplex（c1.real+c2.real,c1.imag+c2.imag）;}
voidComplex∷display（）
{cout<<″（″<intmain（）
{Complexc1（3,4）,c2（5,-10）,c3;
c3=c1+c2;
cout<<″c1=″;c1.display（）;
cout<<″c2=″;c2.display（）;
cout<<″c1+c2=″;c3.display（）;
}
与例10.2相比较，只作了一处改动，将运算符函数不作为成员函数，而把它放在类外，在Complex类中声明它为友元函数。
同时将运算符函数改为有两个参数。
在将运算符“+”重载为非成员函数后，C++编译系统将程序中的表达式c1+c2解释为
operator+（c1,c2）
即执行c1+c2相当于调用以下函数：
Complexoperator+（Complex&c1,Complex&c2）
{returnComplex（c1.real+c2.real,c1.imag+c2.imag）;}
求出两个复数之和。
运行结果同例10.2。
为什么把运算符函数作为友元函数呢？
因为运算符函数要访问Complex类对象中的成员。
如果运算符函数不是Complex类的友元函数，而是一个普通的函数，它是没有权利访问Complex类的私有成员的。
在10.2节中曾提到过：
运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数。
现在分别讨论这3种情况。
首先，只有在极少的情况下才使用既不是类的成员函数也不是友元函数的普通函数，原因是上面提到的，普通函数不能直接访问类的私有成员。
在剩下的两种方式中，什么时候应该用成员函数方式，什么时候应该用友元函数方式？
二者有何区别呢？
如果将运算符重载函数作为成员函数，它可以通过this指针自由地访问本类的数据成员，因此可以少写一个函数的参数。
但必须要求运算表达式第一个参数（即运算符左侧的操作数）是一个类对象，
而且与运算符函数的类型相同。
因为必须通过类的对象去调用该类的成员函数，而且只有运算符重载函数返回值与该对象同类型，运算结果才有意义。
在例10.2中，表达式c1+c2中第一个参数c1是Complex类对象，运算符函数返回值的类型也是Complex，这是正确的。
如果c1不是Complex类，它就无法通过隐式this指针访问Complex类的成员了。
如果函数返回值不是Complex类复数，显然这种运算是没有实际意义的。
如想将一个复数和一个整数相加，如c1+i，可以将运算符重载函数作为成员函数，如下面的形式：
ComplexComplex∷operator+（int&i）//运算符重载函数作为Complex类的成员函数
{returnComplex（real+i,imag）;}
注意在表达式中重载的运算符“+”左侧应为Complex类的对象，如
c3=c2+i;
不能写成
c3=i+c2;//运算符“+”的左侧不是类对象，编译出错
如果出于某种考虑，要求在使用重载运算符时运算符左侧的操作数是整型量（如表达式i+c2，运算符左侧的操作数i是整数），这时是无法利用前面定义的重载运算符的，因为无法调用i.operator+函数。
可想而知，如果运算符左侧的操作数属于C++标准类型（如int）或是一个其他类的对象，则运算符重载函数不能作为成员函数，只能作为非成员函数。
如果函数需要访问类的私有成员，则必须声明为友元函数。
可以在Complex类中声明：
friendComplexoperator+（int&i,Complex&c）;//第一个参数可以不是类对象
在类外定义友元函数：
Complexoperator+（int&i,Complex&c）//运算符重载函数不是成员函数
{returnComplex（i+c.real,c.imag）;}
将双目运算符重载为友元函数时，在函数的形参表列中必须有两个参数，不能省略，形参的顺序任意，不要求第一个参数必须为类对象。
但在使用运算符的表达式中，要求运算符左侧的操作数与函数第一个参数对应，运算符右侧的操作数与函数的第二个参数对应。
如
c3=i+c2;//正确，类型匹配
c3=c2+i;//错误，类型不匹配
请注意，数学上的交换律在此不适用。
如果希望适用交换律，则应再重载一次运算符“+”。
如
Complexoperator+（Complex&c,int&i）//此时第一个参数为类对象
{returnComplex（i+c.real,c.imag）;}
这样，使用表达式i+c2和c2+i都合法，编译系统会根据表达式的形式选择调用与之匹配的运算符重载函数。
可以将以上两个运算符重载函数都作为友元函数，也可以将一个运算符重载函数（运算符左侧为对象名的）作为成员函数，另一个（运算符左侧不是对象名的）作为友元函数。
但不可能将两个都作为成员函数，原因是显然的。
C++规定，有的运算符（如赋值运算符、下标运算符、函数调用运算符）必须定义为类的成员函数，有的运算符则不能定义为类的成员函数（如流插入“<<”和流提取运算符“>>”、类型转换运算符）。
由于友元的使用会破坏类的封装，因此从原则上说，要尽量将运算符函数作为成员函数。
但考虑到各方面的因素，一般将单目运算符重载为成员函数，将双目运算符重载为友元函数。
在学习了本章第10.7节例10.9的讨论后，读者对此会有更深入的认识。
说明：
有的C++编译系统（如VisualC++6.0）没有完全实现C++标准，它所提供不带后缀.h的头文件不支持把成员函数重载为友元函数。
上面例10.3程序在GCC中能正常运行，而在VisualC++6.0中会编译出错。
但是VisualC++所提供的老形式的带后缀.h的头文件可以支持此项功能，因此可以将程序头两行修改如下，即可顺利运行：
#include
以后如遇到类似情况，亦可照此办理。
双目运算符（或称二元运算符）是C++中最常用的运算符。
双目运算符有两个操作数，通常在运算符的左右两侧，如3+5,a=b,i<10等。
在重载双目运算符时，不言而喻在函数中应该有两个参数。
下面再举一个例子说明重载双目运算符的应用。
10.5重载双目运算符
例10.4定义一个字符串类String，用来存放不定长的字符串，重载运算符“==”,“<”和“>”，用于两个字符串的等于、小于和大于的比较运算。
为了使读者便于理解程序，同时也使读者了解建立程序的步骤，下面分几步来介绍编程过程。
（1）先建立一个String类：
#include
usingnamespacestd;
classString
{public:
String（）{p=NULL;}//默认构造函数
String（char*str）;//构造函数
voiddisplay（）;
private:
char*p;//字符型指针，用于指向字符串
};
String∷String（char*str）//定义构造函数
{p=str;}//使p指向实参字符串
voidString∷display（）//输出p所指向的字符串
{cout<intmain（）
{Stringstring1（″Hello″）,string2（″Book″）;
string1.display（）;
cout<string2.display（）;
return0;
}
运行结果为
Hello
Book
（2）有了这个基础后，再增加其他必要的内容。
现在增加对运算符重载的部分。
为便于编写和调试，先重载一个运算符“>”。
程序如下：
#include
#include
usingnamespacestd;
classString
{public:
String（）{p=NULL;}
String（char*str）;
friendbooloperator>（String&string1,String&string2）;//声明运算符函数为友元函数
voiddisplay（）;
private:
char*p;//字符型指针，用于指向字符串
};
String∷String（char*str）
{p=str;}
voidString∷display（）//输出p所指向的字符串
{cout<booloperator>（String&string1,String&string2）//定义运算符重载函数
{if（strcmp（string1.p,string2.p）>0）
returntrue;
elsereturnfalse;
}
intmain（）
{Stringstring1（″Hello″）,string2（″Book″）;
cout<<（string1>string2）<}
程序运行结果为1。
这只是一个并不很完善的程序，但是，已经完成了实质性的工作了，运算符重载成功了。
其他两个运算符的重载如法炮制即可。
（3）扩展到对3个运算符重载。
在String类体中声明3个成员函数：
friendbooloperator>（String&string1,String&string2）;
friendbooloperator<（String&string1,String&string2）;
friendbooloperator==（String&string1,String&string2）;
在类外分别定义3个运算符重载函数：
booloperator>（String&string1,String&string2）//对运算符“>”重载
{if（strcmp（string1.p,string2.p）>0）
returntrue;
else
returnfalse;
}
booloperator<（String&string1,String&string2）//对运算符“<”重载
{if（strcmp（string1.p,string2.p）<0）
returntrue;
else
returnfalse;
}
booloperator==（String&string1,String&string2）//对运算符“==”重载
{if（strcmp（string1.p,string2.p）==0）
returntrue;
else
returnfalse;
}
再修改主函数：
intmain（）
{Stringstring1（″Hello″）,string2（″Book″）,string3（″Computer″）;
cout<<（string1>string2）<cout<<（string1cout<<（string1==string2）<return0;
}
运行结果为
1
0
升级会员 