第七章实验

实验目的和要求

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

实验内容

1、调试下列程序。

[cpp]  view plain  copy

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

运行结果如下：

2.调试下列程序。

[cpp]  view plain  copy

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

运行结果如下：

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

程序如下：

[cpp]  view plain  copy

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.   }  

运行结果如下：

分析与讨论

结合上题中的程序总结运算符重载的形式。

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

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

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