c++之复数类运算

在写之前本人头脑是懵的，因为完全忘记了复数是什么，原谅我高中数学不好。

那么我们大体回顾一下复数，即a+bi,那么关于它的运算法则大体有以下几种。

1.加法法则

  复数的加法按照以下规定的法则进行：设z1=a+bi,z2=c+di是任意两个复数，则它们的和是

 (a+bi)+(c+di)=(a+c)+(b+d)i;返回值类型也应为复数（complex）

2.减法法则

 复数的减法按照以下规定的法则进行：设z1=a+bi,z2=c+di是任意两个复数，则它们的差是 (a+bi)-(c+di)=(a-c)+(b-d)i.

两个复数的差依然是复数，它的实部是原来两个复数实部的差，它的虚部是原来两个虚部的差。

返回值类型也应为复数（complex）

3.乘法法则

规定复数的乘法按照以下的法则进行：设z1=a+bi，z2=c+di(a、b、c、d∈R)是任意两个复数，那么它们的积(a+bi)(c+di)=(ac-bd)+(bc+ad)i.

返回值类型也应为复数（complex）

其实就是把两个复数相乘，类似两个多项式相乘，展开得: ac+adi+bci+bdi^2，因为i^2=-1，所以结果是(ac－bd)+(bc+ad)i 。

两个复数的积仍然是一个复数。

4.除法法则

满足(c+di)(x+yi)=(a+bi)的复数x+yi(x,y∈R)叫复数a+bi除以复数c+di的商

运算方法：可以把除法换算成乘法做,在分子分母同时乘上分母的共轭. 所谓共轭你可以理解为加减号的变换,互为共轭的两个复数相乘是个实常数 . 运算结果为：

(ac+bd)/(c^2+d^2)+(bc-ad)/(c^2+d^2)i

返回值类型也应为复数（complex）

除此以外本人也加进去了一些别的运算如：前置++，后置++，前置--，后置--，+=，

-=，以及判断两个复数是否相等。

代码实现如下

#include<iostream>

<span style="font-size:24px;"><span style="font-size:24px;">#include <cstdlib>

using namespace std;

class Complex
{
public:
	Complex(double r,double i);
	Complex operator+(const Complex c);
	Complex operator-(const Complex &c);
	Complex  operator *(const Complex &c);
	Complex operator/(const Complex &c);
	Complex &operator+=(const Complex c);
	Complex &operator-=(const Complex c);
	bool operator==(const Complex &c);
	Complex operator++();
	Complex operator++(int);
	Complex operator--();
	Complex operator--(int);

	void print(Complex &c);
	//~Complex();//析构函数

private:
	double _real;
	double _image;
};

Complex::Complex(double r=0.0,double i=0.0)
{
	_real=r;//复数实部
	_image=i;//复数虚部
}
Complex Complex:: operator+(const Complex c)//两复数相加
{
	Complex tmp;
	tmp._real =_real+c._real ;
	tmp._image =_image+c._image ;
	return tmp;
}
Complex Complex::operator-(const Complex &c)//两复数相减                                    c的值在函数内部不需要改变，所以采用常引用
{
	Complex tmp;
	tmp._real =_real-c._real ;
	tmp._image =_image-c._image ;
	return tmp;
}
Complex Complex::operator*(const Complex &c)//(a+bi)(c+di)=(ac-bd)+(bc+ad)i.
{
	Complex tmp;
	tmp._real=_real*c._real-_image*c._image;
	tmp._image= _image*c._real +_real*c._image;
	return tmp;
}
Complex Complex::operator/(const Complex &c)//(a+bi)(c-di)/(c+di)(c-di)
	(ac+bd)/(c^2+d^2)+(bc-ad)/(c^2+d^2)i
{ 
	Complex tmp;
	double deno=c._real*c._real+c._image*c._image;//有理化后的分母denominator   
	tmp._real=deno*((_real*c._real)+(_image*c._image));
	tmp._image=deno*((_image*c._real )-(_real*c._image));
	return tmp;
}
Complex& Complex ::operator+=(const Complex c)//加上自身
{
	this->_real += c._real ;
	this->_image += c._image ;
	return *this;
}
Complex& Complex::operator-=(const Complex c)//加上自身
{
	this->_real -= c._real ;
	this->_image -= c._image ;
	return *this;
}
bool Complex::operator==(const Complex &c)//判断两个复数是否相等
{
	return(_real==c._real)&&(_image==c._image);
}
Complex Complex::operator++()//前置++
{
	this->_real+=1;
	this->_image+=1;
	return *this;
}
Complex Complex::operator++(int)//后置++
{
	Complex tmp(*this);//拷贝构造用来保存原来的值
	this->_real++;
	this->_image++;
	return tmp;//返回临时变量所以不能以引用作为返回值
}
Complex	Complex::operator--()//前置--
{
	this->_real-=1;
	this->_image-=1;
	return *this;
}
Complex Complex::operator--(int)//后置--
{
	
	Complex tmp(*this);//拷贝构造用来保存原来的值
	this->_real--;
	this->_image--;
	return tmp;//返回临时变量所以不能以引用作为返回值
}

void Complex::print(Complex &c)
{
	cout<<c._real<<"+ "<<c._image<<"i"<<endl;
}

int main()
{
	Complex *c=NULL;
	Complex c1(6.0,5.0);
	Complex c2(3.0,4.0);
	Complex ret;
	cout<<(c1==c2)<<endl;//输出c1,c2是否相等
	c->print(c1);//输出c1+c2
	c->print(c2);
	cout<<"c1+c2=";
	ret=c1+c2;
	c->print(ret);
	c->print (c1);//输出c1自加
	ret=++c1;   
	c->print(ret);//
	system("pause");
	return 0;</span>
}</span></span>

部分运行结果：

那么我们简单总结一下运算符重载的几个特点

 1.赋值运算符的重载是对一个已经存在的对象进行复制
       2.运算符重载不改变运算符的优先级/结合性/操作符个数
       3.几个C++不能重载的运算符：   .* (点乘)  ， ::(作用域解析符) /， sizeof  ，  ?:(条件运算符)   .
    

相信你也看出来，这个程序运用最多的便是运算符重载，其次还用到隐含的this指针那么下一篇可能会对这两个进行深一步的理解。

                     未完待续！