实现复数模板类

#include<iostream>
using namespace std;

template<typename T>
class Complex {
public:
	//借助函数的默认参数，可以普通构造函数和“转换构造函数”
	//精简为以下带默认参数的构造函数
	Complex(T a=0, T b=0) :m_real(a), m_imag(b){};
	//拷贝构造函数
	Complex(const Complex& c);

	//析构函数
	~Complex() {};
	
	//基本的成员函数
	T getReal() const { return m_real; }  
	void setReal(T r) { m_real = r; }    

	T getImag() const { return m_imag; }
	void setImag(T i) { m_imag = i; }

	//赋值运算符
	Complex& operator=(const Complex& b);

public:
	//类型转换函数，将当前类型转换为其它类型
	//没有必要明确指明返回值的类型，因为类型转换函数
	//要转换的目标类型为double，所以返回值类型也为double类型
	//相当于隐式地指明了返回值类型
	operator double()const { return m_real; }

	//以成员函数的形式定义
	Complex& operator+=(const Complex& a);
	Complex& operator-=(const Complex& a);
	Complex& operator*=(const Complex& a);
	Complex& operator/=(const Complex& a);

	//两种不同的实现方式，在没有“=”运算符时，不要返回引用类型
	//方式一
	Complex& operator+(const Complex& a);
	//方式二
	Complex operator-(const Complex& a);
	Complex operator*(const Complex& a);
	Complex operator/(const Complex& a);
	//在没有等于运算符时，不要返回引用类型
	Complex operator--();
	Complex operator++();
	Complex operator--(int);
	Complex operator++(int);


private:
	T m_real;
	T m_imag;
};
template<typename T>
Complex<T> operator+(const Complex<T>& c1,const Complex<T>& c2)
{
	Complex<T> ss;
	ss.m_imag = c1.m_imag + c2.m_imag;
	ss.m_real = c1.m_real + c2.m_real;
	return ss;
}

template<typename T>
Complex<T>::Complex(const Complex<T>& c)
{
	m_real = c.m_real;
	m_imag = c.m_imag;
}

template<typename T>
ostream& operator<<(ostream& out, const Complex<T>& d)
{
	out << d.getReal() << "+" << d.getImag() << "i";
	return out;
}

template<typename T>
Complex<T>& Complex<T>::operator=(const Complex<T>& b)
{
	this->m_imag = b.m_imag;
	this->m_real = b.m_real;
	return *this;
}

template<typename T>
Complex<T>& Complex<T>::operator+=(const Complex<T>& a)
{
	this->m_real += a.m_real;
	this->m_imag += a.m_imag;
	return *this;
}
template<typename T>

Complex<T>& Complex<T>::operator-=(const Complex<T>& a)
{
	this->m_real -= a.m_real;
	this->m_imag -= a.m_imag;
	return *this;
}

template<typename T>
Complex<T>& Complex<T>::operator*=(const Complex<T>& a)
{
	this->m_real *= a.m_real;
	this->m_imag *= a.m_imag;
	return *this;
}

template<typename T>
Complex<T>& Complex<T>::operator/=(const Complex<T>& a)
{
	this->m_real /= a.m_real;
	this->m_imag /= a.m_imag;
	return *this;
}
//

template<typename T>
Complex<T>& Complex<T>::operator+(const Complex<T>& a)
{
	//Complex<T> c;
	//c.m_real = m_real+ a.m_real;
	//c.m_imag = m_imag+ a.m_imag;
	//return c;
	this->m_imag += a.m_imag;
	this->m_real += a.m_real;
	return *this;
}

template<typename T>
Complex<T> Complex<T>::operator-(const Complex<T>& a)
{
	Complex<T> c;
	c.m_real = m_real - a.m_real;
	c.m_imag = m_imag - a.m_imag;
	return c;
}

template<typename T>
Complex<T> Complex<T>::operator*(const Complex<T>& a)
{
	Complex<T> c;
	c.m_real = m_real * a.m_real;
	c.m_imag = m_imag * a.m_imag;
	return c;
}

template<typename T>
Complex<T> Complex<T>::operator/(const Complex<T>& a)
{
	Complex<T> c;
	c.m_real = m_real / a.m_real;
	c.m_imag = m_imag / a.m_imag;
	return c;
}

//前置
template<typename T>
Complex<T> Complex<T>::operator--()
{
	this->m_imag--;
	this->m_real--;
	return *this;
}

template<typename T>
Complex<T> Complex<T>::operator++()
{
	this->m_imag++;
	this->m_real++;
	return *this;
}

//后置
template<typename T>
Complex<T> Complex<T>::operator--(int )
{
	Complex<T> x = *this;
	this->m_imag--;
	this->m_real--;
	return x;
}

template<typename T>
Complex<T> Complex<T>::operator++(int)
{
	Complex<T> x = *this;
	this->m_imag++;
	this->m_real++;
	return x;
}

int main()
{
	Complex<int> wh(1,2);
	Complex<int> qq = wh;
	Complex<int> ss;
	ss = qq;
	cout << wh << " " << qq << endl;


	Complex<double> oo(10.2,15.3),pp(1.2,5.5);
	pp += oo;
	cout << pp << endl;
	pp -= oo;
	cout << pp << endl;
	pp *= oo;
	cout << pp << endl;
	pp /= oo;
	cout << pp << endl;

	pp = pp + oo;
	cout << pp << endl;
	pp = pp - oo;
	cout << pp << endl;
	pp = pp * oo;
	cout << pp << endl;
	pp = pp / oo;
	cout << pp << endl;

	oo = pp++;
	cout << oo << endl;
	cout << pp << endl;
	oo = ++pp;
	cout << oo << endl;
	cout << pp << endl;
	oo = pp--;
	cout << oo << endl;
	cout << pp << endl;
	oo = --pp;
	cout << oo << endl;
	cout << pp << endl;

	//执行该语句时会产生二义性问题，即编译器不知道是将3.3转换为Complex类型
	//后再执行+运算符，还是将pp类型转换成double类型后再执行+运算符
	//编译器会先只关注pp+3.3这个表达式，不会受=影响
	///要解决二义性问题，可以只定义转换构造函数，不定义类型转换函数，
	//要实现类型转换功能可以借助成员函数，如getReal（）。
	//oo = pp + 3.3;

	//也可以显示地使用强制类型转换实现该功能
	//先使用默认构造函数（转换构造函数），将double类型转换为Complex类型，再进行运算
	pp = (Complex<double>)2.5 + oo;
	cout << pp << endl;

	//先使用类型转换函数，将Complex转换为double类型，再运算，然后将double类型转换为Complex类型，再赋值
	pp = 2.5 + oo;
	cout << pp << endl;

	return 0;

}