C++复数运算探究

题目说明
  抽象数据类型（ADT）的定义与实现: 复数a+bi,a为实部，b为虚部，请用C或C++语言定义和实现复数抽象数据类型。
  要求能够输入两个实数作为实部和虚部，用于初始化（创建）一个复数，对任意的两个复数，能够按照复数运算规则进行加、减、乘运算，定义求复数的模，求共轭复数的算法，并实现两个复数相除,并输出对应的计算结果。

Author:Lee X;
Operating environment:Microsoft Visual Studio 2019

  对于此次的题目，首先让我疑惑的是ADT，在计算机工作中，有些数字是比较难以表示的。例如有理数（可以 a/b 格式表示的数，且 a 和 b 都是整数）本来是不能在电脑中表示出来。不过可以合理的抽象数据类型来定义，如下。构造：使用两个整数 a 与 b 创建实体，其中 a 为分子，b 为分母。运算：加法、减法、乘法、除法、乘幕、比较、约分，转成实数（浮点数）。要完成整个规格，就要根据数据来定义所有的运算。例如，当两个有理数 a/b 和 c/d 相乘时，相乘的结果就要定义为 ( a c ) / ( b d )。还有输入、输出、先决条件、后置条件，以及对抽象数据类型的各种假定。
  抽象数据类型（ADT）是纯粹理论实体，用于简化描述抽象算法，分类与评价数据结构，形式描述程序设计语言的类型系统。一个ADT可以用特定数据类型或数据结构实现，在许多程序设计语言中有许多种实现方式；或者用形式规范语言描述。ADT常实现为模块（module）：模块的接口声明了对应于ADT操作的例程（procedure），有时用注释描述了约束。[来自维基百科]
  看过题目后，对于C++熟悉的同学很容易能想到其中的complex库。为了日后的学习，现整理汇总如下的功能：

#include <complex> //complex头文件引用
  std::complex<double> c{3,4}//表示3+4i,所以得知,complex<类型> 变量名(实部，虚部)
  std::complex<double> c1,a;//初始化
  d = real(a);// 返回复数a的实部，当然也可以写成a.real()下面不再赘述
  a.real();
  d = imag(a);// 返回复数a的虚部
  d = abs(a);// 返回复数a的模值/幅值
  d = norm(a);// 返回复数a的模值平方
  d = arg(a);// 返回复数a的幅角
  z = conj(a);// 返回复数a的共轭复数
  c*c1,c/c1...;//符号运算

  所以可见，使用complex头文件是比较方便的，但是我们也需要理解其中的意义。于是，使用C++面向对象的特性进行简易的复数运算，仅包含上述题目所要求的。（以下环境均为VS2019 enterprise版）
  “Complex.h”

#pragma once
#ifndef COMPLEX_H
#define  COMPLEX_H

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

class Complex {
private:
    float Real, Imag;
public:
    Complex(float r = 0, float i = 0) {
        Real = r;
        Imag = i;
    }
    //显示输出复数
    void show() {
        cout << Real << "+" << Imag << "i";
    }
    Complex operator +(Complex& c);//"+"运算符重载完成复数间的加法运算
    Complex operator +(float s);//"+"完成实部与实数的加法运算
    Complex operator -(Complex& c);
    Complex operator -(float s);
    Complex operator *(Complex& c);
    Complex operator *(float s);
    Complex operator /(Complex& c);
    Complex operator / (float s);
    Complex conj(void);
    float  modu(void);

};

#endif

  对于头文件，建立Complex类模板，同时数据类型为float，私有数据为实部与虚部，在公有操作中，进行了方法（成员函数）的编写，例如show,modu等，同时使用C++特性运算符重载（自定义运算），进行加减乘除的运算。
  方法实现"Complex.cpp"

#include "Complex.h"

Complex Complex::operator +(Complex& c) {
    Complex t;
    t.Real = Real + c.Real;//以下均省略this->Real
    t.Imag = Imag + c.Imag;
    return t;
}

Complex Complex::operator +(float s) {
    Complex t;
    t.Real = Real + s;
    t.Imag = Imag;
    return t;
}

Complex Complex::operator-(Complex& c) {
    Complex t;
    t.Real = Real - c.Real;
    t.Imag = Imag - c.Imag;
    return t;
}

Complex Complex::operator-(float s) {
    Complex t;
    t.Real = Real + s;
    t.Imag = Imag - s;
    return t;
}

Complex Complex::operator *(Complex& c) {
    Complex t;
    t.Real = Real * c.Real - Imag * c.Imag;
    t.Imag = Real * c.Imag + Imag * c.Real;
    return t;
}

