运算符重载实质上就是通过函数重载，重载为成员函数，它就可以自由的访问本类的数据成员，实际使用时，总是通过该类的某个对象来访问重载的运算符。如果是双目运算符，左操作数是对象本身的数据，由this指针指出，就不再需要任何参数。下面分别介绍这两种情况。 

       对于双目运算符B，如果要重载为类的成员函数，使之能够实现表达式oprd1 B oprd2，其中oprd1为A类的对象，则应当把B重载为A类的成员函数，该函数只有一个形参，形参的类型是oprd2所属的类型。经过重载之后，表达式就相当于函数调用orpd.operator B(oprd2). 

       对于前置单目运算符U，如“-”(负号）等，如果要重载为类的成员函数，用来实现表达式U oprd,其中oprd为A类的对象，则U应当重载为A类的成员函数，函数没有形参，经过重载之后，表达式U oprd相当于函数调用oprd.operator U(). 

       再来看看后置运算符“++”和“–”，如果要重载为类的成员函数，用来实现表达式oprd++或oprd–，其中oprd为A类的对象，那么运算符就应当重载为A类的成员函数，这时函数要带有一个整型（int)形参。重载之后，表达式oprd就相当于调用oprd.oprator++(0）和oprd.oprator–(0）。这里的int类型参数在运算中不起任何作用，只是区别于前置后置。 

       复数类加减法运算重载为成员函数形式



 #include<iostream>
 #include<cassert>
using namespace std;
class complex
{
public:
    complex(double r=0.0,double i=0.0):real(r),imag(i){}
    complex operator+(const complex &c2) const;//运算符+重载成员函数
    complex operator-(const complex &c2) const;//运算符-重载成员函数
    void display() const;
private:
    double real;
    double imag;
};
complex complex::operator+(const complex &c2) const
{
    return complex(real+c2.real,imag+c2.imag);//创建一个临时无名对象作为返回值
}
complex complex::operator-(const complex &c2) const
{
    return complex(real-c2.real,imag-c2.imag);
}
void complex::display() const
{
    cout<<"("<<real<<","<<imag<<")"<<endl;
}
int main()
{
    complex c1(5,4),c2(2,10),c3;
    cout<<"c1="; c1.display();
    cout<<"c2="; c2.display();
    c3=c1-c2;//使用重载运算符完成复数减法
    cout<<"c3=c1-c2="; c3.display();
    c3=c1+c2;
    cout<<"c3=c1+c2="; c3.display();
    return 0;
}


将单目运算符“++”重载为成员函数形式。

 #include<iostream>
 #include<cassert>
using namespace std;
class clock
{
    public:
        clock(int hour=0,int minute=0,int second=0);
        void showtime() const;
        clock& operator++();
        clock operator++(int);
    private:
        int hour,minute,second;
};
clock::clock(int hour,int minute,int second)
{
    if(0<=hour&&hour<24&&0<=minute&&minute<60&&0<=second&&second<60)
    {
        this->hour=hour;
        this->minute=minute;
        this->second=second;
    }
    else
    {
        cout<<"time error!"<<endl;
    }
}
void clock::showtime() const
{
    cout<<hour<<":"<<minute<<":"<<second<<endl;
}
clock &clock::operator++()//前置单目运算符重载函数
{
    second++;
    if(second>=60)
    {
        second-=60;
        minute++;
        if(minute>=60)
        {
            minute-=60;
            hour=(hour+1)%24;
        }
    }
    return *this;
}
clock clock::operator++(int)//后置单目运算符重载
{
    clock old=*this;
    ++(*this);//调用前置“++”运算符
    return old;
}
int main()
{
    clock myclock(23,59,59);
    cout<<"first time output: ";
    myclock.showtime();
    cout<<"show myclock++   ";
    (myclock++).showtime();
    cout<<"show ++myclock   ";
    (++myclock).showtime();
    return 0;
}

重载运算符是函数重载的一种，
针对类对象进行操作，重载的函数中至少有一个是类对象
int operator +(ass numone, int num){...}
重载为类的成员函数，
单目运算符重载-操作数是访问本身的数据，由this指出
双目运算符重载-左操作数由this指针给出，右操作数由函数参数给出
显示调用-aa.operator(bb);
隐式调用-aa++bb;
重载为友元函数，
单目重载运算符时，由于要改变操作数自身的值，应采用引用参数传递
class point
{
private:
        int num;
public:
        point()
        {
                num = 0;
        }
        point(int n)
        {
                num = n;
        }
        point operator +(point mn);
        point operator ++();
        friend point operator -(point m, point n);
        friend point operator --(point &m);
        int get_num();
};
int point::get_num()
{
        return num;
}
point point::operator +(point mn)
{
        point item;
        item = num + mn.num;
        return item;
}
point point::operator ++()
{
        ++num;
        return *this;
}
point operator -(point m, point n)
{
        point temp;
        temp.num = m.num + n.num;
        return temp;
}
point operator --(point &m)
{
        --m.num;
        return m;
}

双目运算符重载为成员函数[1]
重载为类成员的运算符函数定义形式(重载为类的成员函数的形式)
函数类型  
双目运算符重载规则
如果要重载 B 为类成员函数，使之能够实现表达式 oprd1 B oprd2，其中 oprd1 为A 类对象，则 B 应被重载为 A 类的成员函数，形参类型应该是 oprd2 所属的类型。
经重载后，表达式 oprd1 B oprd2 相当于 oprd1.operator B(oprd2)
例8-1复数类加减法运算重载为成员函数
要求:
将+、-运算重载为复数类的成员函数。
规则:
实部和虚部分别相加减。
操作数:
两个操作数都是复数类的对象。
源代码：
#include 
程序运行结果
参考
^http://www.xuetangx.com/courses/course-v1:TsinghuaX+00740043_2x_2015_T2+sp/courseware/93f0d3a029d84059a84d02745a1e2bfd/4e3fe66cfdf14439903f61fbfe990e1a/

平时++/--这两个单目运算符基本都会用在for循环，之前理解他们的区别只是：
1、++i：先++，再循环
2、i++：先循环，再++
其实，这种说话是有道理的，但是很模糊，直到学到<单目运算符重载为成员函数>的时候，我才真正的搞明白，不禁感叹：C++机制  ！！！
举个完整的例子 ：《将前置++和后置++重载为时钟类的成员函数》
.hpp文件：
```
#ifndef ________hpp
```
.cpp文件
```
#include 
```
main.cpp
```
#include 
```
运行结果：
```
23
```
其实，大家已经在.cpp文件中发现了，前置++/后置++返回的东西是不一样的：
前置++返回的是引用类型，是将++后的地址返回了，当然就是用+完之后的结果进行循环或者显示了；也可以理解成&的加入，实现了参数的双向传递；
后置++返回的是副本，是用+1前的结果进行循环或者显示，但此时内存地址上的变量已经暗自+1，只是返回的是之前的副本而已；同样可以理解成是参数的单向传递。
因为前置++/后置++的重载函数名字都是operator ++，所为为了区分，
前置++的重载函数没有形参；
后置++的重载函数有形参(int)；
仅仅是为了区分，函数体的实现是不应该使用这个参数的。
其实，这里说的，和我之前的《拷贝构造函数的歪解》是很类似的，道理相通。希望大家好好看一下：
https://blog.csdn.net/weixin_45826012/article/details/102865017​blog.csdn.net
本人技术水平有限，若有错误或不当之处，可以在本号内反馈给我，一起交流一起学习！