一、什麼是運算子過載

過載的運算子是具有特殊名字的函式：它們的名字由關鍵字operator和其要定義的運算子共同組成。例如：operator+()。和其他函式一樣，過載的運算子也包含返回型別、引數列表、函式體
函式型別 operator運算子符號(形參列表)
{
對運算子的過載處理
}

二、為什麼要運算子過載

1.運算子過載的作用

它允許你為類的使用者提供一種直覺的介面，允許C/C++的運算子在使用者定義型別(類)上擁有一個使用者定義的意義

2.運算子過載有什麼好處

通過過載類上標準運算子，你可以發掘類的使用者的直覺，使使用者程式所用的語言面向問題而不是機器，使得減少錯誤率

三、哪些運算子能被過載，哪些不能被過載

1.可被過載

C++本身內部運算子大部分可被過載

2.不可被過載

“ .”：類屬關係運算符
”.*”：成員指標運算子
”：：”：作用域運算子
“？:”：三目運算子
“sizeof”：測佔位元組運算子（也是關鍵字但主要這個不是函式）

3.通常情況下不應該被過載

逗號，取地址&，邏輯與和邏輯或運算子，因為C++已經定義了這些運算子特殊的含義，這一點 與大多數不同

4.淺析運算子有兩個操作符在作為成員函式時引數只有一個，而作為非成員函式卻迴歸正常有兩個

1.例如”+“號運算子，過載時實際上有兩個引數，但由於過載函式是類中的成員函式，所以有一個引數是隱含著的，運算子函式是用this指標隱含訪問資料成員
C1+C2可以看出C1.operator+(C2);，即看成在C1中用C1的資料成員和引用C2物件的資料成員相加
2.而作為友元就可以堂堂正正有兩個引數了

四、運算子過載如何實現

1.當運算子函式作為成員函式（幾個常見例項）

（一）.“+”，“-”，“*”，“/”

#include <stdio.h>　
#include <stdlib.h>　
#include <string.h>　
#include <time.h>
#include <math.h>
#include <cmath>
#include <iostream>
using namespace std;

class A{
public:
    A();
    A(double
 
 _x);
    A operator+(A &a);
    A operator-(A &b);
    A operator*(A &c);
    A operator/(A &d);  
    void show()
    {
        cout<<(double)x<<endl;
    }
private:
    double x;
};

A::A(double _x):x(_x)
{

}

A A::operator+(A &a)
{
    A obj1(1);
    obj1.x=x+a.x;
    return A(obj1.x);
}
A A::operator-(A &a)
{
    A obj1(1);
    obj1.x=x-a.x;
    return obj1.x;
}
A A::operator*(A &a)
{
    A obj1(1);
    obj1.x=x*a.x;
    return obj1.x;
}
A A::operator/(A &a)
{
    A obj1(1);
    obj1.x=x/a.x;
    return obj1.x;
}

int main()
{
    A obj2(1.1);
    A obj3(2.2);
    A obj4(0.0);
    obj4=obj2+obj3;
    obj4.show();

    obj4=obj3-obj2;
    obj4.show();

    obj4=obj2*obj3;
    obj4.show();

    obj4=obj3/obj2;
    obj4.show();
    return 0;
}

（二）.“=”，“==”，“+=”，“-=”

#include <stdio.h>　
#include <stdlib.h>　
#include <string.h>　
#include <time.h>
#include <math.h>
#include <cmath>
#include <iostream>
using namespace std;

class A{
public:
    A();
    A(int _x);
    A &operator=(A &a);
    bool operator==(A &b);
    A &operator+=(A &c);
    A &operator-=(A &d);
    void show()
    {
        cout<<x<<endl;
    }
private:
    int x;  
};

A::A()
{
    x=0;
}
A::A(int _x):x(_x)
{

}
A &A::operator=(A &a)
{
    x=a.x;
//  return x;
}
bool A::operator==(A &b)
{
    if(x==b.x)
    {
        return 1;
    }
    else 
    {
        return 0;
    }
}
A &A::operator+=(A &c)
{
    x=x+c.x;
    //return A(x);
}
A &A::operator-=(A &d)
{
    x=x-d.x;
    //return A(x);
}

