[VC++原创]一个基于MFC(Visual C++)的复数计算器

相似文件 换一批

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

用MFC制作了一个复数计算器

    CComplex类

1. //  复数的头文件
   
2. 
   
3. 
   
4. #ifndef _COMPLEX_H_
   
5. #define _COMPLEX_H_
   
6. 
   
7. 
   
8. #if _MSC_VER>1000
   
9. #pragma once
   
10. #endif
    
11. 
    
12. //  定义一个复数的类
    
13. class CComplex
    
14. {
    
15. protected:
    
16. 
    
17.         double m_dblX;
    
18.         double m_dblY;
    
19. 
    
20.         //  公共的接口函数
    
21. public:
    
22.         //  无参数构造函数
    
23.         CComplex();
    
24. 
    
25. 
    
26.         //  两个参数的构造函数
    
27.         CComplex(double dblX , double dblY);
    
28. 
    
29.         //  复制构造函数
    
30.         CComplex(const CComplex &other);
    
31. 
    
32.         //  析构函数
    
33.         virtual ~CComplex(){};
    
34. 
    
35.         //  输入与显示
    
36.         void SetReal(double dblX);
    
37.         void SetImag(double dblY);
    
38.         double GetReal();
    
39.         double GetImag();
    
40. 
    
41.         //  将字符串转换为复数
    
42.         CString ToString() const;
    
43.         void FromString(CString s , const CString& sDelim = _T(" "));
    
44. 
    
45.         //  各类的数学运算
    
46.         BOOL operator==(const CComplex& cpxX) const;
    
47.         BOOL operator!=(const CComplex& cpxX) const;
    
48.         CComplex& operator=(const CComplex& cpxX);
    
49.         //  复数的模
    
50.         double Abs() const;
    
51.         CComplex operator+(const CComplex& cpxX) const;
    
52.         CComplex operator-(const CComplex& cpxX) const;
    
53.         CComplex operator*(const CComplex& cpxX) const;
    
54.         CComplex operator/(const CComplex& cpxX) const;
    
55. 
    
56.         //  以下是一些函数的运算
    
57.         //  n可能是CComplex的向量个数
    
58.         void Root(CComplex cpxR[]) const;
    
59.         //  实幂指数
    
60.         CComplex Pow(double) const;
    
61.         //  复幂指数
    
62.         CComplex Pow(CComplex,int) const;
    
63.         CComplex Log() const;
    
64.         CComplex Sin() const;
    
65.         CComplex Cos() const;
    
66.         CComplex Tan() const;
    
67. 
    
68. };
    
69. 
    
70. #endif

复制代码

构造、析构、算法等函数：

1. #include "stdafx.h"
   
2. //  所有的文件都需要在"Complex.h"之前
   
3. #include "Complex.h"
   
4. #include <cmath>
   
5. 
   
6. //  为了在debug中检查内存是否泄露
   
7. #ifdef _DEBUG
   
8. #undef THIS_FILE
   
9. static char THIS_FILE[]=__FILE__;
   
10. #define new DEBUG_NEW
    
11. #endif
    
12. 
    
13. #define PI 3.141592653
    
14. 
    
15. //  下面定义相应的函数
    
16. CComplex::CComplex()
    
17. {
    
18.         m_dblX = 0.0;
    
19.         m_dblY = 0.0;
    
20. }
    
21. 
    
22. CComplex::CComplex(double dblX , double dblY)
    
23. {
    
24.         m_dblX = dblX;
    
25.         m_dblY = dblY;
    
26. }
    
27. 
    
28. //  拷贝构造函数
    
29. CComplex::CComplex(const CComplex& other)
    
30. {
    
31.         m_dblX = other.m_dblX;
    
32.         m_dblY = other.m_dblY;
    
33. }
    
34. 
    
35. //  输入和显示
    
36. void CComplex::SetReal(double a)
    
37. {
    
38.         m_dblX = a;
    
39. }
    
40. 
    
41. void CComplex::SetImag(double b)
    
42. {
    
43.         m_dblY = b;
    
44. }
    
45. 
    
46. double CComplex::GetReal()
    
47. {
    
48.         return m_dblX;
    
49. }
    
50. 
    
51. double CComplex::GetImag()
    
52. {
    
53.         return m_dblY;
    
54. }
    
55. 
    
56. //  字符串的转换函数
    
