实验报告 8-1

 

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

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

* 程序头部的注释结束

*/

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

  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. }  

 

 


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

  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。

  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就行

 

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值