C++复数类的简单实现

功能实现

重载了operator+、operator-、operator*、operator/，实现了复数和复数、整型变量、浮点型变量的加减乘除运算以及复数输出运算。

复数类定义

#pragma once
#include <iostream>
#include <cmath>
using namespace std;

//返回值类型定义
template<typename T1, typename T2>
class complex_return{
};
template<>
class complex_return<int, float> {
public:
	typedef float ReturnType;
};
template<>
class complex_return<float, int> {
public:
	typedef float ReturnType;
};
template<>
class complex_return<int, double> {
public:
	typedef double ReturnType;
};
template<>
class complex_return<double, int> {
public:
	typedef double ReturnType;
};
template<>
class complex_return<double, float> {
public:
	typedef double ReturnType;
};

template<typename T>
class complex_return<T, T> {
public:
	typedef T ReturnType;
};



template <typename T>
class complex {
private:
	T re,im;
	T p_2() { return re * re + im * im; }
public:
	complex(T r, T i);
	complex(const complex& c);
	//复数的模
	double modulus();
	//复数的角度
	double angel();
	//复数加法
	template<typename T1>
	complex<typename complex_return<T,T1>::ReturnType> operator + (const complex<T1>& c);
	template<typename T1>
	complex<typename complex_return<T, T1>::ReturnType> operator + (const T1& c);
	template<typename T,typename T1>
	friend complex<typename complex_return<T, T1>::ReturnType> operator + <>(const T1& v, const complex<T>& c);
	//复数减法
	template<typename T1>
	complex<typename complex_return<T, T1>::ReturnType> operator - (const complex<T1>& c);
	template<typename T1>
	complex<typename complex_return<T, T1>::ReturnType> operator - (const T1& c);
	template<typename T, typename T1>
	friend complex<typename complex_return<T, T1>::ReturnType> operator - <>(const T1& v, const complex<T>& c);
	//复数乘法
	template<typename T1>
	complex<typename complex_return<T, T1>::ReturnType> operator * (const complex<T1>& c);
	template<typename T1>
	complex<typename complex_return<T, T1>::ReturnType> operator * (const T1& c);
	template<typename T, typename T1>
	friend complex<typename complex_return<T, T1>::ReturnType> operator * <>(const T1& v, const complex<T>& c);
	//复数除法
	template<typename T1>
	complex<typename complex_return<T, T1>::ReturnType> operator / (const complex<T1>& c);
	template<typename T1>
	complex<typename complex_return<T, T1>::ReturnType> operator / (const T1& c);
	template<typename T, typename T1>
	friend complex<typename complex_return<T, T1>::ReturnType> operator / <>(const T1& v, const complex<T>& c);
	//复数乘方
	complex<T> pow(unsigned un) { return un == 0 ? complex<T>(1, 0) : (un == 1 ? *this : (*this)*pow(un - 1)); }
	//输出
	friend ostream& operator<<  <> (ostream& os, const complex<T>& c);
	const T& getR() const{ return re; }
	const T& getI() const{ return im; }
};


#include "complex_implementation.h"

构造函数

#pragma once

//普通构造函数
template <typename T>
inline complex<T>::complex(T r, T i)
:re(r), im(i)
{
	//std::cout << "普通构造函数被调用" << std::endl;
}

//拷贝构造函数
template <typename T>
inline complex<T>::complex(const complex<T>& c)
:re(c.re), im(c.im)
{
	//std::cout << "复制构造函数被调用" << std::endl;
}

复数加法

#pragma once
template<typename T>
template<typename T1>
complex<typename complex_return<T, T1>::ReturnType> complex<T>::operator+ (const complex<T1>& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	return complex<ReturnType>((ReturnType)this->re+(ReturnType)c.getR(), (ReturnType)this->im + (ReturnType)c.getI());
}

template<typename T>
template<typename T1>
complex<typename complex_return<T, T1>::ReturnType> complex<T>::operator+ (const T1& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	return complex<ReturnType>((ReturnType)this->re + c, (ReturnType)this->im);
}

