运算符重载为成员函数

运算符重载实质上就是通过函数重载，重载为成员函数，它就可以自由的访问本类的数据成员，实际使用时，总是通过该类的某个对象来访问重载的运算符。如果是双目运算符，左操作数是对象本身的数据，由this指针指出，就不再需要任何参数。下面分别介绍这两种情况。

对于双目运算符B，如果要重载为类的成员函数，使之能够实现表达式oprd1 B oprd2，其中oprd1为A类的对象，则应当把B重载为A类的成员函数，该函数只有一个形参，形参的类型是oprd2所属的类型。经过重载之后，表达式就相当于函数调用orpd.operator B(oprd2).

对于前置单目运算符U，如“-”(负号）等，如果要重载为类的成员函数，用来实现表达式U oprd,其中oprd为A类的对象，则U应当重载为A类的成员函数，函数没有形参，经过重载之后，表达式U oprd相当于函数调用oprd.operator U().

再来看看后置运算符“++”和“–”，如果要重载为类的成员函数，用来实现表达式oprd++或oprd–，其中oprd为A类的对象，那么运算符就应当重载为A类的成员函数，这时函数要带有一个整型（int)形参。重载之后，表达式oprd就相当于调用oprd.oprator++(0）和oprd.oprator–(0）。这里的int类型参数在运算中不起任何作用，只是区别于前置后置。

复数类加减法运算重载为成员函数形式

 #include<iostream>
 #include<cassert>
using namespace std;
class complex
{
public:
    complex(double r=0.0,double i=0.0):real(r),imag(i){}
    complex operator+(const complex &c2) const;//运算符+重载成员函数
    complex operator-(const complex &c2) const;//运算符-重载成员函数
    void display() const;
private:
    double real;
    double imag;
};
complex complex::operator+(const complex &c2) const
{
    return complex(real+c2.real,imag+c2.imag);//创建一个临时无名对象作为返回值
}
complex complex::operator-(const complex &c2) const
{
    return complex(real-c2.real,imag-c2.imag);
}
void complex::display() const
{
    cout<<"("<<real<<","<<imag<<")"<<endl;
}
int main()
{
    complex c1(5,4),c2(2,10),c3;
    cout<<"c1="; c1.display();
    cout<<"c2="; c2.display();
    c3=c1-c2;//使用重载运算符完成复数减法
    cout<<"c3=c1-c2="; c3.display();
    c3=c1+c2;
    cout<<"c3=c1+c2="; c3.display();
    return 0;
}

将单目运算符“++”重载为成员函数形式。

 #include<iostream>
 #include<cassert>
using namespace std;
class clock
{
    public:
        clock(int hour=0,int minute=0,int second=0);
        void showtime() const;
        clock& operator++();
        clock operator++(int);
    private:
        int hour,minute,second;
};
clock::clock(int hour,int minute,int second)
{
    if(0<=hour&&hour<24&&0<=minute&&minute<60&&0<=second&&second<60)
    {
        this->hour=hour;
        this->minute=minute;
        this->second=second;
    }
    else
    {
        cout<<"time error!"<<endl;
    }
}
void clock::showtime() const
{
    cout<<hour<<":"<<minute<<":"<<second<<endl;
}
clock &clock::operator++()//前置单目运算符重载函数
{
    second++;
    if(second>=60)
    {
        second-=60;
        minute++;
        if(minute>=60)
        {
            minute-=60;
            hour=(hour+1)%24;
        }
    }
    return *this;
}
clock clock::operator++(int)//后置单目运算符重载
{
    clock old=*this;
    ++(*this);//调用前置“++”运算符
    return old;
}
int main()
{
    clock myclock(23,59,59);
    cout<<"first time output: ";
    myclock.showtime();
    cout<<"show myclock++   ";
    (myclock++).showtime();
    cout<<"show ++myclock   ";
    (++myclock).showtime();
    return 0;
}