Complex Complex::operator *(float s) {
    Complex t;
    t.Real = Real * s;
    t.Imag = Imag * s;
    return t;
}

Complex Complex::operator /(Complex& c) {
    Complex t;
    if (c.Real != 0 && c.Imag != 0) {
        t.Real = (Real * c.Real + Imag * c.Imag) / (c.Real * c.Real + c.Imag * c.Imag); //实部除积
        t.Imag = (Imag * c.Real - Real * c.Imag) / (c.Real * c.Real + c.Imag * c.Imag); //虚部除积
        return t;
    }
    else {
        cout << "分母为0，不能执行命令";
        return -1;
    }
}

Complex Complex::operator /(float s) {
    Complex t;
    if (s != 0.0) {
        t.Real = Real / s;
        t.Imag = Imag / s;
        return t;
    }
    else {
        cout << "分母为0，不能执行命令";
        return -1;
    }
}

Complex Complex::conj(void) {
    Complex t;
    t.Real = Real;
    t.Imag = -Imag;
    return t;
}

float  Complex::modu(void) {
    return sqrt(Real * Real + Imag * Imag);
}

  测试文件"Main.cpp"

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

using namespace std;

int main() {
    float a, b, c, d;
    cout << "请输入第一个复数的实部与虚部:";
    cin >> a >> b;
    cout << "请输入第二个复数的实部与虚部:";
    cin >> c >> d;
    Complex A(a, b), B(c, d), C, D, E, F, G, H;
    C = A + B, D = A - B, E = A * B, F = A / B, G = A.conj(), H = B.conj();
    cout << "加法:"; A.show(); cout << "+"; B.show(); cout << "="; C.show(); cout << endl;
    cout << "减法:"; A.show(); cout << "-"; B.show(); cout << "="; D.show(); cout << endl;
    cout << "乘法:("; A.show(); cout << ")*("; B.show(); cout << ")="; E.show(); cout << endl;
    cout << "除法:("; A.show(); cout << ")/("; B.show(); cout << ")="; F.show(); cout << endl;
    cout << "共轭复数:"; A.show(); cout << ":"; G.show(); cout << "  "; B.show(); cout << ":"; H.show(); cout << endl;
    cout << "复数的模:"; A.show(); cout << ":" << A.modu(); cout << "  "; B.show(); cout << ":" << B.modu() << endl;
    return 0;
}

  以上为C++的代码书写，采取了头文件测试文件等的运用，也比较直观，同时也起到了函数功能封装的作用。以上附完整代码（Main.cpp）

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

class Complex{
    private:
       float Real,Imag;
    public:
        Complex(float r=0,float i=0){
            Real=r;
            Imag=i;
        }
        //显示输出复数
        void show(){
            cout<<Real<<"+"<<Imag<<"i";
        }    
        Complex operator +(Complex &c);//"+"运算符重载完成复数间的加法运算
        Complex operator +(float s);//"+"完成实部与实数的加法运算
        Complex operator -(Complex &c);
        Complex operator -(float s);
        Complex operator *(Complex &c);
        Complex operator *(float s);
        Complex operator /(Complex &c);
        Complex operator / (float s);
        Complex conj(void);
        float  modu(void);
        
};

Complex Complex::operator +(Complex &c){
    Complex t;
    t.Real=Real+c.Real;
    t.Imag=Imag+c.Imag;
    return t;
}

Complex Complex::operator +(float s){
    Complex t;
    t.Real=Real+s;
    t.Imag=Imag;
    return t;
}

Complex Complex::operator-(Complex &c){
    Complex t;
    t.Real=Real-c.Real;
    t.Imag=Imag-c.Imag;
    return t;
}

Complex Complex::operator-(float s){
    Complex t;
    t.Real=Real+s;
    t.Imag=Imag-s;
    return t;
}

Complex Complex::operator *(Complex &c){
    Complex t;
    t.Real=Real*c.Real-Imag*c.Imag;
    t.Imag=Real*c.Imag+Imag*c.Real;
    return t;
}

Complex Complex::operator *(float s){
    Complex t;
    t.Real=Real*s;
    t.Imag=Imag*s;
    return t;
}

Complex Complex::operator /(Complex &c){
    Complex t;
    if(c.Real!=0&&c.Imag!=0){
        t.Real=(Real*c.Real+Imag*c.Imag)/(c.Real*c.Real+c.Imag*c.Imag); //实部除积
        t.Imag=(Imag*c.Real-Real*c.Imag)/(c.Real*c.Real+c.Imag*c.Imag); //虚部除积
        return t;
    }
    else{
        cout<<"分母为0，不能执行命令";
        return -1;
    }
}

