c++ complex 实现

1.complex.h

#ifndef COMPLEX_H
#define COMPLEX_H
class Complex
{
public:
	Complex(double r = 0,double i = 0):m_re(r),m_im(i){}
	Complex& operator+= (const Complex& rhs);  
	Complex& operator-= (const Complex& rhs);
	//基于练习的目的 将一个写为成员函数
	Complex operator* ( const Complex& rhs);  

	double real()const { return this->m_re; }
	double imag()const { return this->m_im; }

private:
	friend Complex& __doapl(Complex* lhs, const Complex& rhs);
	friend Complex& __doami(Complex* lhs, const Complex& rhs);
	friend Complex& __doaml(Complex* lhs, const Complex& rhs);

	double m_re;
	double m_im;
};
//基于练习的目的 将一个 写为非成员函数
Complex& operator*= (Complex &lhs,const Complex& rhs); 
Complex operator+ (const Complex& lhs, const Complex& rhs);
Complex operator- (const Complex& lhs, const Complex& rhs);




#endif // !COMPLEX_H

2.complex.cpp

#include <iostream>
#include "complex.h"

std::ostream& operator<< (std::ostream& os, const Complex& rhs)
{
	return os << "(" << rhs.real() << "," << rhs.imag() << ")";
}

Complex& __doapl(Complex* lhs,const Complex& rhs)
{
	lhs->m_re += rhs.m_re;
	lhs->m_im += rhs.m_im;
	return *lhs;
}

Complex& __doami(Complex* lhs, const Complex& rhs)
{
	lhs->m_re -= rhs.m_re;
	lhs->m_im -= rhs.m_im;
	return *lhs;
}

//此处不再按照正常的复数相乘逻辑 
Complex& __doaml(Complex* lhs, const Complex& rhs)  
{
	lhs->m_re *= rhs.m_re;  
	lhs->m_im *= rhs.m_im;
	return *lhs;
}

Complex& Complex::operator+= (const Complex& rhs)
{
	return __doapl(this, rhs);
}

Complex& Complex::operator-= (const Complex& rhs)
{
	return __doami(this, rhs);
}
Complex Complex::operator* (const Complex& rhs)
{
	return Complex(this->m_re * rhs.m_re, this->m_im * rhs.m_im);
}


Complex& operator*= (Complex& lhs, const Complex& rhs)
{
	return __doaml(&lhs, rhs);
}

Complex operator + (Complex& lhs, const Complex& rhs)
{
	return Complex(lhs.real() + rhs.real(), lhs.real() + rhs.imag());
}

Complex operator - (Complex& lhs, const Complex& rhs)
{
	return Complex(lhs.real() - rhs.real(), lhs.real() - rhs.imag());
}

int main()
{
	Complex c1(3, 3);
	Complex c2(2, 2);
	std::cout << (c1 += c2) << std::endl;
	std::cout << c1 << std::endl;//(5,5)
	std::cout << (c1 -= c2) << std::endl;
	std::cout << c1 << std::endl;
	std::cout << (c1 *= c2) << std::endl;
	std::cout << c1 << std::endl;//(6,6)
	std::cout << "-------------------" << std::endl;
	Complex c3 = c1 + c2;
	std::cout << c3<<std::endl;
	Complex c4 = c1 - c2;
	std::cout << c4 << std::endl;
	Complex c5 = c1 * c2;
	std::cout << c5 << std::endl;

	std::cout << "-------------------" << std::endl;

	c3 = c1 - c2;  // 有默认的复制运算 如果包含指针的话 需要重载
	std::cout << c3 << std::endl;

	
	return 0;


}