复 数 的 运 算 法 则

【复数的四则运算（C++）】
------------------------------------------------------------------------------------------------------
**复数x被定义为二元有序实数对(a,b)，记为z=a+bi,这里a和b是实数，i是虚数单位。

**在复数a+bi中，a=Re(z)称为实部，b=Im(z)称为虚部。

当虚部等于零时，这个复数可以视为实数；
**当z的虚部不等于零时，实部等于零时，常称z为纯虚数。

**复数的四则运算规定为：
**加法法则：（a+bi）+（c+di）=（a+c）+（b+d）i；
**减法法则：（a+bi）－（c+di）=（a－c）+（b－d）i；
**乘法法则：（a+bi）·（c+di）=（ac－bd）+（bc+ad）i；
**除法法则：（a+bi）÷（c+di）=[（ac+bd）-（c2+d2）]+[（bc-ad）-（c2+d2）]i.
**当复数的实部和虚部都相等时，两个复数相等
**只有当复数的虚部等于零的时候两个复数才可以比较大小
------------------------------------------------------------------------------------------------------
C++代码：
-------------------------------------------头文件-----------------------------------------------------
#?ifndef?__COMPLEX_H__?
#?define?__COMPLEX_H__
#?define?_CRT_SECURE_NO_WARNINGS?1
#?include?iostream
#?include?stdlib.h
using?namespace?std;
--声明复数类
class?Complex
public:
voidComplex::Print();
public:
Complex(doublereal,doublep_w_picpath); Complex(constComplexZ);
~Complex();
boolComplex::operator(constComplexZ); boolComplex::operator(constComplexZ); boolComplex::operator==(constComplexZ); public:
ComplexComplexAdd(constComplexZ); ComplexComplexSub(constComplexZ); ComplexComplexMul(constComplexZ); ComplexComplexDiv(constComplexZ);
private:
double_real;
double_p_w_picpath;
#?endif?--__COMPLEX_H__
----------------------------------------------函数---------------------------------------------------- #?include?"Complex.h"
--打印函数
void?Complex::Print()
if(!this-_p_w_picpath)
if(!this-_real)
cout0endl;
coutthis-_realendl;
elseif(!this-_real)
coutthis-_p_w_picpath'i'endl;
if(this-_p_w_picpath0)
coutthis-_realthis-_p_w_picpath'i'endl;
coutthis-_real'+'this-_p_w_picpath'i'endl;
--构造函数
Complex::Complex(double?real,?double?p_w_picpath)
_real=real;
_p_w_picpath=p_w_picpath;
--拷贝构造函数
Complex::Complex(const?Complex?Z)
_real=Z._real;
_p_w_picpath=Z._p_w_picpath;
--析构函数
Complex::~Complex()
--这里的析构函数不需要做任何操作
--操作符重载
-*小于*-
bool?Complex::operator?(const?Complex?Z)
if(!this-_p_w_picpath!Z._p_w_picpath)
if(this-_realZ._real)
returntrue;
returnfalse;
-*大于*-
bool?Complex::operator?(const?Complex?Z)
if(!this-_p_w_picpath!Z._p_w_picpath)
if(this-_realZ._real)
returntrue;
returnfalse;
-*等于*-
bool?Complex::operator==?(const?Complex?Z)
if(!this-_p_w_picpath!Z._p_w_picpath)
if(this-_real==Z._real)
returntrue;
elseif(this-_p_w_picpath==Z._p_w_picpath) if(this-_real==Z._real)
returntrue;
returnfalse;
--四则运算
-*加法*-
Complex?Complex::ComplexAdd(const?Complex?Z) Complextmp(*this);
tmp._real?+=?Z._real;
tmp._p_w_picpath?+=?Z._p_w_picpath;
return?tmp;
-*减法*-
Complex?Complex::ComplexSub(const?Complex?Z) Complextmp(*this);
tmp._real-=Z._real;
tmp._p_w_picpath-=Z._p_w_picpath; returntmp;
-*乘法*-
Complex?Complex::ComplexMul(const?Complex?Z)
Complextmp(*this);
tmp._real=(this-_real*Z._real)-(this-_p_w_picpath *Z._p_w_picpath);
tmp._p_w_picpath=(this-_p_w_picpath*Z._real)+(thi s-_real?*?Z._p_w_picpath);
returntmp;
-*除法*-
Complex?Complex::ComplexDiv(const?Complex?Z)
Complextmp(*this);
tmp._real=((this-_real*Z._real)+(this-_p_w_picpat h?*?Z._p_w_picpath))?
-((Z._real*Z._real)+(Z._p_w_picpath*Z._p_w_picpa th));
tmp._p_w_picpath=((this-_p_w_picpath*Z._real)-(th is-_real?*?Z._p_w_picpath))
-((Z._real*Z._real)+(Z._p_w_picpath*Z._p_w_picpa th));
returntmp;
------------------------------------------ 测试用例-------------------------------------------------- #?include?"Complex.h"
--测试四则运算
-*测试加法*-
-*ComplexZ1(1,2);
ComplexZ2(1,2);
Complexret=plexAdd(Z2); ret.Print();*-
-*测试减法*-
-*ComplexZ1(-1,2);
ComplexZ2(1,1);
Complexret=plexSub(Z2); ret.Print();*-
-*测试乘法*-
-*ComplexZ1(1,-2);
ComplexZ2(1,2);
Complexret=pleMul(Z2); ret.Print();*-
-*测试除法*-
ComplexZ1(1,2);
ComplexZ2(1,1);
Complexret=plexDiv(Z2); ret.Print();*-
--测试操作符重载
boolRET;
-*测试“”*-
--ComplexZ1(1,4); --ComplexZ2(1,4); --RET=Z1Z2;
--coutRETendl;
--ComplexZ3(1,0); --ComplexZ4(2,0); --RET=Z3Z4;
--coutRETendl;
-*测试“”*-
-*ComplexZ1(1,0); ComplexZ2(2,0); RET=Z1Z2; coutRETendl; ComplexZ3(3,0); ComplexZ4(2,0); RET=Z3Z4; coutRETendl;*-
-*测试“==”*- ComplexZ1(1,4);
ComplexZ2(1,4); RET=Z1==Z2; coutRETendl; ComplexZ3(1,1); ComplexZ4(1,3); RET=Z3==Z4; coutRETendl; ComplexZ5(1,0); ComplexZ6(1,0); RET=Z5==Z6; coutRETendl;
--测试拷贝构造函数void?Test2() ComplexZ1(1,3); Z1.Print(); ComplexZ2(Z1);
Z2.Print();
--测试构造函数void?Test1() ComplexZ1(1,3); Z1.Print();
int?main()
--Test1();
--Test2();
--Test3();
Test4();
system("pause");
return0;
----------------------------------------------------------------------------------------------------- ?
C++中的空类，默认产生六个默认成员函数，分别是：构造函数，拷贝（赋值）构造函数，析构函数，赋值操作符重载，取地址操作符重载，const修饰的取地址操作符重载。