template<typename T,typename T1>
complex<typename complex_return<T, T1>::ReturnType> operator +(const T1& v, const complex<T>& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	return complex<ReturnType>((ReturnType)c.getR() + (ReturnType)v, (ReturnType)c.getI());
}

复数减法

#pragma once
template<typename T>
template<typename T1>
complex<typename complex_return<T, T1>::ReturnType> complex<T>::operator- (const complex<T1>& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	return complex<ReturnType>((ReturnType)this->re - (ReturnType)c.getR(), (ReturnType)this->im - (ReturnType)c.getI());
}

template<typename T>
template<typename T1>
complex<typename complex_return<T, T1>::ReturnType> complex<T>::operator- (const T1& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	return complex<ReturnType>((ReturnType)this->re - (ReturnType)c, (ReturnType)this->im);
}

template<typename T, typename T1>
inline complex<typename complex_return<T, T1>::ReturnType> operator- (const T1& v, const complex<T>& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	return complex<ReturnType>(-(ReturnType)c.getR() + (ReturnType)v, -(ReturnType)c.getI());
}

复数乘法

#pragma once
template<typename T>
template<typename T1>
complex<typename complex_return<T, T1>::ReturnType> complex<T>::operator* (const complex<T1>& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	return complex<ReturnType>((ReturnType)this->re * (ReturnType)c.getR()- (ReturnType)this->im * (ReturnType)c.getI(), (ReturnType)this->re * (ReturnType)c.getI()+ (ReturnType)this->im * (ReturnType)c.getR());
}

template<typename T>
template<typename T1>
complex<typename complex_return<T, T1>::ReturnType> complex<T>::operator* (const T1& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	return complex<ReturnType>((ReturnType)this->re * (ReturnType)c, (ReturnType)this->im * (ReturnType)c);
}

template<typename T, typename T1>
inline complex<typename complex_return<T, T1>::ReturnType> operator* (const T1& v, const complex<T>& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	return complex<ReturnType>((ReturnType)c.getR() * (ReturnType)v, (ReturnType)c.getI() * (ReturnType)v);
}

复数除法

#pragma once
template<typename T>
template<typename T1>
complex<typename complex_return<T, T1>::ReturnType> complex<T>::operator/ (const complex<T1>& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	ReturnType fm = (ReturnType)c.getR() * (ReturnType)c.getR() + (ReturnType)c.getI() * (ReturnType)c.getI();
	ReturnType fz1 = (ReturnType)this->re * (ReturnType)c.getR() + (ReturnType)this->im * (ReturnType)c.getI();
	ReturnType fz2 = -(ReturnType)this->re * (ReturnType)c.getI() + (ReturnType)this->im * (ReturnType)c.getR();
	return complex<ReturnType>(fz1/fm,fz2/fm );
}

template<typename T>
template<typename T1>
complex<typename complex_return<T, T1>::ReturnType> complex<T>::operator/ (const T1& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	ReturnType fm = (ReturnType)c;
	ReturnType fz1 = (ReturnType)this->re;
	ReturnType fz2 = -(ReturnType)this->im;
	return complex<ReturnType>(fz1 / fm, fz2 / fm);
}

template<typename T, typename T1>
inline complex<typename complex_return<T, T1>::ReturnType> operator / (const T1& v, const complex<T>& c)
{
	typedef complex_return<T, T1>::ReturnType ReturnType;
	ReturnType fm = (ReturnType)c.getR() * (ReturnType)c.getR() + (ReturnType)c.getI() * (ReturnType)c.getI();
	ReturnType fz1 = (ReturnType)v * (ReturnType)c.getR();
	ReturnType fz2 = -(ReturnType)v * (ReturnType)c.getI();
	return complex<ReturnType>(fz1 / fm, fz2 / fm);
}

复数输出

#pragma once
template <typename T>
inline ostream& operator<<  <>(ostream& os, const complex<T>& c)
{
	return os << "(" << c.re << "," << c.im << ")";
}

复数的模

#pragma once
template<typename T>
double complex<T>::modulus()
{
	return sqrt(p_2());
}

复数辐角

#pragma once
template<typename T>
double complex<T>::angel()
{
	return acos(re / modulus());
}