1什么是运算符重载
所谓重载，就是重新赋予新的含义。函数重载就是对一个已有的函数赋予新的含义，使之实现新功能。
运算符也可以重载。实际上，我们已经在不知不觉之中使用了运算符重载。
现在要讨论的问题是： 用户能否根据自己的需要对C++已提供的运算符进行重载，赋予它们新的含义，使之一名多用。譬如，能否用“+”号进行两个复数的相加。在C++中不能在程序中直接用运算符“+”对复数进行相加运算。用户必须自己设法实现复数相加。例如用户可以通过定义一个专门的函数来实现复数相加。见例1。
【例1】 通过函数来实现复数相加。
#include<iostream>
using namespace std;
class Complex //定义Complex类
{
private:
double real;
double imag;
public:
Complex()
{
real=0;
imag=0;
}
Complex(double r,double i)//构造函数重载
{
real=r;
imag=i;
}
Complex Complex_Add(Complex &c2);//声明复数相加函数
void display();
};
Complex Complex::Complex_Add(Complex &c2)
{
Complex c;
c.real=real+c2.real;
c.imag=imag+c2.imag;
return c;
}
void Complex::display()
{
cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
int main()
{
Complex c1(3,4),c2(5,-10),c3;
c3=c1.Complex_Add(c2);
cout<<"c1=";
c1.display();
cout<<"c2=";
c2.display();
cout<<"c1+c2=";
c3.display();
return 0;
}
结果无疑是正确的，但调用方式不直观、太烦琐，使人感到很不方便。能否也和整数的加法运算一样，直接用加号“+”来实现复数运算呢？如
c3=c1+c2;
编译系统就会自动完成c1和c2两个复数相加的运算。如果能做到，就为对象的运算提供了很大的方便。这就需要对运算符“+”进行重载。
2 运算符重载的方法
运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。也就是说，运算符重载是通过定义函数实现的。运算符重载实质上是函数的重载。
重载运算符的函数一般格式如下：
函数类型 operator 运算符名称 (形参表列)
{ 对运算符的重载处理 }
例如，想将“+”用于Complex类(复数)的加法运算，函数的原型可以是这样的：
Complex operator+ (Complex& c1,Complex& c2);
在定义了重载运算符的函数后，可以说： 函数operator+重载了运算符+。
为了说明在运算符重载后，执行表达式就是调用函数的过程，可以把两个整数相加也想像为调用下面的函数：
int operator + (int a,int b)
{return (a+b);}
如果有表达式5+8，就调用此函数，将5和8作为调用函数时的实参，函数的返回值为13。这就是用函数的方法理解运算符。
可以在例1程序的基础上重载运算符“+”，使之用于复数相加。
【例2 】改写例1，重载运算符“+”，使之能用于两个复数相加。
#include<iostream>
using namespace std;
class Complex
{
public:
Complex()
{
real=0;
imag=0;
}
Complex(double r,double i)
{
real=r;
imag=i;
}
Complex operator+(Complex &c2);
void display();
private:
double real;
double imag;
};
Complex Complex::operator +(Complex &c2)
{
Complex c;
c.real=real+c2.real;
c.imag=imag+c2.imag;
return c;
}
void Complex::display()
{
cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
int main()
{
Complex c1(3,4),c2(5,-10),c3;
c3=c1+c2;
cout<<"c1=";
c1.display();
cout<<"c2=";
c2.display();
cout<<"c1+c2=";
c3.display();
return 0;
}
请比较例1和例2，只有两处不同：
(1) 在例2中以operator+函数取代了例1中的complex_add函数，而且只是函数名不同，函数体和函数返回值的类型都是相同的。
(2) 在main函数中，以“c3=c1+c2;”取代了例1中的“c3=c1.complex_add(c2);”。在将运算符+重载为类的成员函数后，C++编译系统将程序中的表达式c1+c2解释为
c1.operator+(c2) //其中c1和c2是Complex类的对象
即以c2为实参调用c1的运算符重载函数operator+(Complex &c2)，进行求值，得到两个复数之和。
虽然重载运算符所实现的功能完全可以用函数实现，但是使用运算符重载能使用户程序易于编写、阅读和维护。在实际工作中，类的声明和类的使用往往是分离的。假如在声明Complex类时，对运算符+,-,*,/都进行了重载，那么使用这个类的用户在编程时可以完全不考虑函数是怎么实现的，放心大胆地直接使用+,-,*,/进行复数的运算即可，十分方便。
对上面的运算符重载函数operator+还可以改写得更简练一些：
Complex Complex∷operator + (Complex &c2)
{return Complex(real+c2.real, imag+c2.imag);}
需要说明的是： 运算符被重载后，其原有的功能仍然保留，没有丧失或改变。通过运算符重载，扩大了C++已有运算符的作用范围，使之能用于类对象。运算符重载对C++有重要的意义，把运算符重载和类结合起来，可以在C++程序中定义出很有实用意义而使用方便的新的数据类型。运算符重载使C++具有更强大的功能、更好的可扩充性和适应性，这是C++最吸引人的特点之一。
3 重载运算符的规则
(1) C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载。
(2) C++允许重载的运算符
C++中绝大部分的运算符允许重载。不能重载的运算符只有5个：
. (成员访问运算符)
.* (成员指针访问运算符)
∷ (域运算符)
sizeof (长度运算符)
?: (条件运算符)
前两个运算符不能重载是为了保证访问成员的功能不能被改变，域运算符和sizeof运算符的运算对象是类型而不是变量或一般表达式，不具重载的特征。
(3) 重载不能改变运算符运算对象(即操作数)的个数。
(4) 重载不能改变运算符的优先级别。
(5) 重载不能改变运算符的结合性。
(6) 重载运算符的函数不能有默认的参数，否则就改变了运算符参数的个数，与前面第(3)点矛盾。
(7) 重载的运算符必须和用户定义的自定义类型的对象一起使用，其参数至少应有一个是类对象(或类对象的引用)。也就是说，参数不能全部是C++的标准类型，以防止用户修改用于标准类型数据的运算符的性质。
(8) 用于类对象的运算符一般必须重载，但有两个例外，运算符“=”和“&”不必用户重载。
① 赋值运算符(=)可以用于每一个类对象，可以利用它在同类对象之间相互赋值。
② 地址运算符&也不必重载，它能返回类对象在内存中的起始地址。
(9) 应当使重载运算符的功能类似于该运算符作用于标准类型数据时所实现的功能。
(10) 运算符重载函数可以是类的成员函数(如例2)，也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数。
4 运算符重载函数作为类成员函数和友元函数
在例2程序中对运算符“+”进行了重载，使之能用于两个复数的相加。在该例中运算符重载函数operator+作为Complex类中的成员函数。
“+”是双目运算符，为什么在例2程序中的重载函数中只有一个参数呢？实际上，运算符重载函数有两个参数，由于重载函数是Complex类中的成员函数，有一个参数是隐含的，运算符函数是用this指针隐式地访问类对象的成员。
可以看到，重载函数operator+访问了两个对象中的成员，一个是this指针指向的对象中的成员，一个是形参对象中的成员。如this->real+c2.real，this->real就是c1.real。
在2节中已说明，在将运算符函数重载为成员函数后，如果出现含该运算符的表达式，如c1+c2,编译系统把它解释为 c1.operator+(c2)
即通过对象c1调用运算符重载函数，并以表达式中第二个参数(运算符右侧的类对象c2)作为函数实参。运算符重载函数的返回值是Complex类型，返回值是复数c1和c2之和(Complex(c1.real + c2.real,c1.imag+c2.imag))。运算符重载函数除了可以作为类的成员函数外，还可以是非成员函数。可以将例2改写为例3。
例3.将运算符“+”重载为适用于复数加法，重载函数不作为成员函数，而放在类外，作为Complex类的友元函数。
#include<iostream.h>//在VC++存在BUG，这里只能用iostream.h
class Complex
{
public:
Complex()
{
real=0;
imag=0;
}
Complex(double r,double i)
{
real=r;
imag=i;
}
friend Complex operator+(Complex &c1,Complex &c2);
void display();
private:
double real;
double imag;
};
Complex operator+(Complex &c1,Complex &c2)
{
return Complex(c1.real+c2.real,c1.imag+c2.imag);
}
void Complex::display()
{
cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
int main()
{
Complex c1(3,4),c2(5,-10),c3;
c3=c1+c2;
cout<<"c1=";
c1.display();
cout<<"c2=";
c2.display();
cout<<"c1+c2=";
c3.display();
return 0;
}
运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数。现在分别讨论这3种情况。
首先，只有在极少的情况下才使用既不是类的成员函数也不是友元函数的普通函数，原因是上面提到的，普通函数不能直接访问类的私有成员。
在剩下的两种方式中，什么时候应该用成员函数方式，什么时候应该用友元函数方式？二者有何区别呢？如果将运算符重载函数作为成员函数，它可以通过this指针自由地访问本类的数据成员，因此可以少写一个函数的参数。但必须要求运算表达式第一个参数(即运算符左侧的操作数)是一个类对象，而且与运算符函数的类型相同。因为必须通过类的对象去调用该类的成员函数，而且只有运算符重载函数返回值与该对象同类型，运算结果才有意义。 在例2中，表达式c1+c2中第一个参数c1是Complex类对象，运算符函数返回值的类型也是Complex，这是正确的。如果c1不是Complex类，它就无法通过隐式this指针访问Complex类的成员了。如果函数返回值不是Complex类复数，显然这种运算是没有实际意义的。
如想将一个复数和一个整数相加，如c1+i，可以将运算符重载函数作为成员函数，如下面的形式：
Complex Complex∷operator+(int &i) //运算符重载函数作为Complex类的成员函数
{return Complex(real+i,imag);}
注意在表达式中重载的运算符“+”左侧应为Complex类的对象，如
c3=c2+i;
不能写成
c3=i+c2; //运算符“+”的左侧不是类对象，编译出错
如果出于某种考虑，要求在使用重载运算符时运算符左侧的操作数是整型量（如表达式i+c2，运算符左侧的操作数i是整数），这时是无法利用前面定义的重载运算符的，因为无法调用i.operator+函数。可想而知，如果运算符左侧的操作数属于C++标准类型(如int)或是一个其他类的对象，则运算符重载函数不能作为成员函数，只能作为非成员函数。如果函数需要访问类的私有成员，则必须声明为友元函数。可以在Complex类中声明：
friend Complex operator+(int &i,Complex &c); //第一个参数可以不是类对象
在类外定义友元函数：
Complex operator+(int &i, Complex &c) //运算符重载函数不是成员函数
{return Complex(i+c.real,c.imag);}
将双目运算符重载为友元函数时，在函数的形参表列中必须有两个参数，不能省略，形参的顺序任意，不要求第一个参数必须为类对象。但在使用运算符的表达式中，要求运算符左侧的操作数与函数第一个参数对应，运算符右侧的操作数与函数的第二个参数对应。如
c3=i+c2; //正确，类型匹配
c3=c2+i; //错误，类型不匹配
请注意，数学上的交换律在此不适用。如果希望适用交换律，则应再重载一次运算符“+”。如
Complex operator+(Complex &c, int &i) //此时第一个参数为类对象
{return Complex(i+c.real,c.imag);}
这样，使用表达式i+c2和c2+i都合法，编译系统会根据表达式的形式选择调用与之匹配的运算符重载函数。可以将以上两个运算符重载函数都作为友元函数，也可以将一个运算符重载函数(运算符左侧为对象名的) 作为成员函数，另一个(运算符左侧不是对象名的)作为友元函数。但不可能将两个都作为成员函数，原因是显然的。
C++规定，有的运算符(如赋值运算符、下标运算符、函数调用运算符)必须定义为类的成员函数，有的运算符则不能定义为类的成员函数(如流插入“<<”和流提取运算符“>>”、类型转换运算符)。
由于友元的使用会破坏类的封装，因此从原则上说，要尽量将运算符函数作为成员函数。但考虑到各方面的因素，一般将单目运算符重载为成员函数，将双目运算符重载为友元函数。
【说明】： 有的C++编译系统(如Visual C++ 6.0)没有完全实现C++标准，它所提供不带后缀.h的头文件不支持把成员函数重载为友元函数。上面例3程序在GCC中能正常运行，而在Visual C++ 6.0中会编译出错。但是Visual C++所提供的老形式的带后缀.h的头文件可以支持此项功能，因此可以将程序头两行修改如下，即可顺利运行：
#include <iostream.h>
以后如遇到类似情况，亦可照此办理。
5 重载双目运算符
双目运算符(或称二元运算符)是C++中最常用的运算符。双目运算符有两个操作数，通常在运算符的左右两侧，如3+5,a=b,i<10等。在重载双目运算符时，不言而喻在函数中应该有两个参数。下面再举一个例子说明重载双目运算符的应用。
【例4 】定义一个字符串类String，用来存放不定长的字符串，重载运算符“==”,“<”和“>”，用于两个字符串的等于、小于和大于的比较运算。
#include<iostream.h> //在VC++存在BUG，这里只能用iostream.h
#include<string.h>
class String
{
private:
char *p;
public:
String()
{
p=NULL;
}
String(char *str)
{
p=str;
}
void display();
friend bool operator>(String &str1,String &str2);
friend bool operator<(String &Str1,String &str2);
friend bool operator==(String &str1,String &str2);
};
void String::display()
{
cout<<p;
}
bool operator>(String &str1,String &str2)
{
if(strcmp(str1.p,str2.p)>0)
return true;
else
return false;
}
bool operator==(String &str1,String &str2)
{
if(strcmp(str1.p,str2.p)==0)
return true;
else
return false;
}
bool operator<(String &str1,String &str2)
{
if(strcmp(str1.p,str2.p)<0)
return true;
else
return false;
}
void compare(String &str1,String &str2)
{
if(operator>(str1,str2)==true)
{
str1.display();
cout<<">";
str2.display();
cout<<endl;
}
else if(operator<(str1,str2)==true)
{
str1.display();
cout<<"<";
str2.display();
cout<<endl;
}
else if(operator==(str1,str2)==true)
{
str1.display();
cout<<"=";
str2.display();
cout<<endl;
}
}
int main()
{
String str1("hello"),str2("book"),str3("computer"),str4("hello");
compare(str1,str2);
compare(str2,str3);
compare(str1,str4);
return 0;
}
6 重载单目运算符
单目运算符只有一个操作数，如!a，-b，&c，*p，还有最常用的++i和--i等。重载单目运算符的方法与重载双目运算符的方法是类似的。但由于单目运算符只有一个操作数，因此运算符重载函数只有一个参数，如果运算符重载函数作为成员函数，则还可省略此参数。
下面以自增运算符“++”为例，介绍单目运算符的重载。
例.5 有一个Time类，包含数据成员minute(分)和sec(秒)，模拟秒表，每次走一秒，满60秒进一分钟，此时秒又从0开始算。要求输出分和秒的值。
#include<iostream.h>
class Time
{
private:
int minute;
int second;
public:
Time()
{
minute=0;
second=0;
}
Time(int m,int s):minute(m),second(s){};
void display()
{
cout<<minute<<":"<<second<<endl;
}
Time operator++();
};
Time Time::operator ++()
{
if(++second>=60)
{
second-=60;
++minute;
}
return *this;
}
int main()
{
Time time1(34,0);
for(int i=0;i<61;i++)
{
++time1;
time1.display();
}
return 0;
}运行情况如下：
34:1
34:2
┆
34:59
35:0
35:1 (共输出61行)
可以看到： 在程序中对运算符“++”进行了重载，使它能用于Time类对象。“++”和“--”运算符有两种使用方式，前置自增运算符和后置自增运算符，它们的作用是不一样的，在重载时怎样区别这二者呢？
针对“++”和“--”这一特点，C++约定： 在自增(自减)运算符重载函数中，增加一个int型形参，就是后置自增(自减)运算符函数。
例6在例5程序的基础上增加对后置自增运算符的重载。修改后的程序如下：
#include<iostream.h>
class Time
{
private:
int minute;
int second;
public:
Time()
{
minute=0;
second=0;
}
Time(int m,int s):minute(m),second(s){};
void display()
{
cout<<minute<<":"<<second<<endl;
}
Time operator++();
Time operator++(int);
};
Time Time::operator ++()
{
if(++second>=60)
{
second-=60;
++minute;
}
return *this;
}
Time Time::operator ++(int)
{
Time temp(*this);
second++;
if(second>=60)
{
second-=60;
++minute;
}
return temp;
}
int main()
{
Time time1(34,59),time2;
cout<<"time1: ";
time1.display();
++time1;
cout<<"++time1: ";
time1.display();
time2=time1++;
cout<<"time1++: ";
time1.display();
cout<<"time2: ";
time2.display();
return 0;
}
7 重载流插入运算符和流提取运算符
C++的流插入运算符“<<”和流提取运算符“>>”是C++在类库中提供的，所有C++编译系统都在类库中提供输入流类istream和输出流类ostream。cin和cout分别是istream类和ostream类的对象。在类库提供的头文件中已经对“<<”和“>>”进行了重载，使之作为流插入运算符和流提取运算符，能用来输出和输入C++标准类型的数据。因此凡是用“cout<<”和“cin>>”对标准类型数据进行输入输出的，都要用#include <iostream>把头文件包含到本程序文件中。
用户自己定义的类型的数据，是不能直接用“<<”和“>>”来输出和输入的。如果想用它们输出和输入自己声明的类型的数据，必须对它们重载。
对“<<”和“>>”重载的函数形式如下：
istream & operator >> (istream &,自定义类 &);
ostream & operator << (ostream &,自定义类 &);
即重载运算符“>>”的函数的第一个参数和函数的类型都必须是istream&类型，第二个参数是要进行输入操作的类。重载“<<”的函数的第一个参数和函数的类型都必须是ostream&类型，第二个参数是要进行输出操作的类。因此，只能将重载“>>”和“<<”的函数作为友元函数或普通的函数，而不能将它们定义为成员函数（原因：在成员函数里实现<<重载，我们知道this会作为第一个参数，而这是不符合要求的。>>类似！）。
7.1 重载流插入运算符“<<”
在程序中，人们希望能用插入运算符“<<”来输出用户自己声明的类的对象的信息，这就需要重载流插入运算符“<<”。
例7 在例2的基础上，用重载的“<<”输出复数。
#include<iostream.h>
class Complex
{
private:
double real;
double imag;
public:
Complex()
{
real=0;
imag=0;
}
Complex(double r,double i):real(r),imag(i){};
void display();
Complex operator +(Complex &c2);
friend ostream& operator<<(ostream& output,Complex& c);
};
void Complex::display()
{
cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
Complex Complex::operator +(Complex &c2)
{
return Complex(real+c2.real,imag+c2.imag);
}
ostream& operator<<(ostream& output,Complex& c)
{
output<<"("<<c.real<<"+"<<c.imag<<"i)"<<endl;
return output;//作用是能连续向输出流插入信息
}
int main()
{
Complex c1(2,4),c2(6,10),c3;
c3=c1+c2;
cout<<c3;
return 0;
}
7.2 重载流提取运算符“>>”
C++预定义的运算符“>>”的作用是从一个输入流中提取数据，如“cin>>i;”表示从输入流中提取一个整数赋给变量i(假设已定义i为int型)。重载流提取运算符的目的是希望将“>>”用于输入自定义类型的对象的信息。
例8 在例7的基础上，增加重载流提取运算符“>>”，用“cin>>”输入复数，用“cout<<”输出复数。
#include<iostream.h>
class Complex
{
private:
double real;
double imag;
public:
Complex()
{
real=0;
imag=0;
}
Complex(double r,double i):real(r),imag(i){};
Complex operator +(Complex &c2);
friend ostream& operator<<(ostream& output,Complex& c);
friend istream& operator>>(istream& input,Complex& c);
};
Complex Complex::operator +(Complex &c2)
{
return Complex(real+c2.real,imag+c2.imag);
}
ostream& operator<<(ostream& output,Complex& c)
{
output<<"("<<c.real;
if(c.imag>=0)
output<<"+";
output<<c.imag<<"i)";
return output;//作用是能连续向输出流插入信息
}
istream& operator>>(istream& input,Complex& c)
{
cout<<"input real part and imaginary part of complex number: ";
input>>c.real>>c.imag;
return input;
}
int main()
{
Complex c1,c2;
cin>>c1>>c2;
cout<<"c1="<<c1<<endl;
cout<<"c2="<<c2<<endl;
return 0;
}
1060
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
