devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

第四章——运算符重载运算课后练习题_c++程序设计04737第四章运算符重载习题

作者：秋刀鱼在做梦 | 2024-07-10 16:07:06

赞

踩

c++程序设计04737第四章运算符重载习题

练习题1

解题思路：题目中描述是非成员，非友元的普通函数，又要实现复数的运算。第一感觉应该把real和imag设置成public，但是这样就破坏了C++的封装性，所以，我设置了一个getReal()和getImag()的函数，获取real和imag数据

  1. //类声明文件
  2. #include<iostream>
  3. using namespace std;
  4. class Complex
  5. {
  6. public:
  7. 	//构造函数
  8. 	Complex();                                                   
  9. 	//构造构造函数
  10. 	Complex(int ,int );
  11. 	int getReal();
  12. 	int getImag();
  13. 	void display();
  14. private:
  15. 	int real;
  16. 	int imag;
  17. };
  18.  
  19. //类实现文件
  20. #include<iostream>
  21. #include "complex.h"
  22. using namespace std;
  23. Complex::Complex():real(0),imag(0){}
  24. Complex::Complex(int r,int i):real(r),imag(i){}
  25. int Complex::getReal()
  26. {
  27. 	return this->real;
  28. }
  29. int Complex::getImag()
  30. {
  31. 	return this->imag;
  32. }
  33. void Complex::display()
  34. {
  35. 	cout<<this->real<<" + "<<this->imag<<"i"<<endl;
  36. }
  37.  
  38. //主函数文件
  39. #include<iostream>
  40. #include "complex.h"
  41. using namespace std;
  42. Complex operator +( Complex &complex1, Complex &complex2)
  43. {
  44. 	return (Complex(complex1.getReal()+complex2.getReal(),complex1.getImag()+complex2.getImag()));
  45.  
  46. }
  47. int main()
  48. {
  49. 	class Complex complex1(3,30),complex2(5,20);
  50. 	Complex complex3 = complex1 + complex2;
  51. 	complex3.display();
  52.  
  53. 	system("pause");
  54. 	return 0;
  55. }

练习题2

  1. //类声明文件
  2. #include<iostream>
  3. using namespace std;
  4. class Complex
  5. {
  6. public:
  7. 	//构造函数
  8. 	Complex();                                                   
  9. 	//构造构造函数
  10. 	Complex(int ,int );
  11. 	Complex operator +( Complex &complex);
  12. 	Complex operator -( Complex &complex);
  13. 	Complex operator *( Complex &complex);
  14. 	Complex operator /( Complex &complex);
  15. 	int getReal();
  16. 	int getImag();
  17. 	void display();
  18. private:
  19. 	int real;
  20. 	int imag;
  21. };
  22.  
  23. //类实现文件
  24. #include<iostream>
  25. #include "complex.h"
  26. using namespace std;
  27. Complex::Complex():real(0),imag(0){}
  28. Complex::Complex(int r,int i):real(r),imag(i){}
  29. Complex Complex::operator +( Complex &complex)
  30. {
  31. 	return (Complex(this->real + complex.real,this->imag + complex.imag));
  32.  
  33. }
  34. Complex Complex::operator -( Complex &complex)
  35. {
  36. 	return (Complex(this->real - complex.real,this->imag - complex.imag));
  37.  
  38. }
  39. Complex Complex::operator *( Complex &complex)
  40. {
  41. 	return (Complex(this->real * complex.real - this->imag * complex.imag,this->real * complex.imag + this->imag * complex.real));
  42.  
  43. }
  44. Complex Complex::operator /( Complex &complex)
  45. {
  46. 	int Denominator = complex.real * complex.real + complex.imag * complex.imag;
  47. 	if(Denominator != 0)
  48. 	{
  49. 	
  50. 		return (Complex((this->real * complex.real + this->imag * complex.imag)/Denominator,(this->imag * complex.real - this->real * complex.imag)/Denominator));
  51.  
  52. 	}
  53. 	
  54. }
  55.  
  56. int Complex::getReal()
  57. {
  58. 	return this->real;
  59. }
  60. int Complex::getImag()
  61. {
  62. 	return this->imag;
  63. }
  64. void Complex::display()
  65. {
  66. 	cout<<this->real<<" + "<<this->imag<<"i"<<endl;
  67. }
  68.  
  69. //主函数文件
  70. #include<iostream>
  71. #include "complex.h"
  72. using namespace std;
  73.  
  74. int main()
  75. {
  76. 	class Complex complex1(3,30),complex2(5,20);
  77. 	Complex complex3 = complex1 + complex2;
  78.  
  79. 	complex3.display();
  80. 	Complex complex4 = complex1 - complex2;
  81. 	complex4.display();
  82.  
  83. 	Complex complex5 = complex1 * complex2;
  84. 	complex5.display();
  85.  
  86. 	Complex complex6 = complex1 / complex2;
  87. 	complex6.display();
  88.  
  89.  
  90. 	system("pause");
  91. 	return 0;
  92. }

