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

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

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

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

重载函数的格式：

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

比如： 

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

友元函数的重载：

#include <iostream>
using namespace std;

class Complex
{
public:
    Complex(float x=0, float y=0) :_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(2,3);
    Complex c2(3,4);
    80

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

成员重载：

#include <iostream>

using namespace std;

class Complex
{
public:
    Complex(float x=0, float y=0) :_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(2,3);
    Complex c2(3,4);
    c1.dis();
    c2.dis();
    81

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

重载规则：

(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);
}