1、c++絕大多數運算子允許過載，不能過載的運算子只有幾個：
. 成員訪問運算子
. * 成員指標訪問運算子
：： 作用域運算子
Sizeof 長度運算子
？： 條件運算子
2、c++不允許使用者自己定義新的運算子，只能對已有運算子過載
3、**不是C++運算子，但某些程式語言將其作為指數運算子
4、過載不能改變運算子的操作物件個數，如+是雙目運算子，需要兩個引數
5、過載不能改變運算子原有的優先順序
6、過載不能改變運算子原有的結合特性
7、運算子過載函式的引數至少應有一個是類物件獲物件的引用
如int operator(int x,int y)為錯誤的，引數不能全是c++標準型別

#include<iostream>
using namespace std;
class complex
{
    public:
        double real;
        double imag;
        complex(double r=0,double i=0)
        {
            real=r;
            imag=i;
        }
};
complex operator+(complex co1,complex co2)//定義運算子+的過載 
{
    complex temp;
    temp.real=co1.real+co2.real;
    temp.imag=co1.imag+co2.imag;
    return
 
 temp;
}
int main()
{
    complex com1(1.1,2.2),com2(2.2,3.4),total1,total2;
    total1=operator+(com1,com2);
    total2=com1+com2;
    cout<<"total1:"<<"total1.real:"<<total1.real<<",total1.imag:"<<total1.imag<<endl;
    cout<<"total2:"<<"total2.real:"
 
<<total2.real<<",total2.imag:"<<total2.imag<<endl;
    return 0;

}

類的資料成員過載運算子常以以下兩種方式：成員運算子過載函式和友元運算子過載函式
友元運算子過載
在類的內部定義友元運算子格式：
friend 函式型別 operator 運算子（形參表）
{
函式體
}

友元函式在類裡宣告，類外定義：
類中：
class x
{
…
friend 函式型別 operator 運算子（形參表）
…
}
類外：
函式型別 operator 運算子（形參表）
{
函式體
}

#include<iostream>
using namespace std;
class complex

{
    public:
        complex(double r=0,double i=0)
        {
            real=r;
            imag=i;
        }
        void print();
        friend complex operator+(complex &a,complex &b);
        friend complex operator-(complex &a,complex &b);
        private:
            double real,imag;
};

void complex::print()
{
    cout<<real;
    if(imag>0)
    {
        cout<<"+";
    }
    if(imag!=0)
    {
        cout<<imag<<"i"<<endl;
    }
}
complex operator+(complex &a,complex &b)
{
    complex temp;
    temp.real=a.real+b.real;
    temp.imag=a.imag+b.imag;
    return temp;
}

complex operator-(complex &a,complex &b)
{
    complex temp;
    temp.real=a.real-b.real;
    temp.imag=a.imag-b.imag;
    return temp;
}

int main()
{
    complex A1(2.3,4.6),A2(3.6,5.6),A3,A4;
    A3=A1+A2;
    A4=A1-A2;
    A1.print();
    A2.print();
    A3.print();
    A4.print();
    return 0;
}

友元運算子過載單目運算子

#include<iostream>
using namespace std;
class coord
{
    public:
        coord(int i=0,int j=0)
        {
            x=i;
            y=j;
        }
        void print()
        {
            cout<<"x:"<<x<<",y:"<<y<<endl;
        }
        friend coord operator--(coord &obj)
        {
            --obj.x;
            --obj.y;
            return obj;
        }
        private :
            int x,y;
};
int main()
{
    coord obj(12,34);
    obj.print();
    --obj;
    obj.print();
    operator--(obj);
    obj.print();
    return 0;
}

注意，friend coord operator–(coord &obj)，形參是物件的引用，是通過傳址的方式傳遞引數的，函式形參的變化引起實參的變化，若去掉&符號，則函式體內對形參的修改無法傳到函式體外
有的運算子不能定義為友元運算子過載，如賦值運算子“=”，下標運算子“[]”，函式呼叫運算子“()”等

成員運算子過載函式
雙目運算子過載：成員運算子過載函式的形參表僅有一個引數，他作為運算子的右運算元，另一個運算元（左運算元）是隱含的，是該類當前的物件，它是通過this指標隱含傳遞給函式的

#include<iostream>
using namespace std;
class complex
{
    public:
        complex(double r=0,double i=0);
        void print();
        complex operator+(complex c);
        complex operator-(complex c);
        private:
            double real,imag;
};
complex::complex(double r,double i)
{
    real=i;
    imag=i;
}

void complex::print()
{
    cout<<real;
    if(imag>0)
    {
        cout<<"+";
    }
    if(imag!=0)
    {
        cout<<imag<<"i"<<endl;
    }
}
complex complex::operator+(complex c)
{
    complex temp;
    temp.real=real+c.real;
    temp.imag=imag+c.imag;
    return temp;
}

complex complex::operator-(complex c)
{
    complex temp;
    temp.real=real-c.real;
    temp.imag=imag-c.imag;
    return temp;
}

int main()
{
    complex A(2.3,4.5),B(3.5,6.7),C,D;
    C=A+B;
    D=A-B;
    A.print();
    B.print();
    C.print();
    D.print();
    return 0;
}

*單目運算子過載：*成員運算子過載函式的引數列表中沒有引數，此時當前物件作為運算子的一個運算元

include

using namespace std;
class coord
{
public:
coord(int i=0,int j=0);
void print();
coord operator++();
private:
int x,y;
};
coord::coord(int i,int j)
{
x=i;
y=j;
}
void coord::print()
{
cout<<”x:”<