实验报告 8-1

最新推荐文章于 2022-10-10 15:09:14 发布
最新推荐文章于 2022-10-10 15:09:14 发布
阅读量679 收藏
点赞数
分类专栏： c++ 文章标签： c bi system 任务 扩展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhl7191111/article/details/7442189
版权
 

/* (程序头部注释开始)
* 程序的版权和版本声明部分
* Copyright (c) 2011, 烟台大学计算机学院学生 
* All rights reserved.
* 文件名称：定义一个复数类重载运算符+、-、*、/，使之能用于复数的加减乘除。

* 作    者：                              
* 完成日期：     2012    年 04      月  09   日
* 版 本 号：       V1.0   
* 对任务及求解方法的描述部分
* 输入描述： 
* 问题描述： 
* 程序输出： 

* 程序头部的注释结束

*/

方案一：用类的成员函数完成运算符的重载：

[cpp] view plain copy print ?
  1.  #include <iostream>   
  2. using namespace std;  
  3. class Complex  
  4. {  
  5. public:  
  6.     Complex(){real=0;imag=0;}  
  7.     Complex(double r,double i){real=r;imag=i;}  
  8.     Complex operator+(Complex &c2);  
  9.     Complex operator-(Complex &c2);  
  10.     Complex operator*(Complex &c2);  
  11.     Complex operator/(Complex &c2);  
  12.     void display();  
  13. private:  
  14.     double real;  
  15.     double imag;  
  16. };  
  17. //下面定义成员函数   
  18. Complex Complex::operator+(Complex &c2)  
  19. {  
  20.     Complex c;  
  21.     c.real=real+c2.real;  
  22.     c.imag=imag+c2.imag;  
  23.     return c;  
  24.   
  25. }  
  26. Complex Complex::operator-(Complex &c2)  
  27. {  
  28.     Complex c;  
  29.     c.real=real-c2.real;  
  30.     c.imag=imag-c2.imag;  
  31.     return c;  
  32. }  
  33.   
  34. Complex Complex::operator*(Complex &c2)  
  35. {  
  36.     Complex c;  
  37.     c.real=real*c2.real-imag*c2.imag;  
  38.     c.imag=imag*c2.real+real*c2.imag;  
  39.     return c;  
  40. }  
  41.   
  42.  Complex Complex::operator/(Complex &c2)  
  43. {  
  44.     Complex c;  
  45.     c.real=(real*c2.real+imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);  
  46.     c.imag=(imag*c2.real-real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);  
  47.     return c;  
  48. }  
  49.   
  50. void Complex::display()  
  51. {  
  52.     cout<<"("<<real<<","<<imag<<"i)"<<endl;  
  53. }  
  54.   
  55. int main()  
  56. {  
  57.     Complex c1(3,4),c2(5,-10),c3;  
  58.     cout<<"c1=";  
  59.     c1.display();  
  60.     cout<<"c2=";  
  61.     c2.display();  
  62.     c3=c1+c2;  
  63.     cout<<"c1+c2=";  
  64.     c3.display();  
  65.     c3=c1-c2;  
  66.     cout<<"c1-c2=";  
  67.     c3.display();  
  68.     c3=c1*c2;  
  69.     cout<<"c1*c2=";  
  70.     c3.display();  
  71.     c3=c1/c2;  
  72.     cout<<"c1/c2=";  
  73.     c3.display();  
  74.     system("pause");  
  75.     return 0;  
  76. }  

 

 


方案二：请用类的友元函数，而不是成员函数，完成上面提及的运算符的重载：

