运算符重载（C++）

浏览数：16 / 时间：2015年06月08日

一、运算符重载机制：

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

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

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

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

三、普通运算符重载：

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

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class Complex
 5 {
 6     private:
 7     double real;
 8     double image;
 9     public:
10     Complex(double real=0,double image=0){ this->real=real,this->image=image; }
11     void display(){ cout<<"("<<real<<","<<image<<")"<<endl; }
12     friend Complex operator + (Complex A,Complex B){ return Complex(A.real+B.real,A.image+B.image); }//加法
13     friend Complex operator - (Complex A,Complex B);//减号
14     friend Complex operator - (Complex A);//负号
15     friend Complex operator ++ (Complex& A);//前置++
16     friend Complex operator ++ (Complex& A,int);//后置++
17 };
18 Complex operator - (Complex A,Complex B) { return Complex(A.real-B.real,A.image-B.image); }
19 Complex operator - (Complex A) { return Complex(-A.real,-A.image); }
20 Complex operator ++(Complex& A) { return Complex(++A.real,A.image); }
21 Complex operator ++(Complex& A,int) { return Complex(A.real++,A.image); }
22 
23 int main()
24 {
25     Complex A(100.0,200.0),B(-10.0,20.0),C;
26     cout<<"A=";A.display();
27     cout<<"B=";B.display();
28     C=A+B;
29     cout<<"C=A+B=";C.display();
30     C=A-B;
31     cout<<"C=A-B=";C.display();
32     C=-A+B;
33     cout<<"C=-A+B=";C.display();
34     C=A++;
35     cout<<"C=A++,C=";C.display();
36     C=++A;
37     cout<<"C=++A,C=";C.display();
38     C=A+5;
39     cout<<"C=A+5=";C.display();
40     return 0;
41 }

View Code

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

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class Complex
 5 {
 6     private:
 7     double real;
 8     double image;
 9     public:
10     Complex(double real=0,double image=0){ this->real=real,this->image=image; }
11     void display(){ cout<<"("<<real<<","<<image<<")"<<endl; }
12     Complex operator + (Complex B);//加法
13     Complex operator - (Complex B);//减号
14     Complex operator - ();//负号
15     Complex operator ++ ();//前置++
16     Complex operator ++ (int);//后置++
17 };
18 Complex Complex::operator +(Complex B) { return Complex(real+B.real,image+B.image); }
19 Complex Complex::operator - (Complex B) { return Complex(real-B.real,image-B.image); }
20 Complex Complex::operator - () { return Complex(-real,-image); }
21 Complex Complex::operator ++() { return Complex(++real,image); }
22 Complex Complex::operator ++(int) { return Complex(real++,image); }
23 
24 int main()
25 {
26     Complex A(100.0,200.0),B(-10.0,20.0),C;
27     cout<<"A=";A.display();
28     cout<<"B=";B.display();
29     C=A+B;
30     cout<<"C=A+B=";C.display();
31     C=A-B;
32     cout<<"C=A-B=";C.display();
33     C=-A+B;
34     cout<<"C=-A+B=";C.display();
35     C=A++;
36     cout<<"C=A++,C=";C.display();
37     C=++A;
38     cout<<"C=++A,C=";C.display();
39     C=A+5;
40     cout<<"C=A+5=";C.display();
41     return 0;
42 }

View Code

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

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

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

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

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

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

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

四、典型运算符重载：

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

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class Complex
 5 {
 6     private:
 7     double real;
 8     double image;
 9     public:
10     Complex(double real=0,double image=0) { this->real=real,this->image=image; }
11     void display() { cout<<"("<<real<<","<<image<<")"<<endl; }
12     Complex operator + (Complex B);
13     Complex operator = (Complex B);
14 };
15 Complex Complex::operator +(Complex B) { return Complex(real+B.real,image+B.image); }
16 Complex Complex::operator =(Complex B)
17 {
18     real=B.real,image=B.image;
19     cout<<"operator = calling..."<<endl;
20     return *this;
21 }
22 int main()
23 {
24     Complex A(100.0,200.0),B(-10.0,20.0),C;
25     cout<<"A=",A.display();
26     cout<<"B=",B.display();
27     C=A+B;
28     cout<<"C=A+B=",C.display();
29     C=A;
30     cout<<"C=A=",C.display();
31 }

View Code

2.->：

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class Complex
 5 {
 6     private:
 7     double real;
 8     double image;
 9     public:
10     Complex(double real=0,double image=0) { this->real=real,this->image=image; }
11     void display() { cout<<"("<<real<<","<<image<<")"<<endl; }
12 };
13 class PComplex
14 {
15     private:
16     Complex *PC;
17     public:
18     PComplex(Complex *PC=NULL) { this->PC=PC; }
19     Complex * operator ->()
20     {
21         static Complex NullComplex(0.0);
22         if(PC==NULL) return &NullComplex;
23         return PC;
24     }
25 };
26 int main()
27 {
28     PComplex P1;
29     P1->display();
30     Complex C1(100,200);
31     P1=&C1;
32     P1->display();
33     return 0;
34 }

View Code

3.[]：

 1 #include <iostream>
 2 #include <cstring>
 3 using namespace std;
 4 
 5 class String
 6 {
 7     private:
 8     char *str;
 9     int len;
10     public:
11     void showstr() { cout<<"string:"<<str<<",length:"<<len<<endl; }
12     String(const char *p=NULL)
13     {
14         if(p)
15         {
16             len=strlen(p);
17             str=new char[len+1];
18             strcpy(str,p);
19         }
20         else
21         {
22             len=0;
23             str=NULL;
24         }
25     }
26     ~String()
27     {
28         if(str!=NULL)   delete []str;
29     }
30     char &operator[](int n) { return *(str+n); }
31     const char &operator[](int n)const { return *(str+n); }
32 };
33 
34 int main()
35 {
36     String S1("0123456789abcdef");
37     S1.showstr();
38     S1[10]=‘A‘;
39     cout<<"S1[10]=A"<<endl;
40     S1.showstr();
41     const String S2("ABCDEFGHIJKLMN");
42     cout<<"S2[10]="<<S2[10]<<endl;
43     return 0;
44 }