实验七，运算符重载

一、实验目的和要求

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

二、实验内容

1.调试下列程序

//sy7_1.cpp  
#include  
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<
 
  
2、调试下列程序
 
  
//sy7_2.cpp  
#include  
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<
 
  
3.定义一个Time类用来保存时间（时，分，秒），通过重载操作符“+”实现两个时间的相加。（sy7_3.cpp）
 
  
#include   
  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;  
  }  
 
  
运行结果：
 
  

 
  
三、分析与讨论
    结合上题中的程序总结运算符重载的形式。
  答：运算符函数重载一般有两种形式：重载为类的成员函数和重载为类的非成员函数。非成员函数通常是友元。（可以把一个运算符作为一个非成员、非友元函数重载；但是，这样的运算符函数访问类的私有和保护成员时，必须使用类的公有接口中提供的设置数据和读取数据的函数，调用这些函数时会降低性能。可以内联这些函数以提高性能。）  
     当运算符重载为类的成员函数时，函数的参数个数比原来的操作数要少一个（后置单目运算符除外），这是因为成员函数用this指针隐式地访问了类的一个对象，它充当了运算符函数最左边的操作数。因此：双目运算符重载为类的成员函数时，函数只显式说明一个参数，该形参是运算符的右操作数。前置单目运算符重载为类的成员函数时，不需要显式说明参数，即函数没有形参。后置单目运算符重载为类的成员函数时，函数要带有一个整型形参。
 
  
     当运算符重载为类的友元函数时，由于没有隐含的this指针，因此操作数的个数没有变化，所有的操作数都必须通过函数的形参进行传递，函数的参数与操作数自左至右一一对应。
 
  
四、实验小结
 
  
    通过本次实验，我们学习了运算符重载的定义和使用方法，当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运算符类的一个类对象（或者是对该类对象的引用）。