重载运算符总结

柔光的暖阳◎ 2022-05-24 11:11 183阅读 0赞

## 重载运算符 ##

1.前提

在学习了类与对象之后，我们学会了如何定义符合自已需要的数据类型，我们在C语言使用的运算符，运用在类与对象中不是很方便，所以我们就要重载运算符，相当于扩充了运算符内容。下面我来说说我自己对运算符重载的运用的个人理解。

2.基本知识

（1）一般运算符重载运用在类中，它有两种重载方法——成员函数与友元函数，两种可以重载大部分运算符，但也有一些特殊的情况在这里先说明一下。  
一、只能用友元来重载的：

输入输出流（>>or<<）

基本形式：

1.friend ostream & operator <<(ostream & output,Record &r);  
    2.friend istream & operator >>(istream & input,Record &r);  
    3.最后的返回值为:return output; or return input;

二、只能用成员函数形式重载的有：

①\[ \]

基本形式：

1.int & operator [] ( int i )
    2.{  
    3.    return v[i] ;  
    4.}

②、( )

基本形式：

1.double  operator ( )  ( double x ,  double  y ) 
    2.{
    3.return   x * x + y * y ;
    4.}

此例中（）可以看做调用函数，计算两个数的平方之和

③、=

基本形式：

1.Time  operator =(const int &x)  
    2.{  
    3.year=x;  
    4.return *this;  
    5.}

赋值运算符重载用于对象数据的复制

注:复制构造函数是构造对象时调用，重载赋值运算符是对象构造完成后调用。

（2）运算符可分为单目、二目、三目运算符，它们重载时有一些不同：

*  单目运算符  
    单目运算符是需要一个操作数，会有操作数前置后置的问题：

1>前置方式：

1-成员函数：

1.类名 :: 类名 operator++ () ;

2-友元函数：

1.friend 类名 operator++ (类名 &) ;

2>后置方式：

1-成员函数

1.类名 :: 类名  operator++ (int) ;

2-友元函数

1.friend 类名 operator++ (类名 &, int) ;

*  二目运算符
    
    二目运算符是需要左右两个操作数，会有操作数交换顺序的问题

1> 在两个操作数为同一类型，可以交换顺序时，常用成员函数重载

实例：

1.#include<iostream>  
    2.using namespace std;  
    3.class Complex  
    4.{  
    5.public:  
    6.    Complex( )  
    7.    {real=0,imag=0;}  
    8.    Complex(double r,double i)  
    9.    {real=r; imag=i;}  
    10.     Complex operator + (Complex &c2);  
    11.    void display( );  
    12.    private:  
    13.       double real;  
    14.       double imag;};  
    15.  
    16.       Complex Complex:: operator + (Complex &c2) {  
    17.    return Complex(real+c2.real, imag+c2.imag);}  
    18. void Complex::display( ){  
    19.    cout<<"("<<real<<","<<imag<<"i)"<<endl;}  
    20. int main(){  
    21.    Complex c1(3,4),c2(5,-10),c3;  
    22.    c3=c1+c2;  
    23.    cout<<"c1=";c1.display( );  
    24.    cout<<"c2=";c2.display( );  
    25.    cout<<"c1+c2 =";  c3.display( );  
    26.    return 0;  
    27.  
    28. }

形参表中只有一个参数，作为运算符的右操作数，当前对象作为左操作数，通过this指针隐式传递给函数。

2> 在两个运算数为不同类型，不可交换顺序，需用友元函数重载

实例：

1.#include<iostream>  
    2.using namespace std;  
    3.class Complex  
    4.{ public:  
     -      Complex( double r =0, double i =0 )  
     -      { Real = r ;   Image = i ; }  
     -      Complex(int a)  
     -      { Real = a ;  Image = 0 ; }  
     -      void print() const ;  
     -   friend Complex operator+  
     -   ( const Complex & c1, const Complex & c2 ) ;  
     -   friend Complex operator-  
     -   ( const Complex & c1, const Complex & c2 ) ;  
     -   friend Complex operator-  
     -   ( const Complex & c ) ;  
     -  private:  
     -      double  Real, Image ;  
    18.};  
    19.Complex operator + ( const Complex & c1, const Complex & c2 )  
     -  { double r = c1.Real + c2.Real ;  
     -  double i = c1.Image+c2.Image ;  
     -     return Complex ( r,  i ) ;  
     -  }  
    24.Complex operator - ( const Complex & c1, const Complex & c2 )  
     -  { double r = c1.Real - c2.Real ;  
     -  double i = c1.Image - c2.Image ;  
     -     return Complex ( r,  i ) ;  
     -  }  
    29.Complex operator- ( const Complex & c )  
     -  { return Complex ( -c.Real, - c.Image ) ; }  
    31.void Complex :: print() const  
     -  { cout << '(' << Real << " ," << Image << ')' << endl;}  
     -   int main()  
     -   {  
     -    Complex c1(3,4),c2(5,-10),c3;  
     -    c3=c1+c2;  
     -    cout<<"c1=";  
     -    c1.print( );  
     -    cout<<"c2=";  
     -    c2.print( );  
     -    cout<<"c1+c2 =";  
     -    c3.print( );  
     -    return 0;  
     -  
     - }

左右操作数都需显示声明，形参表中有两个参数。

*  三目运算符

我现在所知的三目运算符是 ? : 它不可被重载，不可重载的运算符还有 . :: .\* sizeof

3，简单应用

#include <iostream>
    #include <cstdio>
    #include <string>
    #include <algorithm>
    using namespace std;
    class Time
    {
        int month,day,hour,minute;
    public:
        Time(int mo,int d,int h,int mi)
        {
            month = mo,day = d,hour = h,minute = mi;
    
        }
        Time()
        {
            month = 1,day = 1,hour = 0,minute = 0;
        }
        friend istream&operator>>(istream&out,Time&);
        friend ostream&operator<<(ostream&out,Time&);
        friend bool operator<=(Time,Time);
        void setTime(int mo,int d,int h,int mi)
        {
            month = mo,day = d,hour = h,minute = mi;
        }
        int getMonth()
        {
            return month;
        }
        int getDay()
        {
            return day;
        }
        int getHour()
        {
            return hour;
        }  return in;
    }
    ostream&operator<<(ostream&out,Time&date)
    {
        out<<date.month<<" "<<date.day<<" "<<date.hour<<" "<<date.minute;
        return out;
    }
    bool operator<=(Time t1,Time t2)
    {
        if(t1.getMonth()<t2.getMonth())
            return 1;
        else if(t1.getMonth()==t2.getMonth()&&t1.getDay()<=t2.getDay())
            return 1;
        else return 0;
    }
    int main()
    {    int mo,d,h,mi;
        cin>>mo>>d>>h>>mi;
        Time t1(mo,d,h,mi),t2;
        cout<<t1<<endl;
        cin>>mo>>d>>h>>mi;
        t2.setTime(mo,d,h,mi);
        cout<<t2;
    }

在时间类中重载了输入输出流（>>and<<）和<=

4.个人心得  
学习了重载运算符之后，明显感觉写程序方便了（重载了输入输出流，不用再一个一个地输入输出），与类相关的一些功能也可以很好的实现了（两类比较大小，两类数据相加等等），但是我还是觉得自己没有完全掌握，不常用的运算符还是不太熟悉在哪里用，我还需要强加练习才行。