实验七 运算符重载

实验目的和要求

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

实验内容

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指针,因此操作数的个数没有变化,所有的操作数都必须通过函数的形参进行传递,函数的参数与操作数自左至右一一对应。

实验总结

    通过对于本次实验的学习,我学习了运算符函数重载的两种形式,当运算符函数是一个成员函数时,最左边的操作数(或者只有最左边的操作数)必须是运算符类的一个类对象(或者是对该类对象的引用)。如果左边的操作数必须是一个不同类的对象,或者是一个内部类型的对象,该运算符函数必须作为一个友元函数来实现。当需要重载运算符具有可交换性时,选择重载为友元函数。通过对实验的实际操作使我对运算符函数重载的了解更加深刻。

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页