57. CString CComplex::ToString() const
    
58. {
    
59.         CString s;
    
60. 
    
61.         if(fabs(m_dblX)>1e-10)
    
62.         {
    
63.                 if(m_dblY>0.0)
    
64.                 {
    
65.                         s.Format(_T("%.3f + %.3fj"),m_dblX,m_dblY);
    
66.                 } else if (m_dblY<0.0)
    
67.                 {
    
68.                         s.Format(_T("%.3f - %.3fj"),m_dblX,fabs(m_dblY));
    
69.                 } else
    
70.                 {
    
71.                         s.Format(_T("%.3f"),m_dblX);
    
72.                 }
    
73.         } else
    
74.                 //  判断小于0的情况
    
75.         {
    
76.                 if(m_dblY>0.0)
    
77.                 {
    
78.                         s.Format(_T("%.3fj"),m_dblY);
    
79.                 } else if (m_dblY<0.0)
    
80.                 {
    
81.                         s.Format(_T("-%.3f"),fabs(m_dblY));
    
82.                 } else
    
83.                 {
    
84.                         s.Format(_T("%.3fj"),m_dblX);
    
85.                 }
    
86.         }
    
87. 
    
88.         return s;
    
89. }
    
90. 
    
91. void CComplex::FromString(CString s , const CString& sDelim)
    
92. {
    
93.         int nPos = s.Find(sDelim);
    
94. 
    
95.         if (nPos == -1)
    
96.         {
    
97.                 s.TrimLeft();
    
98.                 s.TrimRight();
    
99.                 m_dblX = _wtof(s);
    
100.                 m_dblY = 0;
     
101.         } else
     
102.         {
     
103.                 int len = s.GetLength();
     
104.                 CString sLeft = s.Left(len);
     
105.                 CString sRight = s.Right(nPos - len - 1);
     
106. 
     
107.                 sLeft.TrimLeft();
     
108.                 sRight.TrimRight();
     
109. 
     
110.                 m_dblX = _wtof(sLeft);
     
111.                 m_dblY = _wtof(sRight);
     
112.         }
     
113. 
     
114. }
     
115. 
     
116. //  相应的重载运算符
     
117. BOOL CComplex::operator==(const CComplex& cpxX) const
     
118. {
     
119.         return(m_dblX == cpxX.m_dblX && m_dblY == cpxX.m_dblY);
     
120. }
     
121. 
     
122. BOOL CComplex::operator!=(const CComplex& cpxX) const
     
123. {
     
124.         return(m_dblX != cpxX.m_dblX || m_dblY != cpxX.m_dblY);
     
125. }
     
126. 
     
127. CComplex& CComplex::operator=(const CComplex& cpxX)
     
128. {
     
129.         m_dblX = cpxX.m_dblX;
     
130.         m_dblY = cpxX.m_dblY;
     
131.         return *this;
     
132. }
     
133. 
     
134. CComplex CComplex::operator+(const CComplex& cpxX) const
     
135. {
     
136.         double x = m_dblX + cpxX.m_dblX;
     
137.         double y = m_dblY + cpxX.m_dblY;
     
138. 
     
139.         return CComplex(x,y);
     
140. }
     
141. 
     
142. CComplex CComplex::operator-(const CComplex& cpxX) const
     
143. {
     
144.         double x = m_dblX - cpxX.m_dblX;
     
145.         double y = m_dblY - cpxX.m_dblY;
     
146. 
     
147.         return CComplex(x,y);
     
148. }
     
149. 
     
150. //  乘法
     
151. CComplex CComplex::operator*(const CComplex& cpxX) const
     
152. {
     
153.         double a = m_dblX;
     
154.         double b = m_dblY;
     
155.         double c = cpxX.m_dblX;
     
156.         double d = cpxX.m_dblY;
     
157. 
     
158.         return(CComplex(a*c - b*d,a*d+b*c));
     
159. }
     
160. 
     
161. //  除法
     
162. CComplex CComplex::operator/(const CComplex& cpxX) const
     
163. {
     
164.         double a = m_dblX;
     
165.         double b = m_dblY;
     
166.         double c = cpxX.m_dblX;
     
167.         double d = cpxX.m_dblY;
     
168. 
     
169.         double x,y;
     
170.         x = (a*c + b*d)/(pow(c,2)+pow(d,2));
     
171.         y = (b*c - a*d)/(pow(c,2)+pow(d,2));
     
172. 
     
173.         return CComplex(x,y);
     
174. 
     
175. }
     