Complex Complex::operator /(float s){
    Complex t;
    if(s!=0.0){
        t.Real=Real/s;
        t.Imag=Imag/s;
        return t;
    }
    else{
        cout<<"分母为0，不能执行命令";
        return -1;
    }
}

Complex Complex::conj(void){
    Complex t;
    t.Real=Real;
    t.Imag=-Imag;
    return t;
}

float  Complex::modu(void){
    return sqrt(Real*Real+Imag*Imag);
}

int main(){
    float a,b,c,d;
    cout<<"请输入第一个复数的实部与虚部:";
    cin>>a>>b;
    cout<<"请输入第二个复数的实部与虚部:";
    cin>>c>>d;
    Complex A(a,b),B(c,d),C,D,E,F,G,H;
    C=A+B,D=A-B,E=A*B,F=A/B,G=A.conj(),H=B.conj();
    cout<<"加法:";A.show();cout<<"+";B.show();C.show();cout<<endl;
    cout<<"减法:";A.show();cout<<"-";B.show();D.show();cout<<endl;
    cout<<"乘法:";A.show();cout<<"*";B.show();E.show();cout<<endl;
    cout<<"除法:";A.show();cout<<"/";B.show();F.show();cout<<endl;
    cout<<"共轭复数:";A.show();cout<<":";G.show();cout<<"  ";B.show();cout<<":";H.show();cout<<endl;
    cout<<"复数的模:";A.show();cout<<":"<<A.modu();cout<<"  ";B.show();cout<<":"<<B.modu()<<endl;
    return 0;
}

题目描述
复数类的声明如下：

要求如下：

1. 实现复数类和友元函数addCom和outCom。

2. 参考addCom函数为复数类增加一个友元函数minusCom，用于实现两个复数的减法

3. 在main函数中，通过友元函数，实现复数的加减法和复数的输出。

输入
第1行：第1个复数的实部和虚部

第2行：需进行运算的次数，注意：是连续运算。具体结果可参考样例

第3行开始，每行输入运算类型，以及参与运算的复数的实部与虚部。“+”表示复数相加，“-”表示复数相减。

输出
每行输出复数运算后的结果，复数输出格式为“(实部,虚部)”。

#include<iostream>
using namespace std;
class complex{
	private:
		double real;	//实部 
		double imag;	//虚部 
	public:
		complex(){}
		complex(double r,double i){
			real=r;
			imag=i;
		}
		friend complex addCom(complex& c1,complex& c2);
		friend complex minusCom(complex &c1,complex& c2);
		friend void outCom(complex c);
};

complex addCom(complex &c1,complex &c2){
	complex temp;
	temp.real=c1.real+c2.real;
	temp.imag=c1.imag+c2.imag;
	return temp;
}
complex minusCom(complex &c1,complex &c2){
	complex temp;
	temp.real=c1.real-c2.real;
	temp.imag=c1.imag-c2.imag;
	return temp;
}
void outCom(complex c){
	cout<<"("<<c.real<<","<<c.imag<<")"<<endl;
} 
int main(){
	int r,i,t;
	char a;
	cin>>r>>i;
	complex c1(r,i);
	cin>>t;
	while(t--){
		cin>>a>>r>>i;
		complex c2(r,i);
		if(a=='+'){
			c1=	addCom(c1,c2);
			outCom(c1);
		}
		if(a=='-'){
			c1=minusCom(c1,c2);
			outCom(c1);
		}
	}
}

    在C++中复数运算可以通过两种方式来实现：

    1）标准C++复数运算库：complex<typedef> ObjectName(realPart, imagePart);

    2）自定义复数运算类：包括复数的实部、虚部、四则运算、模运算、共轭等。

    后者可以根据需要自己定义，关于类的定义这里不再说明，具体的功能可以根据自己的需要去实现。这里介绍C++标准的复数运算类complex，网上已经有一些关于complex类的简单介绍，但大多都是比较粗略的说明，并没有提供完整而详细的介绍。这里参考了网上的一些资源，首先介绍complex类的定义，包括：对象的构造方法、算术运算、赋值运算符、指数运算、对数运算、幂运算、三角函数运算、输入输出重载等，然后给出了一个使用例程，用于对其使用方法的总结用户总结。