[cpp] view plain copy print ?
  1. 01.#include<iostream>     
  2. 02.using namespace std;    
  3. 03.class Complex    
  4. 04.{    
  5. 05.public:    
  6. 06.    Complex(){real=0;imag=0;}    
  7. 07.    Complex(double r,double i){real=r;imag=i;}    
  8. 08.    friend Complex operator+(Complex &c1,Complex &c2);    
  9. 09.    friend Complex operator-(Complex &c1,Complex &c2);    
  10. 10.    friend Complex operator*(Complex &c1,Complex &c2);    
  11. 11.    friend Complex operator/(Complex &c1,Complex &c2);    
  12. 12.    friend void display(Complex &c2);    
  13. 13.private:    
  14. 14.    double real;    
  15. 15.    double imag;    
  16. 16.};    
  17. 17.//下面定义友元函数      
  18. 18.    
  19. 19.//复数相加： (a+bi)+(c+di)=(a+c)+(b+d)i.      
  20. 20.Complex operator+(Complex &c1,Complex &c2)        
  21. 21.{      
  22. 22.    Complex c;       
  23. 23.    c.real=c1.real+c2.real;      
  24. 24.    c.imag=c1.imag+c2.imag;      
  25. 25.    return c;      
  26. 26.}      
  27. 27.      
  28. 28.      
  29. 29.//复数相减：(a+bi)-(c+di)=(a-c)+(b-d)i.            
  30. 30.Complex operator-(Complex &c1,Complex &c2)          
  31. 31.{          
  32. 32.    Complex c;          
  33. 33.    c.real=c1.real-c2.real;          
  34. 34.    c.imag=c1.imag-c2.imag;          
  35. 35.    return c;          
  36. 36.}          
  37. 37.        
  38. 38.//复数相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i.        
  39. 39.       
  40. 40.Complex operator*(Complex &c1,Complex &c2)     
  41. 41.{          
  42. 42.    Complex  c;          
  43. 43.    c.real=c1.real*c2.real-c1.imag*c2.imag;          
  44. 44.    c.imag=c1.imag*c2.real+c1.real*c2.imag;          
  45. 45.    return c;          
  46. 46.}          
  47. 47.        
  48. 48.//复数相除：(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i        
  49. 49.Complex operator/(Complex &c1,Complex &c2)     
  50. 50.{          
  51. 51.    Complex  c;          
  52. 52.    double d=c2.real*c2.real+c2.imag*c2.imag;      
  53. 53.    c.real=(c1.real*c2.real+c1.imag*c2.imag)/d;     //此处有危险未排除：除法溢出        
  54. 54.    c.imag=(c1.imag*c2.real-c1.real*c2.imag)/d;          
  55. 55.    return c;          
  56. 56.}       
  57. 57.         
  58. 58.void display(Complex &c2)        
  59. 59.{      
  60. 60.    cout<<"("<<c2.real<<","<<c2.imag<<"i)"<<endl;      
  61. 61.}      
  62. 62.    
  63. 63.int main()    
  64. 64.{    
  65. 65.    Complex c1(3,4),c2(5,-10),c3;    
  66. 66.    cout<<"c1=";    
  67. 67.    display(c1);    
  68. 68.    cout<<"c2=";    
  69. 69.    display(c2);    
  70. 70.    c3=c1+c2;    
  71. 71.    cout<<"c1+c2=";    
  72. 72.    display(c3);    
  73. 73.    c3=c1-c2;    
  74. 74.    cout<<"c1-c2=";    
  75. 75.    display(c3);    
  76. 76.    c3=c1*c2;    
  77. 77.    cout<<"c1*c2=";    
  78. 78.    display(c3);    
  79. 79.    c3=c1/c2;    
  80. 80.    cout<<"c1/c2=";    
  81. 81.    display(c3);    
  82. 82.    system("pause");    
  83. 83.    return 0;    
  84. 84.}    
  85. #include<iostream>   
  86. using namespace std;  
  87. class Complex  
  88. {  
  89. public:  
  90.     Complex(){real=0;imag=0;}  
  91.     Complex(double r,double i){real=r;imag=i;}  
  92.     friend Complex operator+(Complex &c1,Complex &c2);  
  93.     friend Complex operator-(Complex &c1,Complex &c2);  
  94.     friend Complex operator*(Complex &c1,Complex &c2);  
  95.     friend Complex operator/(Complex &c1,Complex &c2);  
  96.     friend void display(Complex &c2);  
  97. private:  
  98.     double real;  
  99.     double imag;  
  100. };  
  101. //下面定义友元函数   
  102.   
  103. //复数相加： (a+bi)+(c+di)=(a+c)+(b+d)i.   
  104. Complex operator+(Complex &c1,Complex &c2)      
  105. {    
  106.     Complex c;     
  107.     c.real=c1.real+c2.real;    
  108.     c.imag=c1.imag+c2.imag;    
  109.     return c;    
  110. }    
  111.     
  112.     
  113. //复数相减：(a+bi)-(c+di)=(a-c)+(b-d)i.         
  114. Complex operator-(Complex &c1,Complex &c2)        
  115. {        
  116.     Complex c;        
  117.     c.real=c1.real-c2.real;        
  118.     c.imag=c1.imag-c2.imag;        
  119.     return c;        
  120. }        
  121.       
  122. //复数相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i.     
  123.      
  124. Complex operator*(Complex &c1,Complex &c2)   
  125. {        
  126.     Complex  c;        
  127.     c.real=c1.real*c2.real-c1.imag*c2.imag;        
  128.     c.imag=c1.imag*c2.real+c1.real*c2.imag;        
  129.     return c;        
  130. }        
  131.       
  132. //复数相除：(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i     
  133. Complex operator/(Complex &c1,Complex &c2)   
  134. {        
  135.     Complex  c;        
  136.     double d=c2.real*c2.real+c2.imag*c2.imag;    
  137.     c.real=(c1.real*c2.real+c1.imag*c2.imag)/d;     //此处有危险未排除：除法溢出     
  138.     c.imag=(c1.imag*c2.real-c1.real*c2.imag)/d;        
  139.     return c;        
  140. }     
  141.        
  142. void display(Complex &c2)      
  143. {    
  144.     cout<<"("<<c2.real<<","<<c2.imag<<"i)"<<endl;    
  145. }    
  146.   
  147. int main()  
  148. {  
  149.     Complex c1(3,4),c2(5,-10),c3;  
  150.     cout<<"c1=";  
  151.     display(c1);  
  152.     cout<<"c2=";  
  153.     display(c2);  
  154.     c3=c1+c2;  
  155.     cout<<"c1+c2=";  
  156.     display(c3);  
  157.     c3=c1-c2;  
  158.     cout<<"c1-c2=";  
  159.     display(c3);  
  160.     c3=c1*c2;  
  161.     cout<<"c1*c2=";  
  162.     display(c3);  
  163.     c3=c1/c2;  
  164.     cout<<"c1/c2=";  
  165.     display(c3);  
  166.     system("pause");  
  167.     return 0;  
  168. }  
  169.    
  170.   
  171. 运行结果：  


 

 