所谓默认的成员函数，是指，若程序员没有创建该函数，系统则会自动创建。

------------------------------------------------------------------------------------------------------
return Complex(c1.real*c2.real - c1.imag*c2.imag, c1.real*c2.imag + c1.imag*c2.real);
请记住，这样的表达式相乘，实际上就是把各表达式的每一项都相乘，可以运用两次乘法分配律，你也可以用foil法则（就是全部项两两相乘）来提醒自己用这个复数的每一部分乘以这个复数的每一个部分，我们就随便用一种方法吧：
image=image*c2.real+real*c2.image;
即对任意复数z1，z2，z3，有：z1+z2=z2+z1；(z1+z2)+z3=z1+(z2+z3)。

if(z.re==0z.im==0)a setiosflags(ios::fixed) setprecision(0) z.re;
一个四元数的自身点积是个标量。

四元数除以一个标量等效于乘上此标量的倒数，而使四元数的每个元素皆除以此一除数。

Complex(reality+c1.reality,falsehood+c1.falsehood); } Complex
--2. 类的名字为 DivisionException，继承自 runtime_error （需包含头文件 stdexcept）
显然，当k从0依次取到n－1,所得到的角的终边互不相同，但k 从n开始取值后，前面的终边又周期性出现。

因此，复数z的n个n 次方根为:
则它们的和是 (a+bi)+(c+di)=(a+c)+(b+d)i。