176. 
     
177. //  复数的模
     
178. double CComplex::Abs() const
     
179. {
     
180.         double a,b,c;
     
181.         a = pow(m_dblX,2);
     
182.         b = pow(m_dblY,2);
     
183.         c = sqrt(a+b);
     
184. 
     
185.         return c;
     
186. }
     
187. 
     
188. //  复数的根
     
189. void CComplex::Root(CComplex cpxR[]) const
     
190. {
     
191. 
     
192.         double q = atan2(m_dblX , m_dblY);
     
193.         double r = sqrt(pow(m_dblX,2) + pow(m_dblY,2));
     
194. 
     
195.         r = pow(r,0.5);
     
196.         double t = 0.0;
     
197. 
     
198.         for(int k = 0;k<2;k++)
     
199.         {
     
200.                 t = (2.0*k*PI + q)/2;
     
201.                 cpxR[k].m_dblX = r*cos(t);
     
202.                 cpxR[k].m_dblY = r*sin(t);
     
203.         }
     
204. 
     
205. }
     
206. 
     
207. //  实幂指数
     
208. CComplex CComplex::Pow(double dblW) const
     
209. {
     
210.         // 局部变量
     
211.         double r, t;
     
212.    
     
213.     // 特殊值处理
     
214.     if ((m_dblX == 0) && (m_dblY == 0))
     
215.                 return CComplex(0, 0);
     
216.    
     
217.     // 幂运算公式中的三角函数运算
     
218.     if (m_dblX == 0)
     
219.         {
     
220.         if (m_dblY > 0)
     
221.             t = 1.5707963268;
     
222.         else
     
223.             t = -1.5707963268;
     
224.         }
     
225.     else
     
226.         {
     
227.         if (m_dblX > 0)
     
228.             t = atan2(m_dblY, m_dblX);
     
229.         else
     
230.         {
     
231.                         if (m_dblY >= 0)
     
232.                 t = atan2(m_dblY, m_dblX) + PI;
     
233.             else
     
234.                 t = atan2(m_dblY, m_dblX) - PI;
     
235.                 }
     
236.     }
     
237.    
     
238.     // 模的幂
     
239.     r = exp(dblW * log(sqrt(m_dblX * m_dblX + m_dblY * m_dblY)));
     
240.    
     
241.     // 复数的实幂指数
     
242.     return CComplex(r * cos(dblW * t), r * sin(dblW * t));
     
243. }
     
244. 
     
245. //  复幂指数
     
246. CComplex CComplex::Pow(CComplex cpxW,int n = 0) const
     
247. {
     
248.         // 局部变量
     
249.     double r, s, u, v;
     
250.    
     
251.     // 特殊值处理
     
252.     if (m_dblX == 0)
     
253.         {
     
254.         if (m_dblY == 0)
     
255.                         return CComplex(0, 0);
     
256.             
     
257.         s = 1.5707963268 * (fabs(m_dblY) / m_dblY + 4 * n);
     
258.         }
     
259.     else
     
260.         {
     
261.         s = 2 * PI * n + atan2(m_dblY, m_dblX);
     
262.         
     
263.         if (m_dblX < 0)
     
264.                 {
     
265.             if (m_dblY > 0)
     
266.                 s = s + PI;
     
267.             else
     
268.                 s = s - PI;
     
269.         }
     
270.     }
     
271.    
     
272.     // 求幂运算公式
     
273.     r = 0.5 * log(m_dblX * m_dblX + m_dblY * m_dblY);
     
274.     v = cpxW.m_dblX * r + cpxW.m_dblY * s;
     
275.     u = exp(cpxW.m_dblX * r - cpxW.m_dblY * s);
     
276. 
     
277.     return CComplex(u * cos(v), u * sin(v));
     
278. }
     
279. 
     
280. //  求对数
     
281. CComplex CComplex::Log() const
     
282. {
     
283.         double p = log(sqrt(pow(m_dblX,2.0) +pow(m_dblY,2.0)));
     
284.         return CComplex(p,atan2(m_dblY,m_dblX));
     
285. }
     
286. 
     
287. //  求解正弦
     
288. CComplex CComplex::Sin() const
     
