Question

c++复数计算器

Answer 1

＃
/ /定义复杂的类======================================== ======================================

复杂

{

复杂（）{= 0; IMAG = 0;} / /默认构造函数

复杂（双R，双I）{= R皇家IMAG = I;

无效setComplex（双，双R，I）} / /构造;/ /复位复数

复杂的操作符+（复杂和C2）;/ /算术运算符+重载声明

复杂的运算符 - （建筑及C2）;/ /运营商 - 重载声明

复杂的操作符*（复杂和C2）;/ /运算符重载的语句

复杂的操作员/（建筑及C2）;/ /运营商/

朋友的ostream＆操作符重载声明“（ostream的复杂的）;/ /重载流插入复杂的运算符<<输出

朋友istream的＆操作符>>（istream的复杂）; /重装多个输入流提取运算符>>

，无效complexAdd（）

无效complexSubtract（朋友们无效的complexCompare（）;

无效complexMultiply（）;

的无效complexDivide（）...... /“ ）;

朋友双MOD（常量复杂＆C）;/ /求长度的平方

私人如下：

双实;

双重成像; BR />};

/ / ======================================== ==================================

/ / ========== ======成员函数在类外定义====================================== ====

无效复杂:: setComplex（双R的双I）

{

雷亚尔= R; IMAG = I;

}

/ / - ---------------------------------------------

复杂复杂的::运算符+（复杂和C2）

{

复杂的C;

c.real =实际+ c2.real;

c.imag成像+ C2。成像

}

/ / ------------------------------- ---------------

纷繁复杂的::运算符（复杂性和C2）

{

复杂的C;的

c.real =实际c2.real;

c.imag =成像C2。成像

}

/ / ------------------------------- ---------------的的

复杂的复杂::运算符*（）/> {

复杂的C;

c.real建设和C2 =实际* IMAG为c2.real * c2.imag的;

c.imag = * C2影像。房地产+真正的c2.imag;

回报;

}

/ / -------------------------- --------------------

纷繁复杂的::运算符/（复杂和C2）

{

复杂的C BR /> c.real =（实际* c2.real +成像c2.imag）的/（c2.real c2.real + c2.imag c2.imag）;

c.imag =（IMAG * C2。一个真正的实时c2.imag）/（c2.real c2.real + c2.imag c2.imag）;

}

/ / --------- --------------------------------------

ostream的运营商<（ostream的输出，复合＆C）

{

（c.imag> = 0）

输出<<（“”c.real，“+”<<; c.imag“）

输出<<“（”“”c.real“”c.imag“”），“返回输出;

} BR /> / / --------------------------------------------- -----

istream的＆操作符>>（istream的输入，复合＆C）

{

法院<<“请输入的实部和虚部的复杂性，在中间以空格分隔的：“

输入>> c.real >> c.imag

返回输入;

}

> / / =============================================== ========================

/ / =================定义的函数功能（功能）============================

/ /复数加法

，空白complexAdd（） BR /> {

整数;

法院<<“请输入操作数（在另一个复杂的）数量（注操作数= 0）：”

CIN >>数字
a>

时间（数> 10 | | <0）/ /输入操作数<= 10

{

法院<<“您输入的数字大于10或小于0，请重新输入！“<< endl;

法院<<”请输入操作数（参与另一个复数）数量（注操作数= 0）：“

CIN >>中国; BR />}

（NUM == 0）法院<<“请不要输入任何复杂的\ n”;

{

复杂的（0.0 0.0）;

（INT I = 0; I <中国+ +）

{

复杂的C;

CIN> C;

总=总+ C;

}

法院<<“，”中国“，”积聚的一个复杂的“”总<< endl;

} }

/ /复杂的减法

无效complexSubtract（）

{

数量; BR /> cout <<“请输入操作数（涉及复杂的减法）（注操作数= 0）：”;

新霉素>>数量;

（10号> | | <0）/ /输入操作数<= 10

{

法院<<“您输入的数字大于10或小于0，请重新输入！”<< endl; BR />法院<<“请输入操作数（参与减法多元）（注操作数= 0）：

CIN >>中国;

}

（NUM == 0）cout <<“请，请不要输入任何复杂的\ n \ n \ n”;

{

复杂的共（0.0,0.0）;

CIN >>共有

（INT I = 2; <= NUM？？+ +）

{

复杂的C;

> CIN >> C;

总额=总胆固醇;

}

cout <<“请”，“人”，“返回的复杂性和复杂。”}

} BR p>