一、complex类简介

    C++复数运算由标准C++复数运算库(complex number mathematics library)来实现。complex类定义了标准的输入输出运算、算是运算、关系运算和赋值运算，同时还包括指数运算、对数运算、幂运算、平方根、三角函数(正弦，余弦，双曲正弦，双曲余弦)等，还包括笛卡尔坐标系到极坐标系转换的函数。

二、文件包含

1、 #include <complex.h>

2、 #include <math.h>

三、构造方法

1、complex为模板类，因此在定义一个复数时需要制定变量类型，如complex<double> cm(1,1);

2、定义时实部和虚部参数可以使用变量，如：

double a = 1;
double b = 1;
complex<double> cm(a, b);

3、以下定义均合法：

    a) complex(): complex<double> c1;// c1 = (0,0);

    b) complex(double real, double<double> imag = 0.0): complex c2(1.0);// c2 = (1.0,0);

    c) complex<double> c3 = 3.4; // c3 = (3.4,0);

    d) complex c4 = 3.4 + complex(1.2, 3.5);

四、笛卡尔坐标系和极坐标系下有关函数

1、real();: friend double real(complex a);

2、 img();: friend double imag(complex a);

3、 abs();: friend double abs(complex a);

4、 norm();: friend double norm(complex a);

5、 arg();: friend double arg(complex a);

6、 conj();: friend complex conj(complex a);

7、 polar();: friend complex polar(double r,double t);

示例：

d = real(a);// 返回复数a的实部
d = imag(a);// 返回复数a的虚部
d = abs(a);// 返回复数a的模值/幅值
d = norm(a);// 返回复数a的模值平方
d = arg(a);// 返回复数a的幅角
z = conj(a);// 返回复数a的共轭复数
z = polar(r,t);// 复数的极坐标定义方式，r为幅值，t为幅角

五、指数、对数、幂、平方根运算函数

1、 exp(); friend complex exp(complex a);

2、 log(); friend complex log(complex a);

3、 pow(); 四种

        a) friend complex pow(double a, complex b);

        b) friend complex pow(complex a, int b);

        c) friend complex pow(complex a, double b);

        d) friend complex pow(complex a,complex b);

4、 sqrt();friend complex sqrt(complex a);

六、三角关系运算函数

1、 sin(); friend complex sin(complex a);

2、 cos(); friend complex cos(complex a);

3、 sinh(); friend complex sinh(complex a);

4、 cosh(); friend complex cosh(complex a);

七、运算符重载

    运算符重载包括：+、-、*、/（包括+=、-=、*=、/=）、==、!=、<<、>>

八、使用例程

1、开发环境：Win7 (X64) / VS2010

2、创建新项目，编写代码如下：

#include <iostream>
#include <complex>
#include <math.h>

using namespace std;

void main()
{
	// 复数类对象定义
	cout << "复数类对象定义" << endl;
	double r = 1.0;
	double x = 1.0;
	complex<double> c1;
	complex<double> c2(1,1);
	complex<double> c3(r,x);
	complex<double> c4 = 2.0;
	complex<double> c5 = c4 + complex<double>(2,1);

	cout << "c1 = " << c1 << endl;
	cout << "c2 = " << c2 << endl;
	cout << "c3 = " << c3 << endl;
	cout << "c4 = " << c4 << endl;
	cout << "c5 = " << c5 << endl << endl;

	// 笛卡尔坐标系和极坐标系下有关函数
	cout << "笛卡尔坐标系和极坐标系下有关函数" << endl;
	cout << "c5实部real：" << c5.real() << endl;
	cout << "c5虚部imag：" << c5.imag() << endl;
	cout << "c5模值abs：" << abs(c5) << endl;
	cout << "c5模值平方norm：" << norm(c5) << endl;
	cout << "c5幅角arg：" << arg(c5) << endl;
	cout << "c5共轭复数conj：" << conj(c5) << endl;
	complex<double> z = polar(1.0, 3.14/6);
	cout << "复数极坐标定义polar：" << z << endl << endl;

	// 运算符重载，四则运算
	cout << "运算符重载，四则运算" << endl;
	cout << "c2 + c5 = " << c2 + c5 << endl;
	cout << "c2 - c5 = " << c2 - c5 << endl;
	cout << "c2 * c5 = " << c2 * c5 << endl;
	cout << "c2 / c5 = " << c2 / c5 << endl << endl;

	system("pause");
}

3、运行结果如图1所示：

图1

参考：

1）http://blog.chinaunix.net/uid-20559667-id-1924707.html

2）http://blog.csdn.net/qhs1573/article/details/12254205