一个数学中常用到的复数类的实现

一个数学上用到的复数类的实现

 

Complex类是我写的一个复数类，实现了基本的复数四则运算如+，-，*，/， 并重载了流输入，流输出运算符， 等于不等于比较运算符等。

 

复数的格式是realPart + imaginaryPart * i， 其中i是-1的平方根。 这里我先来温故而知新一下复数的运算法则：

 

加法：若复数A = a + bi,  B= c + di;  那么 A + B = (a + c) + (b + d)i;

减法：若复数A = a + bi,  B= c + di;  那么 A - B = (a - c) + (b - d)i;

 

对于乘法和除法：

 

好了，不再啰嗦了，下面来看程序代码：

Complex类头文件Complex.h：

1. //========================================================================
2. //       一个复数类，实现了基本的复数四则运算如+,-,*,/重载了流输入输出运算符等
3. //                        复数的格式是realPart + imaginaryPart * i
4. //     其中i是-1的平方根， By 一剑 Loomman, QQ:28077188, QQ裙：30515563 ☆程序天堂☆ 
5. //========================================================================
6. #ifndef COMPLEX_H
7. #define COMPLEX_H
9. #include <iostream>
10. using namespace std;
12. class Complex
13. {
14. friend ostream &operator<<(ostream &, const Complex &);
15. friend istream &operator>>(istream &, Complex &);
17. public:
18.     Complex(double=0.0, double=0.0);                    //构造函数
19.     Complex operator+(const Complex &) const;           //加
20.     Complex operator-(const Complex &) const;           //减
21.     Complex operator*(const Complex &) const;           //乘
22.     Complex operator/(const Complex &) const;           //除
23.     Complex &operator=(const Complex &);                //赋值
24.     bool operator==(const Complex &);                   //比较 等于==
25.     bool operator!=(const Complex &);                   //比较 不等于!=
26.     void Print() const;                                 //输出
28. private:
29.     double  real;                                       //实部
30.     double  imaginary;                                  //虚部
31. };
33. #endif //COMPLEX_H

Complex类实现文件Complex.cpp：

1. //========================================================================
2. //       一个复数类，实现了基本的复数四则运算如+,-,*,/重载了流输入输出运算符等
3. //                        复数的格式是realPart + imaginaryPart * i
4. //     其中i是-1的平方根， By 一剑 Loomman, QQ:28077188, QQ裙：30515563 ☆程序天堂☆ 
5. //========================================================================
6. #include "complex.h"
8. Complex::Complex(double r, double i)
9. {
10.     real = r;
11.     imaginary = i;
12. }
14. Complex Complex::operator +(const Complex & cplx) const
15. {
16.     Complex sum;
17.     sum.real = real + cplx.real;
18.     sum.imaginary = imaginary + cplx.imaginary;
19.     return sum;
20. }
22. Complex Complex::operator -(const Complex & cplx) const
23. {
24.     Complex diff;
25.     diff.real = real - cplx.real;
26.     diff.imaginary = imaginary - cplx.imaginary;
27.     return diff;
28. }
30. Complex Complex::operator*(const Complex & cplx) const
31. {
32.     Complex muti;
33.     muti.real = real * cplx.real - imaginary * cplx.imaginary;
34.     muti.imaginary = imaginary * cplx.real + real * cplx.imaginary;
35.     return muti;
36. }
38. Complex Complex::operator/(const Complex & cplx) const
39. {
40.     Complex div;
41.     div.real = (real * cplx.real + imaginary * cplx.imaginary) / (cplx.real * cplx.real + cplx.imaginary * cplx.imaginary);
42.     div.imaginary = (imaginary * cplx.real - real * cplx.imaginary) / (cplx.real * cplx.real + cplx.imaginary * cplx.imaginary);
43.     return div;
44. }
46. Complex & Complex::operator =(const Complex & right)
47. {
48.     real = right.real;
49.     imaginary = right.imaginary;
50.     return *this;
51. }
53. bool Complex::operator==(const Complex & right)
54. {
55.     return (real==right.real && imaginary==right.imaginary);
56. }
58. bool Complex::operator!=(const Complex & right)
59. {
60.     return !(real==right.real && imaginary==right.imaginary);
61. }
63. ostream &operator<<(ostream & output, const Complex & cplx)
64. {
65.     output<<'('<<cplx.real<<", "<<cplx.imaginary<<')';
66.     return output;
67. }
69. istream &operator>>(istream & input, Complex & cplx)
70. {
71.     input.ignore();         //跳过'('
72.     input>>cplx.real;       //输入实部
73.     input.ignore(2);        //跳过','和空格
74.     input>>cplx.imaginary;  //输入虚部
75.     input.ignore();         //跳过')'
76.     return input;
77. }
79. void Complex::Print() const
80. {
81.     cout<<'('<<real<<", "<<imaginary<<')';
82. }

Complex类使用演示程序Main.cpp：

1. #include <iostream>
2. #include "complex.h"
3. using namespace std;
5. int main()
6. {
7.     Complex x, y(4.3, 8.2), z(3.3, 1.1);
8.     cout<<"x:"<<x<<endl;
9.     cout<<"y:"<<y<<endl;
10.     cout<<"z:"<<z<<endl;
12.     x = y+z;
13.     cout<<endl<<"x=y+z:"<<endl;
14.     cout<<x<<"="<<y<<"+"<<z<<endl;
16.     x=y-z;
17.     cout<<endl<<"x=y-z:"<<endl;
18.     cout<<x<<"="<<y<<"-"<<z<<endl;
20.     x=y*z;
21.     cout<<endl<<"x=y*z:"<<endl;
22.     cout<<x<<"="<<y<<"*"<<z<<endl;
24.     x=y/z;
25.     cout<<endl<<"x=y/z:"<<endl;
26.     cout<<x<<"="<<y<<"/"<<z<<endl;
28.     cout<<endl<<"cin>>x:";
29.     cin>>x;
30.     cout<<"     x:"<<x<<endl;
32.     int a;
33.     cin>>a;
34.     return a;
35. }

演示程序运行结果如下：

x:(0, 0)
y:(4.3, 8.2)
z:(3.3, 1.1)

 

x=y+z:
(7.6, 9.3)=(4.3, 8.2)+(3.3, 1.1)

 

x=y-z:
(1, 7.1)=(4.3, 8.2)-(3.3, 1.1)

 

x=y*z:
(5.17, 31.79)=(4.3, 8.2)*(3.3, 1.1)

 

x=y/z:
(1.91818, 1.84545)=(4.3, 8.2)/(3.3, 1.1)

 

cin>>x:(1.2345, 2.2345)
         x:(1.2345, 2.2345)

 

by Loomman, QQ:28077188, MSN: Loomman@hotmail.com QQ裙：30515563 ☆程序天堂☆ 请尊重作者原创，转载注明来自裂帛一剑博客，谢谢合作。