复数：我们把形如a+bi（a,b均为实数）的数称为复数，其中a称为实部，b称为虚部，i称为虚数单位。当虚部等于零时，这个复数可以视为实数；当z的虚部不等于零时，实部等于零时，常称z为纯虚数。

---

那自然而然我们会想到必定是由两个变量所决定：实部 虚部所以我们就在类中这样定义

Class Copmlex{
    double re;
    double im;
public:
    Complex(double r=0,double i=0) : re(i),im(i) {}
};

从上边可以看出来ptivate是俩double类型，然后初始化函数后将0 0 赋值给re 和 im

接受数据可以如下：

Complex x；     //默认函数 实部虚部都是 0 0
Comple y（1.2）； //构造转换函数 实部1.2 虚部0,0
Complex z（1.2，3.7）//构造函数 实部1.2 虚部 3.7 
//其实这里的x和y没有任何的影响，就是为了传入参数前所定义的

#include  <iostream>
using namespace std;
class Complex {
    double re;
    double im;
public:
    Complex(double r=0,double i=0):re(r),im(i){}
    double real() const { return re; }
    double imag() const { return im; }
};
int main()
{
    Complex y(1.2, 2.4); //传入参数
    cout << "实部:" << y.real() << endl;
    cout << "虚部:" << y.imag() << endl;
    return 0;
}

其实这和前边我们学的是一样，相信你能明白的

重载运算符:

如果不做特殊处理，C++ 的 +、-、*、/ 等运算符只能用于对基本类型的常量或变量进行运算，不能用于对象之间的运算。

有时希望对象之间也能用这些运算符进行运算，以达到使程序更简洁、易懂的目的。例如，复数是可以进行四则运算的，两个复数对象相加如果能直接用+运算符完成，不是很直观和简洁吗？

利用 C++ 提供的“运算符重载”机制，赋予运算符新的功能，就能解决用+将两个复数对象相加这样的问题。

运算符重载，就是对已有的运算符赋予多重含义，使同一运算符作用于不同类型的数据时产生不同的行为。运算符重载的目的是使得 C++ 中的运算符也能够用来操作对象。

运算符重载的实质是编写以运算符作为名称的函数。不妨把这样的函数称为运算符函数。运算符函数的格式如下：

返回值类型  operator  运算符(形参表)
{
    ....
}

包含被重载的运算符的表达式会被编译成对运算符函数的调用，运算符的操作数成为函数调用时的实参，运算的结果就是函数的返回值。运算符可以被多次重载。

运算符可以被重载为全局函数，也可以被重载为成员函数。

#include  <iostream>
using namespace std;
class Complex {
    
public:
    double re;
    double im;
    Complex(double r=0,double i=0):re(r),im(i){}
    Complex operator -(const Complex& c);
    //Complex operator + (const Complex& y, const Complex& x);
//    double real() const { return re; }
//    double imag() const { return im; }
};
Complex operator + (const Complex& y, const Complex& x) {
    return Complex(y.re + x.re, y.im + x.im); //返回临时值
}
Complex operator - (const Complex& y, const Complex& t) {
    return Complex(t.re + y.re, y.im + t.im); //返回临时值
}
Complex Complex::operator-(const Complex& c) {
    return Complex(re - c.re, im - c.im);
}
int main()
{
    Complex y(1.2, 2.4),x(2.3,3.4),t,s; //传入参数
    t = y + x; //等价于 operator + （y,x）
    s = y - t;
    cout << "实部:" << t.re << endl;
    cout << "虚部:" << t.im << endl;

    cout << (y - x).re << "," << (y - x).im << endl;

    cout << "输出y-t =:";
    cout << s.re << "," << s.im << endl;
    return 0;
}

Complex operator + (const Complex& y, const Complex& x) {
    return Complex(y.re + x.re, y.im + x.im); //返回临时值
}
Complex operator - (const Complex& y, const Complex& t) {
    return Complex(t.re + y.re, y.im + t.im); //返回临时值
}
........
 t = y + x; //等价于 operator + （y,x）
 s = y - t;

看上述这段，其实只是改变了+ 和 - 的符号，

:+和-运算符的实体就是作为成员函数的来实现运算符函数的operator+ 和operator-，因此使用+和-就意味着去调用该运算符的函数 :验证说法

........    
Counter& operator++()  //前置增
    {
        if (cnt < UINT_MAX)
            cnt++;
        return *this;

    }
    Counter operator++(int) {
        Counter x = *this;
        if (cnt < UINT_MAX) cnt++;
        return *this;
    }
  ........
    for (int i = 0; i < no; i++) {
        cout << x++<< ' ' << ++y<<' ' <<++x<< '\n';
    }

这个代码是上一文章的部分片段，当你的main函数中不是使用++系统会提醒你报错了，或者数值不正确，这也是一方面说就是在调用class中的那个函数

类值的传递

Comlex x,y,z;
//....
z= x+y
z= x+ 7.5;
z=7.5+x;  //编译错误

z=y+x  等价于 z= y.operator+(x);

z= x+ 7.5;等价于 z=x.operator + (7.5) //来进行传递阐述

如果传递俩参数呢:z=x.operator+(Complex(7.5,2.1)) 其实就是7.5是实部，2.1是虚部

---

那为啥说 z=7.5+x; //编译错误

因为7.5是内置的double类型，但是不是类的内置类型，double型成员没有函数，所以不能调用

引用文章:

原文链接：https://blog.csdn.net/qq_27278957/article/details/85269245