练习题3

解题思路：根据题目描述，可以决定采用友元函数+转换构造函数可以实现加法交换律

  1. //类声明文件
  2. #include<iostream>
  3. using namespace std;
  4. class Complex
  5. {
  6. public:
  7. 	//构造函数
  8. 	Complex();                                                   
  9. 	//构造构造函数
  10. 	Complex(int ,int );
  11. 	//转换构造函数
  12. 	Complex(int );
  13. 	friend Complex operator +( const Complex &,const Complex &);
  14. 	int getReal();
  15. 	int getImag();
  16. 	void display();
  17. private:
  18. 	int real;
  19. 	int imag;
  20. };
  21.  
  22. //类实现文件
  23. #include<iostream>
  24. #include "complex.h"
  25. using namespace std;
  26. Complex::Complex():real(0),imag(0){}
  27. Complex::Complex(int r):real(r),imag(0){}// 转换构造函数
  28. Complex::Complex(int r,int i):real(r),imag(i){}
  29. Complex operator +( const Complex &complex1,const Complex &complex2)
  30. {
  31. 	return (Complex(complex1.real + complex2.real,complex1.imag + complex2.imag));
  32.  
  33. }
  34. int Complex::getReal()
  35. {
  36. 	return this->real;
  37. }
  38. int Complex::getImag()
  39. {
  40. 	return this->imag;
  41. }
  42. void Complex::display()
  43. {
  44. 	cout<<this->real<<" + "<<this->imag<<"i"<<endl;
  45. }
  46.  
  47. //主函数文件
  48. #include<iostream>
  49. #include "complex.h"
  50. using namespace std;
  51.  
  52. int main()
  53. {
  54. 	class Complex complex1(3,30),complex2(5,20);
  55. 	Complex complex3 = complex1 + complex2;
  56. 	complex3.display();
  57. 	complex3 = 2 + complex2;
  58. 	complex3.display();
  59. 	complex3 = complex2 + 2;
  60. 	complex3.display();
  61. 	system("pause");
  62. 	return 0;
  63. }
  64.

练习题4+5

解题思路：在矩阵中我用了二维数组指针，同时还用了指针的指针。在析构函数中释放指针的指针，在浅拷贝中容易造成野指针，所以我使用了复制构造函数，解决上述问题。