/ /乘法

的无效complexMultiply在（） {

号码;

法院<<数字输入操作（涉及的乘法元）（注操作数= 0）：“;

CIN >>中国;

10 | |计数<0）/ /输入操作数<= 10

{

法院<“你输入的数字大于10或小于0，请重新输入！ “”Endl;

法院<<“输入操作数（S）（注操作数= 0）：”;

新霉素>>数字的乘法数

}

（NUM == 0）法院<<“没有任何复杂的\ n \ n \ n”;

{BR />;复杂的共（1.0,0.0）; / /注意初始值

（i = 1; <= NUM？？+ +）

{

复杂的C; CIN >> C

合计= C;

}

cout <<“请”，“中国制造”的多个累乘法和“<<总计<endl;

}

}

/ /复杂的分工

的无效complexDivide（）BR /> {

整数;

法院<<“输入操作数（涉及复杂的分工）（注操作数= 0）：

CIN >>;

（NUM> 10 | |计数<0）/ /输入操作数<= 10 BR /> {

法院<<“您输入的号码是10或小于0的大，请重新输入！ “<< endl;

法院<<”输入操作数（参与分工劳动的复数）（注操作数= 0）：

CIN >>数字;

}

（NUM == 0）法院<<“输入复数\ n \ n \ n”;

{

总量的复杂;

CIN >>总;/ /参加第一师被分配了一个数字

（INT I = 2; <= NUM？，I + +）

{

复杂C;

CIN >> C;

（MOD（C））

BR /> {

法院<<“除数为零，输入错误，请重新输入\ n \ n已“;

CIN >> C;

}

合计= / C;

}

COUT <<”这“人”，“累了此外，在复杂的供应商。“总<< endl;

}

>

}

/ /在两个比较功能

的无效complexCompare（）/ /两个复杂的比较函数

{

复杂的C1，C2;

法院<<“请输入两个复数：\ n”;

CIN >> C1;

CIN >> C2;

（（c1.real == c2.real）&&（c1.imag == C2。IMAG））法院<<“两个复杂的平等\ n“;

其他（MOD（C1），的调制（C2））法院<< C1 <<”大于“”C2 << \ C2 <<模模模量;/ /比较模式下，模具

如果数（MOD（C1）<设定MOD（C2））法院<<<< C1 <<“\ n”;/ /比较模式，长

其他法院<< “两个复杂的模数等于\ n”; / /比较模式长期

}

/ /找到的长度函数的平方

双MOD（const的复杂＆C）

{

回报（c.real * C实时+ c.imag c.imag）;

}

/ /

解释的主要函数main（）

{

选择的解释;

法院<<“这是一个简单的复杂的操作计算机，进入功能选择：”< <endl;

法院“。退出。 2加法器，减法器的乘法。第5分部。复杂的尺寸（模数）\ n \ n“;

CIN >>选择;/ /输入功能选择

{

（选择== 0）{法院<<” \ n \ n欢迎下一次继续使用一个复杂的计算器！ \ n \ n“;打破;}

否则，如果（选择== 1）complexAdd（）;

否则，如果（选择== 2）complexSubtract（）;

否则，如果（选择=

如果= 3）complexMultiply（）（选择== 4）complexDivide（）;

（选择== 5）complexCompare（）;

其他法院;“\ n \ n输入错误，请重新输入！ \ n \ n“;

法院<<”\ n \ n \ n这是一个简单的复杂的操作计算机，进入功能选择：“<< endl << endl; <BR / cout <<“请为0。退出。 2加法器，减法器的乘法。第5分部。更复杂的尺寸（模数）\ n“;

CIN >>选择;/ /输入功能选择

}（choice! = 0）;

>

返回0;
}

Answer 2