289. {
     
290.     int i;
     
291.     double x, y, y1, br, b1, b2, c[6];
     
292.    
     
293.     // 切比雪夫公式的常数系数
     
294.     c[0] = 1.13031820798497;
     
295.     c[1] = 0.04433684984866;
     
296.     c[2] = 0.00054292631191;
     
297.     c[3] = 0.00000319843646;
     
298.     c[4] = 0.00000001103607;
     
299.     c[5] = 0.00000000002498;
     
300.    
     
301.     y1 = exp(m_dblY);
     
302.     x = 0.5 * (y1 + 1 / y1);
     
303.     if (fabs(m_dblY) >= 1)
     
304.         y = 0.5 * (y1 - 1 / y1);
     
305.     else
     
306.     {
     
307.                 b1 = 0;
     
308.         b2 = 0;
     
309.         y1 = 2 * (2 * m_dblY * m_dblY - 1);
     
310.         for (i = 5; i >=0; --i)
     
311.                 {
     
312.             br = y1 * b1 - b2 - c[i];
     
313.             if (i != 0)
     
314.                         {
     
315.                 b2 = b1;
     
316.                 b1 = br;
     
317.             }
     
318.         }
     
319.         
     
320.         y = m_dblY * (br - b1);
     
321.     }
     
322.    
     
323.     // 组合计算结果
     
324.     x = x * sin(m_dblX);
     
325.     y = y * cos(m_dblX);
     
326. 
     
327.         return CComplex(x, y);
     
328. }
     
329. 
     
330. //  计算余弦
     
331. CComplex CComplex::Cos() const
     
332. {
     
333.     int i;
     
334.     double x, y, y1, br, b1, b2, c[6];
     
335.    
     
336.     // 切比雪夫公式的常数系数
     
337.     c[0] = 1.13031820798497;
     
338.     c[1] = 0.04433684984866;
     
339.     c[2] = 0.00054292631191;
     
340.     c[3] = 0.00000319843646;
     
341.     c[4] = 0.00000001103607;
     
342.     c[5] = 0.00000000002498;
     
343.    
     
344.     y1 = exp(m_dblY);
     
345.     x = 0.5 * (y1 + 1 / y1);
     
346.     if (fabs(m_dblY) >= 1)
     
347.         y = 0.5 * (y1 - 1 / y1);
     
348.     else
     
349.     {
     
350.                 b1 = 0;
     
351.         b2 = 0;
     
352.         y1 = 2 * (2 * m_dblY * m_dblY - 1);
     
353.         for (i=5 ; i>=0; --i)
     
354.                 {
     
355.             br = y1 * b1 - b2 - c[i];
     
356.             if (i != 0)
     
357.             {
     
358.                                 b2 = b1;
     
359.                 b1 = br;
     
360.             }
     
361.         }
     
362.         
     
363.         y = m_dblY * (br - b1);
     
364.     }
     
365.    
     
366.     // 组合计算结果
     
367.     x = x * cos(m_dblX);
     
368.         y = -y * sin(m_dblX);
     
369. 
     
370.         return CComplex(x, y);
     
371. }
     
372. 
     
373. //  计算正切算法
     
374. CComplex CComplex::Tan() const
     
375. {
     
376.         //  类内调用
     
377.         return Sin()/Cos();
     
378. }

复制代码

    如图：

所有源码：

本帖隐藏的内容

ComplexCaculator.rar (1.94 MB)

2015-10-4 19:09:15 上传

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏1 回帖

关键词：Visual UAL MFC 计算器 operator 计算器

好厉害，棒棒哒~~~

发帖不易，用心良苦，感谢fantuanxiaot师兄，感谢分享。

MFC比C#有什么优势？

现在都是C#写的程序

现在Windows平台被C#垄断，Android平台被Java垄断，iOS平台被Swift垄断。至于C++估计只能回到DOS平台吧，俗称“躲死”，真是死无葬身之地啊，未来一定是属于Swift的。

Crsky7 发表于 2015-10-5 11:26
现在Windows平台被C#垄断，Android平台被Java垄断，iOS平台被Swift垄断。至于C++估计只能回到DOS平台吧，俗 ...

确实 C#比C++更方便  不受各类指针的困扰

Crsky7 发表于 2015-10-5 11:19
MFC比C#有什么优势？

mfc是c++做开发用的