C++重载运算符实现复数的操作

代码结构：Complex.h定义类。Complex.cpp定义了成员函数。main.cpp验证功能。

代码的解释全都嵌在代码上了，只贴代码：

Complex.h:

#pragma once

namespace NS_Complex {

	class Complex {

	public:
		Complex();//默认构造函数
		Complex(float, float);//指定xy的构造函数
		~Complex();//析构函数
		void ReSet();//重置清零操作
		Complex operator + (const Complex&) const;//'+'
		Complex operator - (const Complex&) const;//'-'
		Complex operator * (const Complex&) const;//'*'
		Complex operator / (const Complex&) const;//'/'
		Complex operator * (float);//复数乘以常数，后置常数
		friend Complex operator * (const float , const Complex& );//复数乘以常数，前置常数 必须用到友元的形式
		Complex operator + (float);//复数加常数
		friend Complex operator + (const float , const Complex& );//常数加复数
		Complex operator - (float);//复数减常数
		friend Complex operator - (const float, const Complex&);//常数减复数
		Complex operator / (const float);//复数除以常数
		friend Complex operator / (const float, const Complex&);//常数除以负数
		Complex& operator -();//复数取反
		Complex& operator ~();//取共轭
		void Show() const;//展示复数
	private:

		float m_fX;
		float m_fY;
		int m_nExceptionFlag;//当分子和分母同时为0时，不能作为被除数，那么可用这个标志位来判断异常，但本次不做此功能

	};

}

Complex.cpp:

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

namespace NS_Complex
{

	using namespace std;

	Complex::Complex()
	{
		m_fX = 0.0;
		m_fY = 0.0;
		m_nExceptionFlag = 0;
	}

	Complex::Complex(float x, float y)
	{
		m_fX = x;
		m_fY = y;
	}

	Complex::~Complex()
	{
		;
	}

	void Complex::ReSet()//重置清零操作
	{
		m_fX = 0.0;
		m_fY = 0.0;
	}

	Complex Complex::operator + (const Complex& A) const//'+'
	{
		Complex B(this->m_fX + A.m_fX, this->m_fY + A.m_fY);
		return B;
	}
	Complex Complex::operator - (const Complex& A) const//'-'
	{
		Complex B(this->m_fX - A.m_fX, this->m_fY - A.m_fY);
		return B;
	}
	Complex Complex::operator * (const Complex& A) const//'*'
	{
		Complex B(this->m_fX * A.m_fX - this->m_fY * A.m_fY, this->m_fX * A.m_fY + this->m_fY * A.m_fX);
		return B;
	}
	Complex Complex::operator / (const Complex& A) const//'/' 分子分母同时乘以分母的共轭，那么分母会变成一个常数，相当于分子的结果除以常数
	{
		Complex B(this->m_fX * A.m_fX + this->m_fY * A.m_fY, -this->m_fX* A.m_fY + this->m_fY * A.m_fX);
		B = B / (A.m_fX*A.m_fX + A.m_fY*A.m_fY);//注意这里在除以分母位置上的那个常数的时候，采用了重载除以常数的成员函数。
		return B;
	}
	Complex Complex::operator * (float a)//复数乘以常数，后置常数
	{
		return Complex(this->m_fX*a, this->m_fY*a);//显示调用构造函数返回临时complex对象
	}
	Complex operator * (const float a,const Complex& A)//复数乘以常数，前置常数 注意这个函数并不是Complex的成员函数
	{
		//第一种做法：
		Complex B{ a*A.m_fX,a*A.m_fY };//拷贝构造函数，我们不需要单独定义，编译器会帮我们自动生成一个对象之间的浅拷贝的构造函数，这对于我们来说足够用了.但是对于那种有一部分成员变量不需要复制的时候，需要用到第二种做法。
		return	B;
		//第二种做法（无需声明友元的方法）：这种方法即使函数不是成员函数也可以。但是因为参数列表里面的A是常，所以需要生成一个非const变量return出去
		Complex C{ A };
		return C * a;
		// 此种方法并不需要真正得把这个函数声明为类的友元函数。
	}
	Complex Complex::operator + (float a)//复数加常数
	{
		this->m_fX += a;
		return *this;
	}
	Complex operator + (const float a, const Complex& A)//常数加复数
	{
		//第一种做法：
		Complex B{ a+A.m_fX,A.m_fY };//拷贝构造函数，我们不需要单独定义，编译器会帮我们自动生成一个对象之间的浅拷贝的构造函数，这对于我们来说足够用了.但是对于那种有一部分成员变量不需要复制的时候，需要用到第二种做法。
		return	B;
		//第二种做法：
		Complex C{ A };
		return C + a;
	}
	Complex Complex::operator - (float a)//复数减常数
	{
		return Complex{ this->m_fX - a,this->m_fY };
	}
	Complex operator - (const float a, const Complex& A)//常数减复数
	{
		//第一种做法：
		Complex B{ a - A.m_fX,-A.m_fY };//拷贝构造函数，我们不需要单独定义，编译器会帮我们自动生成一个对象之间的浅拷贝的构造函数，这对于我们来说足够用了.但是对于那种有一部分成员变量不需要复制的时候，需要用到第二种做法。
		return	B;
		//第二种做法：
		Complex C{ A };
		return -(C - a);//前面这个负号我要我们重载之后才能支持。千万别按照数学的逻辑吧这个括号消除。哈
	}
	Complex Complex::operator / ( const float a)//复数除以常数 记住这里的返回值不能为引用
	{
		this->m_fX /= a;
		this->m_fY /= a;
		return *this;
	}
	Complex operator / (const float a, const Complex& A)//常数除以负数
	{
		//第一种做法：
		Complex B(a * A.m_fX + 0 * A.m_fY, -a* A.m_fY + 0 * A.m_fX);
		B = B / (A.m_fX*A.m_fX + A.m_fY*A.m_fY);//注意这里在除以分母位置上的那个常数的时候，采用了重载除以常数的成员函数。
		return	B;
		//第二种做法：
		Complex C(a, 0);
		return C / A;
	}