指针的指针接收指针数组的过程，参考博客：https://blog.csdn.net/ChaoFeiLi/article/details/103674308

  1. //类声明文件
  2. #include<iostream>
  3. using namespace std;
  4. class Matrix
  5. {
  6. public:
  7. 	Matrix(int = 1,int = 1);
  8. 	Matrix(const Matrix&);
  9. 	friend Matrix operator +(const Matrix&,const Matrix&);
  10. 	friend ostream& operator <<(ostream&,const Matrix&);
  11. 	friend istream& operator >>(istream&,const Matrix&);
  12. 	void set();
  13. 	void set(double **,int,int);
  14. 	void display();
  15. 	~Matrix(){
  16. 		delete []ptr;
  17. 	}
  18. protected:
  19. 	float **ptr;
  20. private:
  21. 	
  22. 	int row;
  23. 	int column;
  24. };
  25.  
  26. //类实现文件
  27. #include<iostream>
  28. #include "matrix.h"
  29. using namespace std;
  30. Matrix::Matrix(int r ,int c)
  31. {
  32. 	if(r ==0 || c == 0)
  33. 	{
  34. 		return;
  35. 	}
  36. 	row = r;
  37. 	column = c;
  38. 	ptr = new float* [row];
  39. 	for(int i = 0; i < row; i++)
  40. 	{
  41. 		   ptr[i] = new float [column];
  42. 	}
  43. }
  44. Matrix::Matrix(const Matrix&matrix)
  45. {
  46. 	this->row = matrix.row;
  47. 	this->column = matrix.column;
  48. 	this->ptr = new float*[row];
  49. 	for(int i = 0;i<row;i++)
  50. 	{
  51. 		ptr[i] = new float[column];
  52. 		for(int j = 0;j<column;j++)
  53. 		{
  54. 			this->ptr[i][j] = matrix.ptr[i][j];
  55. 		}
  56. 	}
  57. }
  58. Matrix operator +(const Matrix &matrix1,const Matrix &matrix2)
  59. {
  60. 	int row = matrix1.row;
  61. 	int column = matrix1.column;
  62. 	Matrix matrix(row,column);
  63.  
  64. 	for(int i = 0;i < row;i++)
  65. 	{
  66. 		for(int j = 0;j < column;j++)
  67. 		{
  68. 			matrix.ptr[i][j] = matrix1.ptr[i][j] + matrix2.ptr[i][j];
  69. 		}
  70. 	}
  71. 	return matrix;
  72. }
  73.  
  74.  
  75. ostream& operator <<(ostream &output,const Matrix &matrix)
  76. {
  77. 	int row = matrix.row;
  78. 	int column = matrix.column;
  79. 	for(int i = 0;i < row;i++)
  80. 	{
  81. 		for(int j = 0;j < column;j++)
  82. 		{
  83. 			output<<matrix.ptr[i][j]<<"  ";
  84. 		
  85. 		}
  86. 		output<<endl;
  87. 	
  88. 	}
  89. 	
  90.  
  91. 	return output;
  92.  
  93. }
  94. istream& operator >>(istream& input,const Matrix&matrix)
  95. {
  96. 	int row = matrix.row;
  97. 	int column = matrix.column;
  98. 	for(int i = 0;i < row;i++)
  99. 	{
  100. 		for(int j = 0;j < column;j++)
  101. 		{
  102. 			input>>matrix.ptr[i][j];
  103. 		
  104. 		}
  105. 	
  106. 	}
  107. 	return input;
  108.  
  109. }
  110. void Matrix::set()
  111. {
  112. 	for(int i = 0;i < row;i++)
  113. 	{
  114. 		for(int j = 0;j < column;j++)
  115. 		{
  116. 			cin>>ptr[i][j];
  117. 		
  118. 		}
  119. 	
  120. 	}
  121.  
  122. }
  123. void Matrix::set(double **p,int r,int c)
  124. {
  125. 	ptr = new float *[row];
  126. 	for (int i = 0;i < row;i++)
  127. 	{
  128. 		ptr[i] = new float[column];
  129. 		for (int j = 0;i<column;j++)
  130. 		{
  131. 				ptr[i][j] = p[i][j];
  132. 		}
  133. 	}
  134.  
  135.  
  136. }
  137. void Matrix::display()
  138. {
  139. 	for(int i = 0;i < row;i++)
  140. 	{
  141. 		for(int j = 0;j < column;j++)
  142. 		{
  143. 			cout<<ptr[i][j]<<"  ";
  144. 		
  145. 		}
  146. 		cout<<endl;
  147. 	
  148. 	}
  149. }
  150.  
  151. //主函数文件
  152. #include<iostream>
  153. #include "matrix.h"
  154. using namespace std;
  155. int main()
  156. {
  157.  
  158.  
  159. 	Matrix matrix1(2,3);
  160. 	cin>>matrix1;
  161. 	cout<<endl;
  162. 	Matrix matrix2(2,3);
  163. 	cin>>matrix2;
  164. 	Matrix matrix = matrix1 + matrix2;
  165. 	cout<<matrix;
  166.  
  167. 	system("pause");
  168. 	return 0;
  169. }

