运算符重载（C++）

一、运算符重载机制：

一元运算符：　　@obj => operator @(obj)

二元运算符：　　obj@obj2 => operator @(obj,obj2)

注意：前置++、--与一元运算符处理方式相同，而后置++、--这样处理：obj++ => operator ++(obj,0)

二、除了.、.*、::、?:、sizeof这5个运算符之外，其他一概都可以重载。

三、普通运算符重载：

1.重载为类的友元函数：

#include <iostream>
using namespace std;

class Complex
{
    private:
    double real;
    double image;
    public:
    Complex(double real=0,double image=0){ this->real=real,this->image=image; }
    void display(){ cout<<"("<<real<<","<<image<<")"<<endl; }
    friend Complex operator + (Complex A,Complex B){ return Complex(A.real+B.real,A.image+B.image); }//加法
    friend Complex operator - (Complex A,Complex B);//减号
    friend Complex operator - (Complex A);//负号
    friend Complex operator ++ (Complex& A);//前置++
    friend Complex operator ++ (Complex& A,int);//后置++
    friend bool operator < (const Complex& A,const Complex& B);//
    friend bool operator == (const Complex& A,const Complex& B);//
};
Complex operator - (Complex A,Complex B) { return Complex(A.real-B.real,A.image-B.image); }
Complex operator - (Complex A) { return Complex(-A.real,-A.image); }
Complex operator ++(Complex& A) { return Complex(++A.real,A.image); }
Complex operator ++(Complex& A,int) { return Complex(A.real++,A.image); }
bool operator < (const Complex& A,const Complex& B) { return A.real*A.real+A.image*A.image<B.real*B.real+B.image*B.image; }
bool operator == (const Complex& A,const Complex& B) { return A.real==B.real&&A.image==B.image; }

int main()
{
    Complex A(100.0,200.0),B(-10.0,20.0),C;
    cout<<"A=";A.display();
    cout<<"B=";B.display();
    C=A+B;
    cout<<"C=A+B=";C.display();
    C=A-B;
    cout<<"C=A-B=";C.display();
    C=-A+B;
    cout<<"C=-A+B=";C.display();
    C=A++;
    cout<<"C=A++,C=";C.display();
    C=++A;
    cout<<"C=++A,C=";C.display();
    C=A+5;
    cout<<"C=A+5=";C.display();
    return 0;
}

2.重载为类的成员函数：

#include <iostream>
using namespace std;

class Complex
{
    private:
    double real;
    double image;
    public:
    Complex(double real=0,double image=0){ this->real=real,this->image=image; }
    void display(){ cout<<"("<<real<<","<<image<<")"<<endl; }
    Complex operator + (Complex B);//加法
    Complex operator - (Complex B);//减号
    Complex operator - ();//负号
    Complex operator ++ ();//前置++
    Complex operator ++ (int);//后置++
    bool operator < (const Complex &B)const;//
    bool operator ==(const Complex &B)const;//
};
Complex Complex::operator +(Complex B) { return Complex(real+B.real,image+B.image); }
Complex Complex::operator - (Complex B) { return Complex(real-B.real,image-B.image); }
Complex Complex::operator - () { return Complex(-real,-image); }
Complex Complex::operator ++() { return Complex(++real,image); }
Complex Complex::operator ++(int) { return Complex(real++,image); }
bool Complex::operator < (const Complex &B)const { return real*real+image*image<B.real*B.real+B.image*B.image; }
bool Complex::operator == (const Complex &B)const {return real==B.real&&image==B.image; }

int main()
{
    Complex A(100.0,200.0),B(-10.0,20.0),C;
    cout<<"A=";A.display();
    cout<<"B=";B.display();
    C=A+B;
    cout<<"C=A+B=";C.display();
    C=A-B;
    cout<<"C=A-B=";C.display();
    C=-A+B;
    cout<<"C=-A+B=";C.display();
    C=A++;
    cout<<"C=A++,C=";C.display();
    C=++A;
    cout<<"C=++A,C=";C.display();
    C=A+5;
    cout<<"C=A+5=";C.display();
    return 0;
}

3.两种重载方式的比较：

1）一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。

2）一些双目运算符不能重载为类的友元函数：=、()、[]、->。

3）若一个运算符的操作需要改变对象的状态，选择重载为成员函数较好。

4）若运算符所需的操作数（尤其第一个操作数）希望有隐式类型转换，则只能选用友元函数。

5）当运算符函数是一个成员函数时，最左边的操作数必须是运算符类的一个类对象或其引用。若左边的操作数必须是一个不同类的对象，或者是一个基本数据类型的对象，该运算符函数必须作为一个友元函数来实现。

6）当需要重载运算符的运算具有可交换性时，选择重载为友元函数。

四、典型运算符重载：

1.重载=进行复数类数据赋值：

#include <iostream>
using namespace std;

class Complex
{
    private:
    double real;
    double image;
    public:
    Complex(double real=0,double image=0) { this->real=real,this->image=image; }
    void display() { cout<<"("<<real<<","<<image<<")"<<endl; }
    Complex operator + (Complex B);
    Complex operator = (Complex B);
};
Complex Complex::operator +(Complex B) { return Complex(real+B.real,image+B.image); }
Complex Complex::operator =(Complex B)
{
    real=B.real,image=B.image;
    cout<<"operator = calling..."<<endl;
    return *this;
}
int main()
{
    Complex A(100.0,200.0),B(-10.0,20.0),C;
    cout<<"A=",A.display();
    cout<<"B=",B.display();
    C=A+B;
    cout<<"C=A+B=",C.display();
    C=A;
    cout<<"C=A=",C.display();
}

2.->：

#include <iostream>
using namespace std;

class Complex
{
    private:
    double real;
    double image;
    public:
    Complex(double real=0,double image=0) { this->real=real,this->image=image; }
    void display() { cout<<"("<<real<<","<<image<<")"<<endl; }
};
class PComplex
{
    private:
    Complex *PC;
    public:
    PComplex(Complex *PC=NULL) { this->PC=PC; }
    Complex * operator ->()
    {
        static Complex NullComplex(0.0);
        if(PC==NULL) return &NullComplex;
        return PC;
    }
};
int main()
{
    PComplex P1;
    P1->display();
    Complex C1(100,200);
    P1=&C1;
    P1->display();
    return 0;
}

3.[]：

#include <iostream>
#include <cstring>
using namespace std;

class String
{
    private:
    char *str;
    int len;
    public:
    void showstr() { cout<<"string:"<<str<<",length:"<<len<<endl; }
    String(const char *p=NULL)
    {
        if(p)
        {
            len=strlen(p);
            str=new char[len+1];
            strcpy(str,p);
        }
        else
        {
            len=0;
            str=NULL;
        }
    }
    ~String()
    {
        if(str!=NULL)   delete []str;
    }
    char &operator[](int n) { return *(str+n); }
    const char &operator[](int n)const { return *(str+n); }
};

int main()
{
    String S1("0123456789abcdef");
    S1.showstr();
    S1[10]='A';
    cout<<"S1[10]=A"<<endl;
    S1.showstr();
    const String S2("ABCDEFGHIJKLMN");
    cout<<"S2[10]="<<S2[10]<<endl;
    return 0;
}