C++运算符重载

/***************忆十代码***************/

1、运算符重载：（主要是为了运算类类型的数据变量）

不能重载的运算符：

.	为了保证成员运算符对成员访问的安全性，故不允许重载
.*	同上
::	运算符左侧是类型名，而不是一个表达式
? :	没有定义三目运算符的重载语法
sizeof	运算数是一个类型名，而不是表达式

重载格式：

函数类型 operator 重载运算符（形参表）     //格式1：重载成类的成员函数

{

       函数体；

}

 

friend 函数类型 operator 重载运算符（形参表）   //格式2：重载成类的友元函数

{

       函数体;

}

2、各种运算符重载的示例代码：

              注：其他一些御运算符重载没有列出例子，但基本格式一定，用到时可以查一查！

       A、单目双目运算符（单目一般重载成成员函数运算符，双目一般重载成友元函数）：

              函数类型 operator ++();      //前缀运算

              函数类型 operator ++(int);    //后缀运算

              函数类型 operator --();      //前缀运算

              函数类型 operator -- (int);    //后缀运算

              函数类型 operator ->();  

       B、其他运算符重载：

       “+=”和“-=”：此运算符重载以后与标准数据类型的完全不同，当调用重载运算符时，例如v1+=v2，并不会更改v1的值，但标准数据类型则会！

       “=”：此运算符的重载会像深复制和浅复制那一出现问题，解决方案如下：

       Complex&operator=(Complex &c)         //当赋值运算符重载时，如果类中有指针，则会出现问题，可以如此来解决

       {

              deletep;

              p=newchar[strlen(c.p)+1];

              strcpy(p,c.p);

              return*this;

       }

       或者

       operator=(Complex&c)          //当赋值运算符重载时，如果类中有指针，则会出现问题，可以如此来解决

       {

              deletep;

              p=newchar[strlen(c.p)+1];

              strcpy(p,c.p);  //返回引用

       }

运算符重载示例：

/***************忆十代码***************/

#include <iostream.h>

 

class Complex

{

private:

       floata;        //实数部分

       floatb;        //虚数部分

       //char*p;

public:

       Complex(){}

       Complex(floata1,float b1):a(a1),b(b1){}

       Complexoperator+(Complex );       //重载“+”运算符，成员函数

       friendComplex operator-(Complex c1,Complex c2); //“-”运算符重载为友元函数

       Complexoperator+=(Complex );       //重载“+=”运算符，成员函数

       friendComplex operator-=(Complex c1,Complex c2); //“-=”运算符重载为友元函数

       /*

       Complex&operator=(Complex &c)         //当赋值运算符重载时，如果类中有指针，则会出现问题，可以如此来解决

       {

              deletep;

              p=newchar[strlen(c.p)+1];

              strcpy(p,c.p);

              return*this;

       }

       或者

       operator=(Complex&c)          //当赋值运算符重载时，如果类中有指针，则会出现问题，可以如此来解决

       {

              deletep;

              p=newchar[strlen(c.p)+1];

              strcpy(p,c.p);  //返回引用

       }

       */

       /*

       charoperator[](int n)        //下标运算符重载，常用到数组中

       {

              if(n>len-1)

              {

                     cout<<"数组下标超界！";

              }

              else

                     return*(str+n);

       }

       */

       operator++(){a++;b++;}       //“++”运算符的前缀重载

       operator++(int){a+=2;b+=2;}  //“++”运算符的后缀重载

       operator--(){a--;b--;}       //“--”运算符的前缀重载

       operator--(int){a-=2;b-=2;}  //“--”运算符的后缀重载

       booloperator <(const Complex c);  //重载“<”运算符

       booloperator >(const Complex c);  //重载“>”运算符

       booloperator ==(const Complex c);  //重载“==”运算符

 

       Complex*operator->()        //重载“->”运算符

       {

              returnthis;   //对this的返回是很不错的

       }

 

       voiddisp()     //显示复数

       {

              cout<<a;

              if(b>=0)cout<<"+";

              cout<<b<<"i"<<endl;

       }

};

Complex Complex::operator+(Complex c)   //重载+

{

       Complextmp;

       tmp.a=a+c.a;

       tmp.b=b+c.b;

       returntmp;

}

Complex operator-(Complex c1,Complexc2)   //重载-

{ 

       Complextmp;

       tmp.a=c1.a-c2.a;

       tmp.b=c1.b-c2.b;

       returntmp;

}

Complex Complex::operator+=(Complex c)   //重载+=

{

       Complextmp;

       tmp.a=a+c.a;

       tmp.b=b+c.b;

       returntmp;

}

Complex operator-=(Complex c1,Complexc2)   //重载-=

{ 

       Complextmp;

       tmp.a=c1.a-c2.a;

       tmp.b=c1.b-c2.b;

       returntmp;

}

bool Complex::operator >(const Complexc)       //重载>

{

       if(a<c.a|| b<c.b)

              returnfalse;

       else

              returntrue;

}

bool Complex::operator <(const Complexc)       //重载<

{

       if(a>c.a|| b>c.b)

              returnfalse;

       else

              returntrue;

}

bool Complex::operator ==(const Complexc)       //重载==

{

       if(a!=c.a|| b!=c.b)

              returnfalse;

       else

              returntrue;

}

 

void main()

{

       cout<<"**************“+与-运算符”***************"<<endl;

       Complexs1(2,5),s2(1,10),s3,s4;

       s3=s1+s2;

       s4=s1-s2;

       cout<<"s1:";s1.disp();

       cout<<"s2:";s2.disp();

       cout<<"s3:";s3.disp();

       cout<<"s4:";s4.disp();

       cout<<"**************“++与--运算符”***************"<<endl;

       cout<<"s1:";s1.disp();

       cout<<"s2:";s2.disp();

       s1++;                                  //调用后缀

       ++s2;                                  //调用前缀

       cout<<"s1:";s1.disp();

       cout<<"s2:";s2.disp();

       Complexs5(2,3);

       s5->disp();           //重载->

       cout<<"**************比较运算符***************"<<endl;

       cout<<"s1:";s1.disp();

       cout<<"s2:";s2.disp();

       boolb;

       b=s1>s2;

       cout<<"b=s1>s2  "<<b<<endl;

       b=s1<s2;

       cout<<"b=s1<s2  "<<b<<endl;

       b=s1==s2;

       cout<<"b=s1=s2  "<<b<<endl;

}

/***************忆十代码***************/