	Complex& Complex::operator -()//复数取反 此运算符是前置的，所以括号中不需要参数，而this指针是隐含存在的
	{	
		this->m_fX = 0 - this->m_fX;
		this->m_fY = 0 - this->m_fY;
		return *this;
	}
	Complex& Complex::operator ~()//取共轭 此运算符是前置的，所以括号中不需要参数，而this指针是隐含存在的
	{
		this->m_fY = 0 - this->m_fY;
		return *this;
	}
	void Complex::Show() const//展示复数
	{
		cout.precision(3);//固定精度2位
		cout.setf(ios::fixed);//强制显示小数点，防止XY为整数的时候不显示小数点
		cout << "[" << this->m_fX << "," << this->m_fY <<"]"<< endl;
		return ;
	}


}

Main.cpp:

// Main.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Complex.h"
#include <iostream>
using namespace std;
using namespace NS_Complex;

int main()
{
	//加法测试
	Complex A;//默认构造函数
	Complex B{ 2.001f,3.001f };//列表初始化,此处如果不加f，那么常数在存储时默认为是double，编译会报错：double转化为float是缩窄转化
	Complex C = A + B;
	C.Show();

	//减法测试
	Complex D{7.001f,8.002f};
	Complex E{ 2.001f,3.001f };//列表初始化
	Complex F =  -(D - E);//包含了取反运算
	F.Show();

	//乘法测试
	Complex J{5,5,};//int可以转化为float
	Complex H{ 2.001f,3.001f };//列表初始化
	Complex I = ~(10*J * H *10);//这里面既包含了前置乘以常数，又包含了后置乘以常数。
	I.Show();

	//除法测试
	Complex G{12,15};
	Complex K{ 2.0f,3.0f };//列表初始化
	Complex L = G / K;
	L.Show();

	cin.get();
    return 0;
}

运算结果：

[2.001,3.001]
[-5.000,-5.001]
[-500.000,-2501.000]
[5.308,-0.462]

这是一个关于重载和友元的简单例子。不过发现由于构造函数是参数为float的，但是直接写Complex(2.0,3.0)竟让编译报错：无法从double缩窄成float，看来是由于常量2.0的存储是double的形式，所以加一个f来显式的指出是float类型的。