练习题6

  1. //类声明文件
  2. #include<iostream>
  3. using namespace std;
  4. class Complex
  5. {
  6. public:
  7. 	//构造函数
  8. 	Complex();                                                   
  9. 	//构造构造函数
  10. 	Complex(double,double);
  11. 	//转换构造函数
  12. 	Complex(double);
  13. 	//类型转换函数
  14. 	operator double() const;
  15. 	void display();
  16. private:
  17. 	double real;
  18. 	double imag;
  19. };
  20. //类实现文件
  21. #include<iostream>
  22. #include "complex.h"
  23. using namespace std;
  24. Complex::Complex():real(0),imag(0){}
  25. Complex::Complex(double r):real(r),imag(0){}
  26. Complex::Complex(double r,double i):real(r),imag(i){}
  27.  
  28. void Complex::display()
  29. {
  30. 	cout<<this->real<<" + "<<this->imag<<"i"<<endl;
  31. }
  32. Complex::operator double() const
  33. {
  34. 	return this->real;
  35. }
  36.  
  37. //主函数文件
  38. #include<iostream>
  39. #include "complex.h"
  40. using namespace std;
  41. int main()
  42. {
  43. 	class Complex complex1(3,30);
  44. 	double d1 = 2.5;
  45. 	d1 = d1 + complex1;
  46. 	cout<<d1<<endl;
  47. 	Complex(d1).display();
  48. 	system("pause");
  49. 	return 0;
  50. }

练习题7

必须把class Student中的成员变量设置为public的，或者通过get函数获取；在转换构造函数中无法使用

  1. //类声明文件
  2. #include <iostream>
  3. class Student
  4. {
  5. public:
  6. 	Student(int,char [],char);
  7. 	void display();
  8. 	int num;
  9. 	char name[50];
  10. 	char sex;
  11.  
  12. };
  13. class Teacher
  14. {
  15. public:
  16. 	Teacher(int,char [],char);
  17. 	//转换构造函数
  18. 	Teacher(const Student&);
  19. 	void display();
  20. private:
  21. 	int num;
  22. 	char name[50];
  23. 	char sex;
  24.  
  25. };
  26. //类实现文件
  27. #include <iostream>
  28. #include "worker.h"
  29. using namespace std;
  30. Student::Student(int n,char na[],char s)
  31. {
  32. 	this->num = n;
  33. 	strcpy(this->name, na);
  34. 	this->sex = s;
  35. }
  36. void Student::display()
  37. {
  38. 	cout <<name<<endl;
  39. }
  40. Teacher::Teacher(int n,char na[],char s)
  41. {
  42. 	this->num = n;
  43. 	strcpy(this->name, na);
  44. 	this->sex = s;
  45. }
  46. Teacher::Teacher(const Student &student)
  47. {
  48. 	this->num = student.num;
  49. 	strcpy(this->name, student.name);
  50. 	this->sex = student.sex;
  51. }
  52. void Teacher::display()
  53. {
  54. 	cout<<this->name<<"   "<<this->num<<"   "<<this->sex<<endl;
  55. }
  56. //主函数文件
  57. #include<iostream>
  58. #include "worker.h"
  59. using namespace std;
  60. int main()
  61. {
  62. 	class Student student1(2017,"andrew",'m');
  63. 	student1.display();
  64. 	class Teacher teacher1(student1);
  65. 	teacher1.display();
  66. 	system("pause");
  67. 	return 0;
  68. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/806840
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号