方案三：在方案二的基础上，扩展+、-、*、/运算符的功能，使之能与double型数据进行运算。设Complex c; double d; c?d和d?c的结果为将d视为实部为d的复数同c运算的结果（其中?为+、-、*、/之一）。另外，定义一目运算符-，-c相当于0-c。

[cpp] view plain copy print ?
  1. 01.#include<iostream>     
  2. 02.using namespace std;    
  3. 03.class Complex    
  4. 04.{    
  5. 05.public:    
  6. 06.    Complex(){real=0;imag=0;}    
  7. 07.    Complex(double r,double i){real=r;imag=i;}    
  8. 08.    friend Complex operator+(Complex &c1,Complex &c2);    
  9. 09.    friend Complex operator-(Complex &c1,Complex &c2);    
  10. 10.    friend Complex operator-(Complex &c2);    
  11. 11.    friend Complex operator*(Complex &c1,Complex &c2);    
  12. 12.    friend Complex operator/(Complex &c1,Complex &c2);    
  13. 13.    friend Complex operator+(Complex &c1,const double &d);    
  14. 14.    friend Complex operator+(const double &d, Complex &c);    
  15. 15.    friend void display(Complex &c2);    
  16. 16.private:    
  17. 17.    double real;    
  18. 18.    double imag;    
  19. 19.};    
  20. 20.//下面定义友元函数      
  21. 21.    
  22. 22.//复数相加： (a+bi)+(c+di)=(a+c)+(b+d)i.      
  23. 23.Complex operator+(Complex &c1,Complex &c2)        
  24. 24.{      
  25. 25.    Complex c;       
  26. 26.    c.real=c1.real+c2.real;      
  27. 27.    c.imag=c1.imag+c2.imag;      
  28. 28.    return c;      
  29. 29.}      
  30. 30.Complex operator+(Complex &c1,const double &d)    
  31. 31.{    
  32. 32.    return Complex(c1.real+d, c1.imag);    
  33. 33.}    
  34. 34.Complex operator+(const double &d, Complex &c1)    
  35. 35.{    
  36. 36.    return Complex(c1.real+d, c1.imag);    
  37. 37.}    
  38. 38.      
  39. 39.//复数相减：(a+bi)-(c+di)=(a-c)+(b-d)i.            
  40. 40.Complex operator-(Complex &c1,Complex &c2)          
  41. 41.{          
  42. 42.    Complex c;          
  43. 43.    c.real=c1.real-c2.real;          
  44. 44.    c.imag=c1.imag-c2.imag;          
  45. 45.    return c;          
  46. 46.}          
  47. 47.Complex operator-(Complex &c2)    
  48. 48.{    
  49. 49.    return Complex(-c2.real, -c2.imag);    
  50. 50.    
  51. 51.}    
  52. 52.//复数相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i.        
  53. 53.       
  54. 54.Complex operator*(Complex &c1,Complex &c2)     
  55. 55.{          
  56. 56.    Complex  c;          
  57. 57.    c.real=c1.real*c2.real-c1.imag*c2.imag;          
  58. 58.    c.imag=c1.imag*c2.real+c1.real*c2.imag;          
  59. 59.    return c;          
  60. 60.}          
  61. 61.        
  62. 62.//复数相除：(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i        
  63. 63.Complex operator/(Complex &c1,Complex &c2)     
  64. 64.{          
  65. 65.    Complex  c;          
  66. 66.    double d=c2.real*c2.real+c2.imag*c2.imag;      
  67. 67.    c.real=(c1.real*c2.real+c1.imag*c2.imag)/d;     //此处有危险未排除：除法溢出        
  68. 68.    c.imag=(c1.imag*c2.real-c1.real*c2.imag)/d;          
  69. 69.    return c;          
  70. 70.}       
  71. 71.         
  72. 72.void display(Complex &c2)        
  73. 73.{      
  74. 74.    cout<<"("<<c2.real<<","<<c2.imag<<"i)"<<endl;      
  75. 75.}      
  76. 76.    
  77. 77.int main()    
  78. 78.{    
  79. 79.    Complex c1(3,4),c2(5,-10),c3,c4;    
  80. 80.    cout<<"c1=";    
  81. 81.    display(c1);    
  82. 82.    cout<<"c2=";    
  83. 83.    display(c2);    
  84. 84.    c3=c1+c2;    
  85. 85.    cout<<"c1+c2=";    
  86. 86.    display(c3);    
  87. 87.    c3=c1-c2;    
  88. 88.    cout<<"c1-c2=";    
  89. 89.    display(c3);    
  90. 90.    c3=c1*c2;    
  91. 91.    cout<<"c1*c2=";    
  92. 92.    display(c3);    
  93. 93.    c3=c1/c2;    
  94. 94.    cout<<"c1/c2=";    
  95. 95.    display(c3);    
  96. 96.    c4=c1+3.14;    
  97. 97.    cout<<"c1+3.14=";    
  98. 98.    display(c4);    
  99. 99.    c4=3.14+c1;    
  100. 100.    cout<<"3.14+c1=";    
  101. 101.    display(c4);    
  102. 102.    c4=-c1;    
  103. 103.    cout<<"-c1=";    
  104. 104.    display(c4);    
  105. 105.    system("pause");    
  106. 106.    return 0;    
  107. 107.}    


 有点长，但不是很难，步骤大体一样，Cope就行

 

