08 c++中运算符重载（未完成）

参考：轻松搞定c++语言

定义：赋予已有运算符多重含义，实现一名多用（比较函数重载）

　　　　运算符重载的本质是函数重载

重载函数的格式：

函数类型 operator 运算符名称(形参表列)  {  
重载实体;
 
 
}

比如： 

const  Complex  operator+(const  Complex  &c1,const  Complex  &c2);

友元函数的重载：

 #include <iostream>
 using namespace std;

 class Complex
 {
 public:
     Complex(float x=, float y=) :_x(x),_y(y){}
     void dis()
     {
         cout<<"("<<_x<<","<<_y<<")"<<endl;
     }
     friend const Complex operator+(const Complex &c1,const Complex &c2);
 private:
     float _x;
     float _y;
 };
 const Complex operator+(const Complex &c1,const Complex &c2)
 {
     return Complex(c1._x + c2._x,c1._y + c2._y);
 }
 int main()
 {
     Complex c1(,);
     Complex c2(,);

     c1.dis();
     c2.dis();
     Complex c3 = c1+c2;
     //Complex c3 = operator+(c1,c2);
     c3.dis();
     return ;
 }

成员重载：

 #include <iostream>

 using namespace std;

 class Complex
 {
 public:
     Complex(float x=, float y=) :_x(x),_y(y){}
     void dis() {
     cout<<"("<<_x<<","<<_y<<")"<<endl;
 }
     friend const Complex operator+(const Complex &c1,const Complex &c2);
     const Complex operator+(const Complex &another);
 private:
     float _x;
     float _y;
 };
 const Complex operator+(const Complex &c1,const Complex &c2)
 {
     cout<<"友元函数重载"<<endl;
     return Complex(c1._x + c2._x,c1._y + c2._y);
 }
 const Complex Complex::operator+(const Complex & another)
 {
     cout<<"成员函数重载"<<endl;
     return Complex(this-­‐>_x + another._x,this-­‐>_y + another._y);
 }
 int main()
 {
     Complex c1(,);
     Complex c2(,);
     c1.dis();
     c2.dis();

     //Complex c3 = c1+c2;
     //Complex c3 = operator+(c1,c2);
     Complex c3 = c1+c2;
     c3.dis();
     return ;
 }

重载规则：

(1) C++不允许用户自己定义新的运算符,只能对已有的  C++运算符进行重载。

 4个不可以重载的运算符：

• . (成员访问运算符)
• .*（成员指针访问运算符）
• ::(域运算符)
• sizeof(长度运算符)
• ？:(条件运算符)

（2）重载不能改变运算符运算对象(即操作数)的个数，双目运算符重载后也是双目运算符）

（3）重载不能改变运算符的优先级别。 

（4）重载不能改变运算符的结合性。 

　　　　如,复制运算符” =“是右结合性(自右至左),重载后仍为右结合性。

（5）重载运算符的函数不可以有默认参数

（6）重载的运算符必须和用户定义的自定义类型的对象一起使用,其参数至少应有

一  个是类对象(或类对象的引用)。 

（7）用于类对象的运算符一般必须重载,但有两个例外,运算符” =“和运算
符” &“不  必用户重载。 

• 复制运算符” =“可以用于每一个类对象,可以用它在同类对象之间相互赋值，因为系统已为每一个新声明的类重载了一个赋值运算符,它的作用是逐个复制类中的数据成员。地址运算符&也不必重载,它能返回类对象在内存中的起始地址。

（8）运算符重载函数可以是类的成员函数,也可以是类的友元函数,还可以是既非
类  的成员函数也不是友元函数的普通函数

单目运算符：（只需要一个操作符）sizeof 　　+（正）　　-（负）　　！　　++　　--　　~（位非）

双目运算符：+, -, *, /, %, <, >, >=, <=, ==, !=, <<, >>, &, ^, |, &&, ||, =

//使#用:      L#R

operator#(L,R);      //全局函数

L.operator#(R);       //成员函数

operator+=：

 //作为友元函数
 class A
 {
     int a,b;
 public:
     A(int x, int y) : a(x), b(y) {}
     friend A operator + (const A&, const A&);
 };
 A operator + (const A& x, const A& y)
 {
     int a = x.a + y.a;
     int b = x.b + y.b;
     return A(a,b);
 }

 //作为成员函数
 class A
 {
     int a,b;
 public:
     A(int x, int y) : a(x), b(y) {}
     A operator + (const A&);
 };
 A A::operator + (const A& x)
 {
     return A(a+x.a,
     b+x.b);
 }