# 实验七 运算符重载

## 实验目的和要求

熟悉运算符重载的定义和使用方法

## 实验内容

1.调试下列程序

1. //sy7_1.cpp
2. #include<iostream>
3. using namespace std;
4. class complex
5. {
6.     public:
7.         complex(){real=imag=0.0;}
8.         complex(double r){real=r;imag=0.0;}
9.         complex(double r,double i){real=r;imag=i;}
10.         complex operator + (const complex &c);
11.         complex operator - (const complex &c);
12.         complex operator * (const complex &c);
13.         complex operator / (const complex &c);
14.         friend void print(const complex &c);
15.     private:
16.         double real,imag;
17. };
18. inline complex complex::operator + (const complex &c)
19. {
20.     return complex(real+c.real,imag+c.imag);
21. }
22. inline complex complex::operator - (const complex &c)
23. {
24.     return complex(real-c.real,imag-c.imag);
25. }
26. inline complex complex::operator * (const complex &c)
27. {
28.     return complex(real*c.real-imag*c.imag,real*c.imag+imag*c.real);
29. }
30. inline complex complex::operator / (const complex &c)
31. {
32.     return complex((real*c.real+imag*c.imag)/(c.real*c.real+c.imag*c.imag),(imag*c.real-real*c.imag)/(c.real*c.real+c.imag*c.imag));
33. }
34. void print(const complex &c)
35. {
36.     if(c.imag<0)
37.         cout<<c.real<<c.imag<<"i";
38.     else
39.         cout<<c.real<<"+"<<c.imag<<"i";
40. }
41. int main()
42. {
43.     complex c1(2.0),c2(3.0,-1.0),c3;
44.     c3=c1+c2;
45.     cout<<"\nc1+c2= ";
46.     print(c3);
47.     c3=c1-c2;
48.     cout<<"\nc1-c2= ";
49.     print(c3);
50.     c3=c1*c2;
51.     cout<<"\nc1*c2= ";
52.     print(c3);
53.     c3=c1/c2;
54.     cout<<"\nc1/c2= ";
55.     print(c3);
56.     c3=(c1+c2)*(c1-c2)*c2/c1;
57.     cout<<"\n(c1+c2)*(c1-c2)*c2/c1= ";
58.     print(c3);
59.     cout<<endl;
60.     return 0;
61. }
//sy7_1.cpp
#include<iostream>
using namespace std;
class complex
{
public:
complex(){real=imag=0.0;}
complex(double r){real=r;imag=0.0;}
complex(double r,double i){real=r;imag=i;}
complex operator + (const complex &c);
complex operator - (const complex &c);
complex operator * (const complex &c);
complex operator / (const complex &c);
friend void print(const complex &c);
private:
double real,imag;
};
inline complex complex::operator + (const complex &c)
{
return complex(real+c.real,imag+c.imag);
}
inline complex complex::operator - (const complex &c)
{
return complex(real-c.real,imag-c.imag);
}
inline complex complex::operator * (const complex &c)
{
return complex(real*c.real-imag*c.imag,real*c.imag+imag*c.real);
}
inline complex complex::operator / (const complex &c)
{
return complex((real*c.real+imag*c.imag)/(c.real*c.real+c.imag*c.imag),(imag*c.real-real*c.imag)/(c.real*c.real+c.imag*c.imag));
}
void print(const complex &c)
{
if(c.imag<0)
cout<<c.real<<c.imag<<"i";
else
cout<<c.real<<"+"<<c.imag<<"i";
}
int main()
{
complex c1(2.0),c2(3.0,-1.0),c3;
c3=c1+c2;
cout<<"\nc1+c2= ";
print(c3);
c3=c1-c2;
cout<<"\nc1-c2= ";
print(c3);
c3=c1*c2;
cout<<"\nc1*c2= ";
print(c3);
c3=c1/c2;
cout<<"\nc1/c2= ";
print(c3);
c3=(c1+c2)*(c1-c2)*c2/c1;
cout<<"\n(c1+c2)*(c1-c2)*c2/c1= ";
print(c3);
cout<<endl;
return 0;
}


2.调试下列程序

