C++运算符重载实现的过程，代码

所有运算符重载，都拥有一个统一的名称：operator# (#表示运算符号)

参数：根据运算符本身特点决定，如果是单目运算符，最多拥有一个参数，如果是双目运算符，最多拥有两个参数

返回值：由用户自己决定

1.调用原则及调用时机

1> 调用时机：使用该运算符时，系统自动调用，无需手动调用

2> 调用原则：左调右参 （运算符的左侧是函数调用者，右侧是该函数的参数） 例如：a = b; //a.operator=(b)

2. 重载版本

每个运算符重载，都可以实现两个版本的重载函数，分别是成员函数版和全局函数版

成员函数版比全局函数版本少一个参数，因为类对象本身就是一个参数

全局函数版和成员函数版只能实现一个，否则会造成调用时的混乱情况

全局函数版，需要使用友元函数来完成

3.算术类运算符重载

1> 种类：+、-、*、/、%

2> 表达式格式：L # R //L表示左操作数 #表示运算符 R表示右操作数

3> 左操作数：既可以是左值也可以是右值，运算过程中不会被修改

4> 右操作数：既可以是左值也可以是右值，运算过程中不会被修改

5> 结果：结果是一个同类的右值，不能被改变

6> 定义格式：

全局函数版：const 类名 operator# (const 类名 &L, const 类名 &R)

成员函数版：const 类名 operator# ( const 类名 &R)const

4.关系类运算符重载

1> 种类：>、=、

2> 表达式格式：L # R //L表示左操作数 #表示运算符 R表示右操作数

3> 左操作数：既可以是左值也可以是右值，运算过程中不会被修改

4> 右操作数：既可以是左值也可以是右值，运算过程中不会被修改

5> 结果：bool类型，表示真假

6> 定义格式：

全局函数版：bool operator# (const 类名 &L, const 类名 &R)

成员函数版：bool operator# ( const 类名 &R)const

5.赋值类运算符重载

1> 种类：=、+=、-=、*=、/=、%=

2> 表达式格式：L # R //L表示左操作数 #表示运算符 R表示右操作数

3> 左操作数：只能是左值

4> 右操作数：既可以是左值也可以是右值，运算过程中不会被修改

5> 结果：自身的引用

6> 定义格式：

全局函数版：类名 &operator# (类名 &L, const 类名 &R)

成员函数版：类名 & operator# ( const 类名 &R)

6.单目运算符重载

1> 种类：！、~、*、&、-

2> 表达式格式： # O // #表示运算符 O表示操作数

3> 操作数：既可以是左值也可以是右值，运算过程中不能更改

4> 结果：同类的右值

5> 定义格式：

全局函数版：类名 operator# (const 类名 &O)

成员函数版：类名 operator# ( )const

7.自增自减运算符

1> 前置自增运算

1、表达式格式：++O

2、操作数：只能是左值

3、结果：更改后自身的引用，是一个左值

4、定义格式

全局函数版：类名& operator++（类名 & other）

成员函数版：类名 & operator++()

2> 后置自增

1、表达式格式：O++

2、操作数：只能是左值

3、结果：临时值，是一个右值，更改之前的值

4、定义格式：为了区分跟前置自增的区别，后置自增多一个哑元进行占位

全局函数版：类名 operator++（类名 & other， int）

成员函数版：类名 operator++(int)

8.插入提取运算符的重载（>）

1> 这两个运算符的使用：cout>对象名 //cout.operator

2> cin和cout所在的类分别为istream和ostream类，如果想要实现成员函数版的运算符重载，需要对这两个类重新更改内容

3> 对于这两个运算符重载，只能使用全局函数版，借助友元的威力来实现

4> 由于不需要访问istream或ostream类中的私有成员或受保护成员，所以无需将该全局函数在istream和ostream类中设置成友元函数

5> 由于该函数要访问自定义类的私有成员，所以只需在自定义类中将该全局函数设置成友元函数即可

6> 表达式：L#R //L表示cin或cout #表示>运算符 R表示自定义的类对象

7> 左操作数：istream或ostream类对象

8> 右操作数：自定义的类对象

9> 结果：左操作数自身的引用

10> 定义格式

ostream &operator

istream &operator>>(istream &L, 类名 &R);

9.代码

