运算符重载（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=,double image=){ 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+;
     cout<<"C=A+5=";C.display();
     return ;
 }

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

 #include <iostream>
 using namespace std;
 
 class Complex
 {
     private:
     double real;
     double image;
     public:
     Complex(double real=,double image=){ 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+;
     cout<<"C=A+5=";C.display();
     return ;
 }

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

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

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

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

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

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

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

四、典型运算符重载：

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

 #include <iostream>
 using namespace std;
 
 class Complex
 {
     private:
     double real;
     double image;
     public:
     Complex(double real=,double image=) { 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=,double image=) { 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(,);
     P1=&C1;
     P1->display();
     return ;
 }

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+];
             strcpy(str,p);
         }
         else
         {
             len=;
             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[]='A';
     cout<<"S1[10]=A"<<endl;
     S1.showstr();
     const String S2("ABCDEFGHIJKLMN");
     cout<<"S2[10]="<<S2[]<<endl;
     return ;
 }