zhl7191111
关注
专栏目录
TEC-8数据通路实验报告.docx
06-15
一篇自己写的计算机组成实验——TEC-8模拟数据通路实验报告的模板，比较简单，仅供学生等新手来参考，不足多多指点
TEC-8中断原理实验报告.docx
06-15
一篇自己写的计算机组成实验——TEC-8模拟中断原理实验报告的模板，比较简单，仅供学生等新手来参考，不足多多指点
BUPT计算机组成原理实验系统TEC-8仿真实验报告
06-02
本实验分为运算器组成实验，双端口存储器实验，数据通路实验，微程序控制实验，为计组实验课的课后作业报告
TEC-8运算器组成实验报告.docx
06-15
一篇自己写的计算机组成实验的TEC-8运算器组成实验报告模板，因为是学生所以比较简单，模板仅供学生参考
微程序控制器实验实验报告
05-30
广东工业大学的计算机组成原理实验3的实验报告，不过是个人报告，有些觉得不必要的东西都没加上去
《计算机组成原理》实验报告---8位算术逻辑运算实验.docx
07-05
《计算机组成原理》实验报告——8位算术逻辑运算实验主要涵盖了计算机硬件系统中的核心组件——运算器的设计和操作。该实验旨在让学生深入理解算术逻辑运算器（ALU）的工作原理，以及如何通过控制电路实现不同的算术...
西南交通大学 操作系统实验报告1-7.zip
06-29
这个压缩包“操作系统实验报告1-7.zip”包含了完整的实验过程，包括实验代码，为学习者提供了丰富的学习材料。 实验报告通常包括以下几个方面： 1. 实验目的：明确实验的目标，如理解进程管理、内存管理、文件系统...
《计算机组成原理》实验报告---8位算术逻辑运算实验.pdf
06-23
《计算机组成原理》实验报告---8位算术逻辑运算实验主要涵盖了计算机硬件核心部分——运算器的基本构造和工作原理，以及如何通过实际操作验证其功能。在这个实验中，学生需要理解算术逻辑运算器（ALU）的工作机制，...
C语言程序设计-大一实验报告1-10-长春工程学院
04-20
1. 交换两个变量的值，需要借助第三个变量； 2. 大小写字母之间的ASCII码相差32； 3. 在用scanf()函数输入时，如果格式控制字符串中有其他字符，应原样输入； 4. 输入整数用%d，输入单精度实数用%f，输入字符用%c； ...
TEC-2实验计算机微程序控制器实验二 实验报告
01-18
TEC-2实验计算机微程序控制器实验二 实验报告
计算机组成与结构实验一《运算器组成》
最新发布
weixin_52626339的博客
10-10 7657
运算器组成
操作系统文件系统设计实验报告
热门推荐
Henry's Blog
06-02 5万+
操作系统报告 文件系统设计     姓名： 郑兆涵                  专业： 计算机科学与技术(嵌入式方向)      计算机与控制工程学院 2016年6月1日 目录： 一、设计目的、意义 二、设计分析 三、方案分析 四、功能模块实现 五、最终结果分析 六、设计体会 七、附录 一、设计目的、
实验报告3
weixin_30905133的博客
11-04 113
网络对抗技术 实验报告 实验三 密码破解技术 学生姓名 刘立坤 年级 2015 区队 二区队 指导教师 高见 信息技术与网络安全学院 2018年10月17日 实验...
Java实验报告4
sifangege的博客
06-18 6133
一、实验目的： 1.了解如何使用类及其成员的修饰符，理解类的继承性，掌握方法的继承、重载和覆盖。二、实验环境： Eclipce三、实验内容：（一）修饰符     1.编写源程序KY4_1.java，通过两个类StaticDome、KY4_1来说明类变量和与对象变量，以及类方法和对       象方法的区别。源代码如下:       package ch4;       class StaticDe...
操作系统课程实验报告（四）
qq_32589509的博客
07-29 3036
进程运行轨迹的跟踪和统计实验——来自实验楼
第八周
zcyhr2012的专栏
04-24 743
#include using namespeace std; class Complex {public: Complex(){real=0;imag=0;} Complex(double r,double i){real=r;imag=i;} Complex operator+(Complex &c2); Complex operator-(Complex &c2);
[CSAPP]Bufbomb实验报告
yuchenchenyi的博客
04-14 1万+
Bufbomb实验报告 实验分析: level 0-3从test开始制执行,通过函数getbuf向外界读取一串内容(buf). Level 4 是通过参数-n,程序执行testn函数,调用getbufn函数向外界读取一串内容(bufn). 实验要求我们通过getbuf读取内容时不检查边界的这一特性,输入过多的内容把栈里面的东西修改掉,使得程序发生预定的错误. 实验给了我们
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值