＃
/ /定义复杂类================================= =============================================
类公共复杂
{
复杂（）{实际= 0; IMAG = 0;} / /默认构造函数
复杂（双R，双I）{雷亚尔= R; IMAG = I;
的无效setComplex（双，双R，I）} / /构造;/ /复位复数
复杂的操作符+（大楼及C2）;/ /运算符+重载声明
复杂的运营商 - （大楼及C2）;/ /运营商 - 重载声明
复杂的操作符*（复杂和C2）;/ /操作员重载声明
复杂的操作员/（大楼及C2）;/ /运营商/重载声明
朋友的ostream＆操作符<<（ostream的，复杂的）;/ /重载流插入运算符<<复杂的输出
朋友istream的＆操作符>>（istream的，复杂的）; /重载多个输入流提取运算符>>
无效complexAdd（）;
的无效complexSubtract的（）;
的无效complexMultiply的（）;
的无效complexDivide（）; ...... />的朋友无效complexCompare（）;
朋友双MOD（const的复杂＆C）;/ /求长度的平方
私人如下：
双实;
双成像; BR />};
/ / ======================================= ===================================
/ / ========= =======成员函数在类外定义===================================== =====
无效情结:: setComplex的（双R，双I）
{
雷亚尔= R; IMAG = I;
}
/ / - ---------------------------------------------
复杂复杂::运算符+（大楼及C2）
{
复杂的C;
c.real =实际+ c2.real;
c.imag成像+ c2.imag;
回报;
}
/ / -------------------------------- --------------
复杂复杂::运营商（复杂和C2）
{
复杂的C;
c.real =实际c2.real;
c.imag =成像c2.imag;
回报;
}
/ / ------------- ---------------------------------
复杂复杂::运算符*（大楼及C2） /> {
复杂的C;
c.real =实际* c2.real-IMAG * c2.imag;
c.imag =成像* C2。真正+真正c2.imag;
回报;
}
/ / ------------------------ ----------------------
复杂复杂::运算符/（大楼及C2）
{
复杂的C; BR /> c.real =（实际* c2.real +成像c2.imag）/（c2.real c2.real + c2.imag * c2.imag）;
c.imag =（IMAG * C2。真正的实时c2.imag）/（c2.real c2.real + c2.imag c2.imag）;
回报;
}
/ / --- --------------------------------------------
ostream的运营商<（ostream的输出，复合＆C）
{
（c.imag> = 0）
输出<<“（”<< c.real“;” +“<< c.imag”“）;
其他
输出<<”（“<< c.real <<”“<< c.imag”“）”
返回输出;
}
/ / ------------------------------- -------------------
istream的＆操作符>>（istream的输入，复合＆C）
{
法院<<“请输入复数的实部和虚部，中间用空格隔开：“
输入>> c.real >> c.imag
返回输入;
}

/ / =============================== ========================================
/ / ==== =============功能定义函数（Function）============================
> / /复数加法
的空白complexAdd（）
{
整型数;
法院<<“请输入操作数（参与在另外的复数）数量（注意操作数 = 0）：“;
CIN >>数;

一段时间（数> 10 | |数<0）/ /输入操作数<= 10
{
法院<<“你输入的数量大于10或小于0，请重新输入！”<< endl;
法院<<“请输入操作数（以参加在另外的复数）数量（注操作数 = 0）：“;
CIN >>民;
}

（NUM == 0 ）cout <<“请没有输入任何复杂的\ n”;
其他
{
复杂的共（0.0,0.0）;
（INT I = 0; I <民我+ +）
{
复杂的C;
CIN >> C;
总额=总+ C;
}
法院<<“” “民”，“一个复杂的积累”<<总<< endl;

}
}

/ /复杂的减法
的无效complexSubtract（）

{
数;
法院<<“请输入操作数（参与复杂的减法）号码（注操作数 = 0）：“;
霉素>>数量;

（数> 10 | |数<0）/ /输入操作数<= 10
{
法院<<“您输入的数字大于10或小于0，请重新输入！” << endl;
法院<<“请输入操作数（参与减法复数）（注操作数 = 0）：”
CIN >>民;
}

（NUM == 0）cout <<“请没有输入任何复杂的\ n \ n \ n”;
其他
{
复杂的共（ 0.0,0.0）;
CIN >>共有;
（INT I = 2; <= NUM??我+ +）
{
复杂的C;
> CIN >> C;
总额=总胆固醇;
}
法院<<“这个”“民”“复杂的回归和复杂的。”总< endl; BR />}

}

