复数的四则运算实现（运算符重载）

复数的四则运算实现（运算符重载）

#include <iostream>
using namespace std;

class complex
{
public:
    complex(double real, double image) : m_real(real), m_image(image) {}
    complex() //无参构造
    {
        m_real = 0.0;
        m_image = 0.0;
    }
    // complex(double real):m_real(real) {}

    void display();
    complex operator+=(const complex &A);
    complex operator-=(const complex &A);
    complex operator*=(const complex &A);
    complex operator/=(const complex &A);

    complex &operator++();               //前置加加
    complex operator++(int);             //后置加加
    complex &operator--();               //前置减减
    complex operator--(int);             //后置减减
    operator double() { return m_real; } //重载强制类型转换符号
    operator int() { return m_real; }    //重载强制类型转换符号

    friend complex operator+(const complex &A, const complex &B);
    friend complex operator-(const complex &A, const complex &B);
    friend complex operator*(const complex &A, const complex &B);
    friend complex operator/(const complex &A, const complex &B);

    friend istream &operator>>(istream &in, complex &a);
    friend ostream &operator<<(ostream &in, const complex &a);

private:
    double m_real;  //实部
    double m_image; //虚部
};

complex complex::operator+=(const complex &A)
{
    this->m_real = this->m_real + A.m_real;
    this->m_image = this->m_image + A.m_image;
    return *this;
}

complex complex::operator-=(const complex &A)
{
    this->m_real = this->m_real - A.m_real;
    this->m_image = this->m_image - A.m_image;
    return *this;
}

complex complex::operator*=(const complex &A)
{
    this->m_real = this->m_real * A.m_real - this->m_image * A.m_image;
    this->m_image = this->m_image * A.m_real + this->m_real * A.m_image;
    return *this;
}

complex complex::operator/=(const complex &A)
{
    this->m_real = (this->m_real * A.m_real + this->m_image * A.m_image) / (A.m_real * A.m_real + A.m_image * A.m_image);
    this->m_image = (this->m_image * A.m_real - this->m_real * A.m_image) / (A.m_real * A.m_real + A.m_image * A.m_image);
    return *this;
}

complex operator+(const complex &A, const complex &B)
{
    complex C;
    C.m_real = A.m_real + B.m_real;
    C.m_image = A.m_image + B.m_image;
    return C;
}

complex operator-(const complex &A, const complex &B)
{
    complex C;
    C.m_real = A.m_real - B.m_real;
    C.m_image = A.m_image - B.m_image;
    return C;
}

complex operator*(const complex &A, const complex &B)
{
    complex C;
    C.m_real = A.m_real * B.m_real - A.m_image * B.m_image;
    C.m_image = A.m_image * B.m_real + A.m_real * B.m_image;
    return C;
}

complex operator/(const complex &A, const complex &B)
{
    complex C;
    C.m_real = (A.m_real * B.m_real + A.m_image * B.m_image) / (B.m_real * B.m_real + B.m_image * B.m_image);
    C.m_image = (A.m_image * B.m_real - A.m_real * B.m_image) / (B.m_real * B.m_real + B.m_image * B.m_image);
    return C;
}

complex &complex::operator++()
{
    this->m_real++;
    this->m_image++;
    return *this;
}

complex complex::operator++(int)
{
    complex temp = *this;
    this->m_real++;
    this->m_image++;
    return temp;
}

complex &complex::operator--()
{
    this->m_real--;
    this->m_image--;
    return *this;
}

complex complex::operator--(int)
{
    complex temp = *this;
    this->m_real--;
    this->m_image--;
    return temp;
}

istream &operator>>(istream &in, complex &a)
{
    in >> a.m_real >> a.m_image;
    return in;
}

ostream &operator<<(ostream &out, const complex &a)
{
    out << a.m_real << "+" << a.m_image << "i";
    return out;
}

void complex::display()
{
    cout << m_real << "+" << m_image << "i" << endl;
}

int main()
{

    complex A(1, 2);
    cout << A << endl;
    complex B(2.3, 3.4);
    cout << B << endl;

    //complex C = A + 2.2;
    // cout << C << endl;

    complex d;
    cin >> d;
    cout << ++d << endl;
    cout << d++ << endl;
    cout << d << endl;
    cout << --d << endl;
    cout << d-- << endl;
    cout << d << endl;

    int a = A;
    cout << a << endl;

    return 0;
}