1. //sy7_2.cpp
2. #include<iostream>
3. using namespace std;
4. class complex
5. {
6.     public:
7.         complex(){real=imag=0.0;}
8.         complex(double r){real=r;imag=0.0;}
9.         complex(double r,double i){real=r;imag=i;}
10.         friend complex operator + (const complex &c1,const complex &c2);
11.         friend complex operator - (const complex &c1,const complex &c2);
12.         friend complex operator * (const complex &c1,const complex &c2);
13.         friend complex operator / (const complex &c1,const complex &c2);
14.         friend void print(const complex &c);
15.     private:
16.         double real,imag;
17. };
18. complex operator + (const complex &c1,const complex &c2)
19. {
20.     return complex(c1.real+c2.real,c1.imag+c2.imag);
21. }
22. complex operator - (const complex &c1,const complex &c2)
23. {
24.     return complex(c1.real-c2.real,c1.imag-c2.imag);
25. }
26. complex operator * (const complex &c1,const complex &c2)
27. {
28.     return complex(c1.real*c2.real-c1.imag*c2.imag,c1.real*c2.imag+c1.imag*c2.real);
29. }
30. complex operator / (const complex &c1,const complex &c2)
31. {
32.     return complex((c1.real*c2.real+c1.imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag),(c1.imag*c2.real-c1.real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag));
33. }
34. void print(const complex &c)
35. {
36.     if(c.imag<0)
37.         cout<<c.real<<c.imag<<"i";
38.     else
39.         cout<<c.real<<"+"<<c.imag<<"i";
40. }
41. int main()
42. {
43.     complex c1(2.0),c2(3.0,-1.0),c3;
44.     c3=c1+c2;
45.     cout<<"\nc1+c2= ";
46.     print(c3);
47.     c3=c1-c2;
48.     cout<<"\nc1-c2= ";
49.     print(c3);
50.     c3=c1*c2;
51.     cout<<"\nc1*c2= ";
52.     print(c3);
53.     c3=c1/c2;
54.     cout<<"\nc1/c2= ";
55.     print(c3);
56.     c3=(c1+c2)*(c1-c2)*c2/c1;
57.     cout<<"\n(c1+c2)*(c1-c2)*c2/c1= ";
58.     print(c3);
59.     cout<<endl;
60.     return 0;
61. }
//sy7_2.cpp
#include<iostream>
using namespace std;
class complex
{
public:
complex(){real=imag=0.0;}
complex(double r){real=r;imag=0.0;}
complex(double r,double i){real=r;imag=i;}
friend complex operator + (const complex &c1,const complex &c2);
friend complex operator - (const complex &c1,const complex &c2);
friend complex operator * (const complex &c1,const complex &c2);
friend complex operator / (const complex &c1,const complex &c2);
friend void print(const complex &c);
private:
double real,imag;
};
complex operator + (const complex &c1,const complex &c2)
{
return complex(c1.real+c2.real,c1.imag+c2.imag);
}
complex operator - (const complex &c1,const complex &c2)
{
return complex(c1.real-c2.real,c1.imag-c2.imag);
}
complex operator * (const complex &c1,const complex &c2)
{
return complex(c1.real*c2.real-c1.imag*c2.imag,c1.real*c2.imag+c1.imag*c2.real);
}
complex operator / (const complex &c1,const complex &c2)
{
return complex((c1.real*c2.real+c1.imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag),(c1.imag*c2.real-c1.real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag));
}
void print(const complex &c)
{
if(c.imag<0)
cout<<c.real<<c.imag<<"i";
else
cout<<c.real<<"+"<<c.imag<<"i";
}
int main()
{
complex c1(2.0),c2(3.0,-1.0),c3;
c3=c1+c2;
cout<<"\nc1+c2= ";
print(c3);
c3=c1-c2;
cout<<"\nc1-c2= ";
print(c3);
c3=c1*c2;
cout<<"\nc1*c2= ";
print(c3);
c3=c1/c2;
cout<<"\nc1/c2= ";
print(c3);
c3=(c1+c2)*(c1-c2)*c2/c1;
cout<<"\n(c1+c2)*(c1-c2)*c2/c1= ";
print(c3);
cout<<endl;
return 0;
}


3.定义一个Time类用来保存时间（时，分，秒），通过重载操作符“+”实现两个时间的相加。（sy7_3.cpp）

1. #include <stdio.h>
2.   class Time
3.   {
4.   public:
5.     Time(){ hours=0;minutes=0;seconds=0;} //无参构造函数
6.     Time(int h, int m,int s) //重载构造函数
7.     {
8.              hours=h; minutes=m; seconds=s;
9.     }
10.     Time operator +(Time&); //操作符重载为成员函数，返回结果为Time类
11.     void gettime();
12.   private:
13.     int hours,minutes,seconds;
14.   };
15.   Time Time::operator +(Time& time)
16.   {
17.   int h,m,s;
18.   s=time.seconds+seconds;
19.   m=time.minutes+minutes+s/60;
20.   h=time.hours+hours+m/60;
21.   Time result(h,m%60,s%60);
22.   return result;
23.   }
24.   void Time::gettime()
25.   {
26.   printf("%d:%d:%d\n",hours,minutes,seconds);
27.   }
28.   int main( )
29.   {
30.   Time t1(9,35,45),t2(12,15,32),t3;
31.   t3=t1+t2;
32.   t3.gettime();
33.   return 0;
34.   }
  #include <stdio.h>