/ /乘法
的虚空complexMultiply（）
{
数;
法院<<数的输入操作（参与的乘法多元）（注操作数 = 0）：“;
CIN >>民;
10 | |数<0）/ /输入操作数<= 10
{
法院<<“你输入的数量是大于10或小于0，请重新输入！“<< endl;
法院<<”输入操作数（多个）参与（注操作数 = 0）：“;
霉素>>数的乘法的数量
}

（NUM == 0）法院<<“没有任何复杂的\ n \ n \ n”;
其他
{ BR />复杂总额（1.0,0.0）; / /注意这里的初始值
（i = 1; <= NUM??我+ +）
{
复杂的C ;
CIN >> C;
总额=总* C;
}
COUT <<“这个”“民”的复数累乘法和“<<总<endl;
}

}

/ /复杂的分工
的无效complexDivide（） BR /> {
整型数;
法院<<“输入操作数（参与复杂的分工）（注操作数 = 0）：”
CIN >>数;

（NUM> 10 | |数<0）/ /输入操作数<= 10
{
法院<<“您输入的号码是大于10或小于0，请重新输入！“<< endl;
法院<<”输入操作数（参与分工的复数）（注操作数 = 0）： “
CIN >>数;
}

（NUM == 0）法院<<”输入是复数\ n \ n \ n“;
>
其他
{
复杂的总量;
CIN >>共有;/ /参与分工的第一次分配一个编号的总
（INT I = 2; <= NUM??，我+ +）
{
复杂的C;
CIN >> C;
（MOD（C））
BR /> {
法院<<“除数为零，输入错误，请重新输入\ n \ n”;
CIN >> C;
}
总=总/ C;
}
法院<<“这”“民”“累，除了复数的供应商”<<总<< endl;
}
a>

}

/ /两个多比较功能
无效complexCompare（）/ /两个复杂的比较函数
> {
复杂的C1，C2;
法院<<“请输入两个复杂的：\ n”;
CIN >> C1;
CIN >> C2;
>（（c1.real == c2.real）&&（c1.imag == C2。IMAG））法院<<“两个复杂的平等\ n”;
其他的话（MOD（C1）调制（ c2）的）法院<< c1的<<“大于”<< c2的<<“\”;/ /比较模式的模具中的模量长
其他如果数（Mod（c1）的<设为Mod（C2） ）法院<< C2 <<模模数大于“<< C1 <<”\ n“;/ /比较模式下，长
其他cout <<”请两个复杂的模数等于\ n“; / /比较模式长
}

/ /找到的长度函数的平方
双MOD（const的复杂＆C）
{
回报（c.real * c.real + c.imag c.imag）;
}

/ /主要功能
诠释的main（）
> {
诠释的选择;
法院<<“这是一个简单的复数运算的计算器，进入功能选择：”<< endl;
法院“0。退出。 2加法器，减法乘法。第5分部。比较复杂的尺寸（模数）\ n \ n“;
CIN >>选择;/ /输入功能选择

{
（选择== 0）{ cout <<“请\ n \ n欢迎下次继续使用复数计算器！ \ n \ n“;打破;}
否则，如果（选择== 1）complexAdd（）;
否则，如果（选择== 2）complexSubtract（）;
否则，如果（选择=
如果= 3）complexMultiply（）（选择== 4）complexDivide（）;

其他（选择== 5）complexCompare（）;
其他法院<<“\ n \ n输入错误，请重新输入！ \ n \ n“;

法院<<”\ n \ n \ n这是一个简单的复数运算的计算器，进入功能选择：“<< endl << endl;
法院<<“0。退出1。 2加法器，减法乘法。第5分部。比较复杂的尺寸（模数）\ n“;
CIN >>选择;/ /输入功能选择
}（choice! = 0）;

>

返回0;
}

Answer 3