int main()
{
    A obj2(1);
    A obj3(2);
    A obj4;
    obj3+=obj2;
    obj3.show();

    obj3-=obj2;
    obj3.show();

    if(obj3==obj2)
    {
        obj3.show();
    }
    else 
    {
        obj3=obj2;
        obj3.show();
    }
    return 0;
}

（三）.”++“，”- -“（a++有參，++a無參）

#include <stdio.h>　
#include <stdlib.h>　
#include <string.h>　
#include <time.h>
#include <math.h>
#include <cmath>
#include <iostream>
using namespace std;

class A{
public:
    A();
    A(int _x,int _y);
    A &operator++();
    A &operator++(int);
    A &operator--();
    A &operator--(int);
    friend ostream &operator<<(ostream &output,A &m);
private:
    int x;
    int y;
};
A::A()
{
    x=0;
    y=0;
}
A::A(int _x,int _y):x(_x),y(_y)
{

}
A &A::operator++(int)//返回的是自增之前的值 
{
    A obj1(*this);
    ++(*this);
    return obj1;
}
A &A::operator++()//返回自增之後的值 
{
    x++;
    y++;
    return *this;   
} 
A &A::operator--(int)//返回的是自減之前的值 
{
    A obj1(*this);
    --(*this);
    return obj1;
}
A &A::operator--()//返回自減自之後的值 
{
    x--;
    y--;
    return *this;
} 
ostream &operator<<(ostream &output,A &m)
{
    output<<m.x<<"--"<<m.y<<endl;
    return output;
}
int main()
{
    A obj2(1,1);
    cout<<obj2++;

    A obj3(1,1);
    cout<<++obj3;

    A obj4(1,1);
    cout<<obj4--;

    A obj5(1,1);
    cout<<--obj5;

    return 0;
}

三、當運算子函式作為非成員函式（友元）

（一）.友元“+”

#include <stdio.h>　
#include <stdlib.h>　
#include <string.h>　
#include <time.h>
#include <math.h>
#include <cmath>
#include <iostream>
using namespace std;

class A{
public:
    A();
    A(int _x);
    friend A operator+(A &a,A &b);
    void show()
    {
        cout<<x<<endl;
    }
private:
    int x;  
};

A::A()
{
    x=0;
}
A::A(int _x):x(_x)
{

}
A operator+(A &a,A &b)
{
    A obj;
    obj.x=a.x+b.x;
    return obj.x;
}

int main()
{
    A obj2(1);
    A obj3(2);
    A obj4;
    obj4=obj3+obj2;
    obj4.show();
    return 0;
}

（二）.“<<”、“>>”（輸入輸出運算子必須是非成員函式）

1.cout << XXX 這種情況是cout在呼叫operator<<而不是XXX在呼叫operator<< .如果你要把operator<<設為成員函式就只能用 XXX << cout 這種形式
2.假設輸入輸出運算子是某個類的成員，則它們也必須是istream或ostream的成員。然而，這兩個類屬於標準庫，並且我們無法給標準庫中的類新增任何成員

#include <stdio.h>　
#include <stdlib.h>　
#include <string.h>　
#include <time.h>
#include <math.h>
#include <cmath>
#include <iostream>
using namespace std;

class A{
public:
    A();
    A(int _x);
    friend ostream &operator<<(ostream &output,A &a);
    friend istream &operator>>(istream &intput,A &b);   
private:
    int x;
};
A::A()
{
    x=0;
}
A::A(int _x):x(_x)
{

}
ostream &operator<<(ostream &output,A &a)
{
    output<<a.x;
    return output;
}
istream &operator>>(istream &input,A &b)
{
    input>>b.x;
    return input;
}

int main()
{
    A obj1;
    cin>>obj1;
    cout<<obj1;
    return 0;
}