class Time
{
public:
Time(){ hours=0;minutes=0;seconds=0;} //无参构造函数
Time(int h, int m,int s) //重载构造函数
{
hours=h; minutes=m; seconds=s;
}
Time operator +(Time&); //操作符重载为成员函数，返回结果为Time类
void gettime();
private:
int hours,minutes,seconds;
};
Time Time::operator +(Time& time)
{
int h,m,s;
s=time.seconds+seconds;
m=time.minutes+minutes+s/60;
h=time.hours+hours+m/60;
Time result(h,m%60,s%60);
return result;
}
void Time::gettime()
{
printf("%d:%d:%d\n",hours,minutes,seconds);
}
int main( )
{
Time t1(9,35,45),t2(12,15,32),t3;
t3=t1+t2;
t3.gettime();
return 0;
}

1. #include <stdio.h>
2.   class Time
3.   {
4.   public:
5.     Time(){ hours=0;minutes=0;seconds=0;} //无参构造函数
6.     Time(int h, int m,int s) //重载构造函数
7.     {
8.              hours=h; minutes=m; seconds=s;
9.     }
10.     friend Time operator +(Time&,Time&); //重载运算符为友元函数形式。
11.                                                                  //友元不是类成员，所以这里要用两个参数，返回这两个参数的和。
12.     void gettime( );
13.   private:
14.     int hours,minutes,seconds;
15.   };
16.      Time operator +(Time& time1,Time& time2)
17.   {
18.   int h,m,s;
19.   s=time1.seconds+time2.seconds;              //计算秒数
20.   m=time1.minutes+time2.minutes+s/60;      //计算分数
21.   h=time1.hours+time2.hours+m/60;           //计算小时数
22.   Time result(h,m%60,s%60);
23.   return result;
24.   }
25.      void Time::gettime( )
26.   {
27.   printf("%d:%d:%d\n",hours,minutes,seconds);
28.   }
29.      int main( )
30.   {
31.   Time t1(9,5,24),t2(13,14,20),t3;
32.   t3=t1+t2; //调用友元函数
33.   t3.gettime( );
34.      return 0;
35.      }
  #include <stdio.h>
class Time
{
public:
Time(){ hours=0;minutes=0;seconds=0;} //无参构造函数
Time(int h, int m,int s) //重载构造函数
{
hours=h; minutes=m; seconds=s;
}
friend Time operator +(Time&,Time&); //重载运算符为友元函数形式。
//友元不是类成员，所以这里要用两个参数，返回这两个参数的和。
void gettime( );
private:
int hours,minutes,seconds;
};
Time operator +(Time& time1,Time& time2)
{
int h,m,s;
s=time1.seconds+time2.seconds;              //计算秒数
m=time1.minutes+time2.minutes+s/60;      //计算分数
h=time1.hours+time2.hours+m/60;           //计算小时数
Time result(h,m%60,s%60);
return result;
}
void Time::gettime( )
{
printf("%d:%d:%d\n",hours,minutes,seconds);
}
int main( )
{
Time t1(9,5,24),t2(13,14,20),t3;
t3=t1+t2; //调用友元函数
t3.gettime( );
return 0;
}


## 分析与讨论

答：运算符函数重载一般有两种形式：重载为类的成员函数和重载为类的非成员函数。非成员函数通常是友元。（可以把一个运算符作为一个非成员、非友元函数重载；但是，这样的运算符函数访问类的私有和保护成员时，必须使用类的公有接口中提供的设置数据和读取数据的函数，调用这些函数时会降低性能。可以内联这些函数以提高性能。）

当运算符重载为类的成员函数时，函数的参数个数比原来的操作数要少一个（后置单目运算符除外），这是因为成员函数用this指针隐式地访问了类的一个对象，它充当了运算符函数最左边的操作数。因此：双目运算符重载为类的成员函数时，函数只显式说明一个参数，该形参是运算符的右操作数。前置单目运算符重载为类的成员函数时，不需要显式说明参数，即函数没有形参。后置单目运算符重载为类的成员函数时，函数要带有一个整型形参。

当运算符重载为类的友元函数时，由于没有隐含的this指针，因此操作数的个数没有变化，所有的操作数都必须通过函数的形参进行传递，函数的参数与操作数自左至右一一对应。