#include 
 
 
using namespace std;
 
 
//定义一个复数类 5 + 3i
class Complex
{
private:
    int real;         //实部
    int vir;          //虚部
 
 
public:
    Complex() {}
    Complex(int r, int v):real(r), vir(v) {}         //有参构造
 
 
    //定义展示函数
    void show()
    {
        if(vir>=0)
        {
            cout<" + "<"i"<
        }else
        {
            cout<"i"<
        }
    }
 
 
    //全局函数版实现加运算符重载
    friend const Complex operator+ (const Complex &L, const Complex &R);
 
 
    //成员函数版实现运算符重载
    const  Complex  operator- ( const Complex  &R)const
    {
        Complex c;
 
 
        c.real = this->real - R.real;
        c.vir = this->vir - R.vir;
 
 
        return c;
    }
 
 
    //成员函数版实现关系运算符的重载：实部>实部  && 虚部>虚部
    bool operator>(const Complex &R)const
    {
        return this->real>R.real&&this->vir>R.vir;
    }
 
 
    //重载中括号运算符
    int & operator[](int index)
    {
        if(index == 0)
        {
            return real;          //返回实部
        }else if(index == 1)
        {
            return vir;           //返回虚部
        }
    }
 
 
 
 
    //重载+=运算符：实部+=实部   虚部+=虚部
    Complex & operator+=(const Complex &R)
    {
        this->real += R.real;
        this->vir += R.vir;
 
 
        return *this;                //返回自身的引用
    }
 
 
    //重载负号运算符： 实部= -实部， 虚部 = -虚部
    Complex operator-()
    {
        Complex c;
        c.real = -this->real;
        c.vir = -this->vir;
 
 
        return c;
    }
 
 
    //重载前置自增运算符重载函数:实部 = 实部+1   虚部=虚部+1
    Complex &operator++()
    {
        ++this->real;
        ++this->vir;
 
 
        return *this;
    }
 
 
    //重载后置自增运算符重载函数：实部 = 实部+1   虚部=虚部+1
    Complex operator++(int)
    {
        Complex c;
 
 
        c.real = this->real++;
        c.vir = this->vir++;
 
 
        return c;
    }
 
 
 
 
    //将全局函数版实现的输出运算符重载函数设置成友元
    friend ostream &operator<<(ostream &L, Complex &c);
 
 
    //重载小括号运算符，做一个仿函数
    void operator()(string s)
    {
        cout<
    }
 
 
    //重载小括号运算符，做一个仿函数
    void operator()()
    {
        cout<<520<<" "<<1314<
    }
 
 
    //重写类型转换运算符
    operator int()
    {
        return real;         //将该数据类型向int类型转换后，使用的是real的值
    }
 
 
 
 
};
 
 
//全局函数版实现加号运算符重载：实部+实部  虚部+虚部
const Complex operator+ (const Complex &L, const Complex &R)
{
    //定义一个临时空间
    Complex c;
 
 
    c.real = L.real + R.real;
    c.vir = L.vir + R.vir;
 
 
    return c;
}
 
 
 
 
//重载输出运算符函数
ostream &operator<<(ostream &L, Complex &c)
{
    if(c.vir>=0)
    {
        L<" + "<"i"<
    }else
    {
        L<"i"<
    }
 
 
    //返回左操作数自身的引用
    return L;
}
 
 
 
 
 
 
int main()
{
    Complex c1(5,3);
    c1.show();                    //5+3i
 
 
    Complex c2(2,-1);
    c2.show();                      //2-1i
 
 
    Complex c3 = c1-c2;             //调用加法运算符重载函数  c1.operator-(c2)
 
 
    c3.show();                      //3+4i
 
 
 
 
    if(c3 > c2)              //调用关系运算符重载函数
    {
        cout<<"yes"<
    }else
    {
        cout<<"no"<
    }
 
 
    c3[0] = 5;               //将实部进行修改成5,调用中括号运算符重载
    c3.show();                  //5+4i
 
 
    c3 += c2;            //调用+=运算符重载函数
    c3.show();             //7+3i
 
 
    Complex c4 = -c3;      //调用-号运算符重载
    c4.show();              //-7 - 3i
    c3.show();            //7+3i
 
 
 
 
    Complex c5 = ++c3;          //调用前置自增运算符重载函数
    c5.show();                  //8+4i
    c3.show();                   //8+4i
 
 
    Complex c6 = c3++;           //调用后置自增运算符重载函数
    c6.show();                   //8+4i
    c3.show();                   //9+5i
 
 
 
 
    cout<//cout.operator<<(c3)
 
 
    c3("hello world");      //c3.operator()("hello world");
    c3();
 
 
    
    int num = (int)c3;            //调用类型转换运算符重载函数
    cout<<"num = "<
 
 
 
 
 
 
 
 
 
 
    return 0;
}