＃
/
/定义复杂类=================================
=============================================
类公共复杂
{
复杂（）{实际=
0;
IMAG
=
0;}
/
/默认构造函数
复杂（双R，双I）{雷亚尔=
R;
IMAG
=
I;
的无效setComplex（双，双R，I）}
/
/构造;/
/复位复数
复杂的操作符+（大楼及C2）;/
/运算符+重载声明
复杂的运营商
-
（大楼及C2）;/
/运营商
-
重载声明
复杂的操作符*（复杂和C2）;/
/操作员重载声明
复杂的操作员/（大楼及C2）;/
/运营商/重载声明
朋友的ostream＆操作符<<（ostream的，复杂的）;/
/重载流插入运算符<<复杂的输出
朋友istream的＆操作符>>（istream的，复杂的）;
/重载多个输入流提取运算符>>
无效complexAdd（）;
的无效complexSubtract的（）;
的无效complexMultiply的（）;
的无效complexDivide（）;
......
/>的朋友无效complexCompare（）;
朋友双MOD（const的复杂＆C）;/
/求长度的平方
私人如下：
双实;
双成像;
BR
/>};
/
/
=======================================
===================================
/
/
=========
=======成员函数在类外定义=====================================
=====
无效情结::
setComplex的（双R，双I）
{
雷亚尔=
R;
IMAG
=
I;
}
/
/
-
---------------------------------------------
复杂复杂::运算符+（大楼及C2）
{
复杂的C;
c.real
=实际+
c2.real;
c.imag成像+
c2.imag;
回报;
}
/
/
--------------------------------
--------------
复杂复杂::运营商（复杂和C2）
{
复杂的C;
c.real
=实际c2.real;
c.imag
=成像c2.imag;
回报;
}
/
/
-------------
---------------------------------
复杂复杂::运算符*（大楼及C2）
/>
{
复杂的C;
c.real
=实际*
c2.real-IMAG
*
c2.imag;
c.imag
=成像*
C2。真正+真正c2.imag;
回报;
}
/
/
------------------------
----------------------
复杂复杂::运算符/（大楼及C2）
{
复杂的C;
BR
/>
c.real
=（实际*
c2.real
+成像c2.imag）/（c2.real
c2.real
+
c2.imag
*
c2.imag）;
c.imag
=（IMAG
*
C2。真正的实时c2.imag）/（c2.real
c2.real
+
c2.imag
c2.imag）;
回报;
}
/
/
---
--------------------------------------------
ostream的运营商<（ostream的输出，复合＆C）
{
（c.imag>
=
0）
输出<<“（”<<
c.real“;”
+“<<
c.imag”“）;
其他
输出<<”（“<<
c.real
<<”“<<
c.imag”“）”
返回输出;
}
/
/
-------------------------------
-------------------
istream的＆操作符>>（istream的输入，复合＆C）
{
法院<<“请输入复数的实部和虚部，中间用空格隔开：“
输入>>
c.real
>>
c.imag
返回输入;
}
/
/
===============================
========================================
/
/
====
=============功能定义函数（Function）============================
>
/
/复数加法
的空白complexAdd（）
{
整型数;
法院<<“请输入操作数（参与在另外的复数）数量（注意操作数
=
0）：“;
CIN
>>数;
一段时间（数>
10
|
|数<0）/
/输入操作数<=
10
{
法院<<“你输入的数量大于10或小于0，请重新输入！”<<
endl;
法院<<“请输入操作数（以参加在另外的复数）数量（注操作数
=
0）：“;
CIN
>>民;
}
（NUM
==
0
）cout
<<“请没有输入任何复杂的\
n”;
其他
{
复杂的共（0.0,0.0）;
（INT
I
=
0;
I
<民我+
+）
{
复杂的C;
CIN
>>
C;
总额=总+
C;
}
法院<<“”
“民”，“一个复杂的积累”<<总<<
endl;
}
}
/
/复杂的减法
的无效complexSubtract（）
{
数;
法院<<“请输入操作数（参与复杂的减法）号码（注操作数
=
0）：“;
霉素>>数量;
（数>
10
|
|数<0）/
/输入操作数<=
10
{
法院<<“您输入的数字大于10或小于0，请重新输入！”
<<
endl;
法院<<“请输入操作数（参与减法复数）（注操作数
=
0）：”
CIN
>>民;
}
（NUM
==
0）cout
<<“请没有输入任何复杂的\
n
\
n
\
n”;
其他
{
复杂的共（
0.0,0.0）;
CIN
>>共有;
（INT
I
=
2;
<=
NUM??我+
+）
{
复杂的C;
>
CIN
>>
C;
总额=总胆固醇;
}
法院<<“这个”“民”“复杂的回归和复杂的。”总<
endl;
BR
/>}
}
/
/乘法
的虚空complexMultiply（）
{
数;
法院<<数的输入操作（参与的乘法多元）（注操作数
=
0）：“;
CIN
>>民;
10
|
|数<0）/
/输入操作数<=
10
{
法院<<“你输入的数量是大于10或小于0，请重新输入！“<<
endl;
法院<<”输入操作数（多个）参与（注操作数
=
0）：“;
霉素>>数的乘法的数量
}
（NUM
==
0）法院<<“没有任何复杂的\
n
\
n
\
n”;
其他
{
BR
/>复杂总额（1.0,0.0）;
/
/注意这里的初始值
（i
=
1;
<=
NUM??我+
+）
{
复杂的C
;
CIN
>>
C;
总额=总*
C;
}
COUT
<<“这个”“民”的复数累乘法和“<<总<endl;
}
}
/
/复杂的分工
的无效complexDivide（）
BR
/>
{
整型数;
法院<<“输入操作数（参与复杂的分工）（注操作数
=
0）：”
CIN
>>数;
（NUM>
10
|
|数<0）/
/输入操作数<=
10
{
法院<<“您输入的号码是大于10或小于0，请重新输入！“<<
endl;
法院<<”输入操作数（参与分工的复数）（注操作数
=
0）：
“
CIN
>>数;
}
（NUM
==
0）法院<<”输入是复数\
n
\
n
\
n“;
>
其他
{
复杂的总量;
CIN
>>共有;/
/参与分工的第一次分配一个编号的总
（INT
I
=
2;
<=
NUM??，我+
+）
{
复杂的C;
CIN
>>
C;
（MOD（C））
BR
/>
{
法院<<“除数为零，输入错误，请重新输入\
n
\
n”;
CIN
>>
C;
}
总=总/
C;
}
法院<<“这”“民”“累，除了复数的供应商”<<总<<
endl;
}
a>
}
/
/两个多比较功能
无效complexCompare（）/
/两个复杂的比较函数
>
{
复杂的C1，C2;
法院<<“请输入两个复杂的：\
n”;
CIN
>>
C1;
CIN
>>
C2;
>（（c1.real
==
c2.real）&&（c1.imag
==
C2。IMAG））法院<<“两个复杂的平等\
n”;
其他的话（MOD（C1）调制（
c2）的）法院<<
c1的<<“大于”<<
c2的<<“\”;/
/比较模式的模具中的模量长
其他如果数（Mod（c1）的<设为Mod（C2）
）法院<<
C2
<<模模数大于“<<
C1
<<”\
n“;/
/比较模式下，长
其他cout
<<”请两个复杂的模数等于\
n“;
/
/比较模式长
}
/
/找到的长度函数的平方
双MOD（const的复杂＆C）
{
回报（c.real
*
c.real
+
c.imag
c.imag）;
}
/
/主要功能
诠释的main（）
>
{
诠释的选择;
法院<<“这是一个简单的复数运算的计算器，进入功能选择：”<<
endl;
法院“0。退出。
2加法器，减法乘法。第5分部。比较复杂的尺寸（模数）\
n
\
n“;
CIN
>>选择;/
/输入功能选择
{
（选择==
0）{
cout
<<“请\
n
\
n欢迎下次继续使用复数计算器！
\
n
\
n“;打破;}
否则，如果（选择==
1）complexAdd（）;
否则，如果（选择==
2）complexSubtract（）;
否则，如果（选择=
如果=
3）complexMultiply（）（选择==
4）complexDivide（）;
其他（选择==
5）complexCompare（）;
其他法院<<“\
n
\
n输入错误，请重新输入！
\
n
\
n“;
法院<<”\
n
\
n
\
n这是一个简单的复数运算的计算器，进入功能选择：“<<
endl
<<
endl;
法院<<“0。退出1。
2加法器，减法乘法。第5分部。比较复杂的尺寸（模数）\
n“;
CIN
>>选择;/
/输入功能选择
}（choice!
=
0）;
>
返回0;
}

Answer 4

代码我倒是有 但是不能直接发给你 变成这东西还要自己一步一步来 你这样直接要答案 永远挂科学不好