devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++类和对象--封装，类分文件编写_实现一个类如何设置头文件封装

作者：IT小白 | 2024-03-15 20:32:04

赞

踩

实现一个类如何设置头文件封装

目录

 1.封装

1.1封装的意义一--将属性和行为作为一个整体

 1.1.1成员属性，成员变量，成员函数，成员方法

 1.2封装的意义二--将属性和行为加以控制，公共权限，保护权限，私有权限

1.3struct和class区别

1.4成员属性设置为私有的优点

 1.4.1可以自己控制读写权限

1.4.2对于写可以检测数据的有效性

1.5案例练习

1.5.1练习1--设计立方体

1.5.2练习二--点和圆的关系

1.5.2.1在类中可以让另一个类作为本类的成员

1.5.2.2如何把一个类拆到不同的文件中.h,.cpp

 1.封装

1.1封装的意义一--将属性和行为作为一个整体

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. const double PI = 3.14;
  5.  
  6. //设计圆类，求圆的周长
  7. //圆求周长的公式：2*PI*半径
  8.  
  9. //class达标设计一个类，类后面紧跟着的就是类名
  10. class Circle
  11. {
  12. 	//访问权限
  13. 	//公共权限，不管是在类内还是类外都可以访问
  14. public:
  15.  
  16. 	//属性,通常是一些变量
  17. 	int m_r;//半径
  18.  
  19. 	//行为，在代码中通常用函数去代表它
  20. 	//获取圆的周长
  21. 	double calculateZC()
  22. 	{
  23. 		return 2 * PI * m_r;
  24. 	}
  25.  
  26. };
  27. int main()
  28. {
  29. 	//通过圆类 创建具体的圆，具体的圆我们称为对象
  30. 	//实例化（通过一个类 创建一个对象的过程称为实例化）
  31. 	Circle c1;
  32. 	//给圆对象的属性进行赋值
  33. 	c1.m_r = 10;
  34. 	cout << "圆的周长为：" << c1.calculateZC() << endl;
  35.  
  36. 	//将半径和求周长封装在一起
  37. 	system("pause");//按任意键继续
  38. 	return 0;
  39. }

 1.1.1成员属性，成员变量，成员函数，成员方法

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. const double PI = 3.14;
  5.  
  6. //设计学生类
  7. class Student
  8. {
  9. 	//类中的属性和行为 我们统一称为 成员
  10. 	//属性也称为成员属性，成员变量
  11. 	//行为也称为成员函数 成员方法
  12. 	
  13.  
  14. 	//公共权限
  15. public:
  16.  
  17. 	//属性,通常是一些变量
  18. 	string name;
  19. 	int number;
  20.  
  21. 	//行为，在代码中通常用函数去代表它
  22. 	//显示姓名和学号
  23. 	void showStudent()
  24. 	{
  25. 		cout <<"姓名："<< name << " "
  26. 			<<"学号："<< number << endl;
  27. 	}
  28.  
  29. 	//可以通过行为给属性赋值
  30. 	//给姓名赋值
  31. 	void setName(string m_name)
  32. 	{
  33. 		name = m_name;
  34. 	}
  35. 	//给学号赋值
  36. 	void setNumber(int m_number)
  37. 	{
  38. 		number = m_number;
  39. 	}
  40. };
  41. int main()
  42. {
  43. 	//创建一个具体学生 实例化（通过一个类 创建对象的过程）对象
  44. 	Student s;
  45. 	//给s对象 进行属性赋值操作
  46. 	s.name = "张三";
  47. 	s.number = 201640;
  48. 	s.showStudent();
  49.  
  50. 	Student s1;
  51. 	s1.setName("李四");
  52. 	s1.setNumber(2017022);
  53. 	s1.showStudent();
  54.  
  55.  
  56. 	system("pause");//按任意键继续
  57. 	return 0;
  58. }

 1.2封装的意义二--将属性和行为加以控制，公共权限，保护权限，私有权限

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. //访问权限
  5. //公共权限 public 成员类内可以访问,类外也可以访问
  6. //保护权限 protected 成员类内可以访问,类外不可以访问 儿子可以访问父亲中的保护内容
  7. //私有权限 private 成员类内可以访问,类外不可以访问 儿子不可以访问父亲中的私有内容
  8.  
  9. class person
  10. {
  11. 	//公共权限
  12. public:
  13. 	string m_Name;//姓名
  14.  
  15. 	//保护权限
  16. protected:
  17. 	string m_Car;//汽车
  18.  
  19. 	//私有权限
  20. private:
  21. 	int m_Password;//银行卡密码
  22.  
  23. private:
  24. 	void func()
  25. 	{
  26. 		m_Name = "张三";
  27. 		m_Car = "拖拉机";
  28. 		m_Password = 123456;
  29. 	}
  30. };
  31.  
  32. int main()
  33. {
  34. 	//实例化具体对象
  35. 	person p1;
  36. 	p1.m_Name = "李四";
  37. 	//p1.m_car = "奔驰";//保护权限的内容，在类外访问不到
  38. 	//p1.m_Password = 123;//私有权限的内容，在类外访问不到
  39. 	//p1.func();私有权限的内容，在类外访问不到
  40.     
  41.  
  42.  
  43. 	system("pause");//按任意键继续
  44. 	return 0;
  45. }

1.3struct和class区别

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. class C1
  5. {
  6. 	//默认权限就是public啥的都没写
  7. 	int m_A;//默认权限是私有
  8. };
  9.  
  10. struct C2
  11. {
  12. 	int m_A;//默认权限 是公告
  13. };
  14. int main()
  15. {
  16. 	//struct和class的区别
  17. 	//struct 默认权限是 公共 public
  18. 	//class 默认权限是 私有 private
  19.  
  20. 	C1 c1;
  21. 	//c1.m_A = 100;//报错
  22.  
  23. 	C2 c2;
  24. 	c2.m_A = 100;//在struct中默认权限为公共，可以访问
  25.  
  26.  
  27. 	system("pause");//按任意键继续
  28. 	return 0;
  29. }

1.4成员属性设置为私有的优点

 1.4.1可以自己控制读写权限

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. //成员属性设置为私有
  5. //1、可以控制读写权限
  6. //2、对于写可以检测数据的有效性
  7.  
  8. class Person
  9. {
  10. public:
  11. 	//设置姓名
  12. 	void setName(string name)
  13. 	{
  14. 		m_Name = name;//对外提供一个公共的成员函数，来侧面给它的成员属性进行赋值操作
  15. 	}
  16. 	//获取姓名
  17. 	string getName()
  18. 	{
  19. 		return m_Name;
  20. 	}
  21. 	//获取年龄,只读
  22. 	int getAge()
  23. 	{
  24. 		m_Age = 0;//初始化为0岁
  25. 		return m_Age;
  26. 	}
  27. 	//设置情人 只写
  28. 	void setLover(string lover)
  29. 	{
  30. 		m_Lover = lover;
  31. 	}
  32. private:
  33. 	//姓名 可读可写
  34. 	string m_Name;
  35. 	//年龄 只读
  36. 	int m_Age;
  37. 	//情人 只写
  38. 	string m_Lover;
  39. };
  40. int main()
  41. {
  42. 	Person p;
  43. 	p.setName("张三");
  44. 	cout << "姓名为：" << p.getName() << endl;
  45.  
  46. 	//p.m_Age = 18;//只读
  47. 	//p.setAge(18);//只读
  48. 	cout << "年龄为：" << p.getAge() << endl;
  49.  
  50. 	//设置情人为苍井女士
  51. 	p.setLover("苍井");
  52. 	//cout << "情人为：" << p.m_Lover << endl;
  53. 	//cout << "情人为：" << p.getLover() << endl;
  54. 	system("pause");//按任意键继续
  55. 	return 0;
  56. }

1.4.2对于写可以检测数据的有效性

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. //成员属性设置为私有
  5. //1、可以控制读写权限
  6. //2、对于写可以检测数据的有效性
  7.  
  8. class Person
  9. {
  10. public:
  11. 	//设置姓名
  12. 	void setName(string name)
  13. 	{
  14. 		m_Name = name;//对外提供一个公共的成员函数，来侧面给它的成员属性进行赋值操作
  15. 	}
  16. 	//获取姓名
  17. 	string getName()
  18. 	{
  19. 		return m_Name;
  20. 	}
  21. 	//获取年龄,可读可写，如果想修改（年龄的范围必须是0-150之间）
  22. 	int getAge()
  23. 	{
  24. 		return m_Age;
  25. 	}
  26. 	//设置年龄
  27. 	void setAge(int age)
  28. 	{
  29. 		if (age < 0 || age>150)
  30. 		{
  31. 			cout << "年龄有误" << endl;
  32. 			m_Age = 0;
  33. 		}
  34. 		else
  35. 		{
  36. 			m_Age = age;
  37. 		}
  38. 		/*还可以这样写
  39. 		if (age < 0 || age>150)
  40. 		{
  41. 			cout << "年龄有误" << endl;
  42. 			m_Age = 0;
  43. 			return;
  44. 		}
  45. 		m_Age = age;
  46. 		*/
  47. 	}
  48. 	//设置情人 只写
  49. 	void setLover(string lover)
  50. 	{
  51. 		m_Lover = lover;
  52. 	}
  53. private:
  54. 	//姓名 可读可写
  55. 	string m_Name;
  56. 	//年龄 只读
  57. 	int m_Age;
  58. 	//情人 只写
  59. 	string m_Lover;
  60. };
  61. int main()
  62. {
  63. 	Person p;
  64. 	p.setName("张三");
  65. 	cout << "姓名为：" << p.getName() << endl;
  66.  
  67. 	p.setAge(18);
  68. 	cout << "年龄为：" << p.getAge() << endl;
  69.  
  70. 	//设置情人为苍井女士
  71. 	p.setLover("苍井");
  72. 	//cout << "情人为：" << p.m_Lover << endl;
  73. 	//cout << "情人为：" << p.getLover() << endl;
  74. 	system("pause");//按任意键继续
  75. 	return 0;
  76. }

1.5案例练习

1.5.1练习1--设计立方体

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. //立方体类
  5. class Cube
  6. {
  7. public:
  8. 	void setL(double l)//设置长
  9. 	{
  10. 		m_L = l;
  11. 	}
  12. 	double getL()//获取长
  13. 	{
  14. 		return m_L ;
  15. 	}
  16. 	void setW(double w)
  17. 	{
  18. 		m_W = w;
  19. 	}
  20. 	double getW()
  21. 	{
  22. 		return m_W;
  23. 	}
  24. 	void setH(double h)
  25. 	{
  26. 		m_H = h;
  27. 	}
  28. 	double getH()
  29. 	{
  30. 		return m_H;
  31. 	}
  32. 	double getS()//返回面积
  33. 	{
  34. 		return 2 * m_L * m_W + 2 * m_L * m_H + 2 * m_H * m_W;
  35. 	}
  36. 	double getV()//返回面积
  37. 	{
  38. 		return m_L * m_W * m_H;
  39. 	}
  40. 	//利用成员函数判断是否相等
  41. 	/*void judge(double l, double w, double h)
  42. 	{
  43. 		if (m_L == l && m_W == w && m_H == h)
  44. 		{
  45. 			cout << "相等" << endl;
  46. 		}
  47. 		else
  48. 		{
  49. 			cout << "不相等" << endl;
  50. 		}
  51. 	}*/
  52. 	bool isSamebyClass(Cube &c)//成员函数传一个就好，会用已知到去调用这个函数，传入一个未知的
  53. 	{
  54. 		if (m_L == c.getL() && m_W == c.getW() && m_H == c.getH())
  55. 		{
  56. 			return true;
  57. 		}
  58. 		return false;
  59. 	}
  60. private:
  61. 	double m_L, m_W, m_H;
  62. };
  63.  
  64. //利用全局函数判断是否相等
  65. /*void Qjudge(double a1, double a2, double a3, double b1, double b2, double b3)
  66. {
  67. 	if (a1 == b1 && a2 == b2 && a3 == b3)
  68. 	{
  69. 		cout << "相等" << endl;
  70. 	}
  71. 	else
  72. 	{
  73. 		cout << "不相等" << endl;
  74. 	}
  75. }*/
  76. bool isSame(Cube &c1, Cube &c2)//值传递会拷贝出来一份数据，引用传递不拷贝，会用原始的
  77. {
  78. 	if (c1.getL() == c2.getL() && c1.getW() == c2.getW() && c1.getH() == c2.getH())
  79. 	{
  80. 		return true;
  81. 	}
  82. 	return false;
  83. }
  84.  
  85. int main()
  86. {
  87. 	//创建立方体对象
  88. 	Cube c1, c2;
  89. 	c1.setL(10);
  90. 	c1.setW(10);
  91. 	c1.setH(10);
  92. 	c2.setL(20);
  93. 	c2.setW(20);
  94. 	c2.setH(20);
  95. 	cout << "c1面积" << c1.getS() << endl;
  96. 	cout << "c1体积：" << c1.getV() << endl;
  97. 	//利用成员函数判断
  98. 	//c1.judge(c2.getL(), c2.getW(), c2.getH());
  99. 	//利用全局函数判断
  100. 	//Qjudge(c1.getL(), c1.getW(), c1.getH(), c2.getL(), c2.getW(), c2.getH());
  101. 	
  102.  
  103. 	//利用全局函数判断
  104. 	bool ret = isSame(c1, c2);
  105. 	if (ret)
  106. 	{
  107. 		cout << "c1、c2相等" << endl;
  108. 	}
  109. 	else
  110. 	{
  111. 		cout << "c1、c2不相等" << endl;
  112.  
  113. 	}
  114. 	//利用成员函数判断
  115. 	bool ret1 = c1.isSamebyClass(c2);
  116. 	if (ret1)
  117. 	{
  118. 		cout << "c1、c2相等" << endl;
  119. 	}
  120. 	else
  121. 	{
  122. 		cout << "c1、c2不相等" << endl;
  123.  
  124. 	}
  125. 	system("pause");//按任意键继续
  126. 	return 0;
  127. }

1.5.2练习二--点和圆的关系

1.5.2.1在类中可以让另一个类作为本类的成员

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. //点类
  5. class Point
  6. {
  7. public:
  8. 	//设置x
  9. 	void setX(double x)
  10. 	{
  11. 		m_X = x;
  12. 	}
  13. 	//获取x
  14. 	double getX()
  15. 	{
  16. 		return m_X;
  17. 	}
  18. 	//设置y
  19. 	void setY(double y)
  20. 	{
  21. 		m_Y = y;
  22. 	}
  23. 	//获取y
  24. 	double getY()
  25. 	{
  26. 		return m_Y;
  27. 	}
  28. private:
  29. 	double m_X;
  30. 	double m_Y;
  31. };
  32. //圆类
  33. class Circle
  34. {
  35. public:
  36. 	//设置半径
  37. 	void setR(double r)
  38. 	{
  39. 		m_R = r;
  40. 	}
  41. 	//获取半径
  42. 	double getR()
  43. 	{
  44. 		return m_R;
  45. 	}
  46. 	//设置圆心
  47. 	void setC(Point center)
  48. 	{
  49. 		m_Center = center;
  50. 	}
  51. 	//获取圆心
  52. 	Point getC()
  53. 	{
  54. 		return m_Center;
  55. 	}
  56. private:
  57. 	double m_R;
  58.  
  59. 	//在类中可以让另一个类 作为本类中的成员
  60. 	Point m_Center;
  61. };
  62.  
  63. //判断点和圆之间的位置关系
  64. void isInCircle(Circle &c, Point &p)
  65. {
  66. 	//计算两点之间距离的平方
  67. 	double distance= (p.getX() - c.getC().getX())* (p.getX() - c.getC().getX())
  68. 		+ (p.getY() - c.getC().getY()) * (p.getY() - c.getC().getY());
  69. 	//计算半径的平方
  70. 	double rDistance= c.getR() * c.getR();
  71. 	if (distance == rDistance)
  72. 	{
  73. 		cout << "点在圆上" << endl;
  74. 	}
  75. 	else if (distance > rDistance)
  76. 	{
  77. 		cout << "点在圆外" << endl;
  78. 	}
  79. 	else
  80. 	{
  81. 		cout << "点在圆内" << endl;
  82. 	}
  83. }
  84. int main()
  85. {
  86. 	//创建圆
  87. 	Circle c;
  88. 	c.setR(10);
  89. 	Point cp;
  90. 	cp.setX(10);
  91. 	cp.setY(0);
  92. 	c.setC(cp);
  93. 	//创建点
  94. 	Point p1,p2,p3;
  95. 	p1.setX(10);
  96. 	p1.setY(9);
  97. 	p2.setX(10);
  98. 	p2.setY(10);
  99. 	p3.setX(10);
  100. 	p3.setY(11);
  101. 	isInCircle(c, p1);
  102. 	isInCircle(c, p2);
  103. 	isInCircle(c, p3);
  104. 	system("pause");//按任意键继续
  105. 	return 0;
  106. }

1.5.2.2如何把一个类拆到不同的文件中.h,.cpp

 

 

  1. /*point.h代码
  2. #pragma once//防止头文件重复包含
  3. //在头文件中声明
  4. #include<iostream>
  5. using namespace std;
  6. //把成员函数和属性声明
  7. class Point
  8. {
  9. public:
  10. 	void setX(double x);
  12. 		//获取x
  13. 	double getX();
  15. 		//设置y
  16. 	void setY(double y);
  18. 		//获取y
  19. 	double getY();
  21. private:
  22. 	double m_X;
  23. 	double m_Y;
  24. };
  26. */
  27. /*c.h代码
  28. #pragma once//防止头文件重复包含
  29. #include<iostream>
  30. using namespace std;
  31. #include"point.h"
  32. class Circle
  33. {
  34. public:
  35. 	//设置半径
  36. 	void setR(double r);
  37. 	//获取半径
  38. 	double getR();
  39. 	//设置圆心
  40. 	void setC(Point center);
  41. 	//获取圆心
  42. 	Point getC();//将point头文件加进来，让它知道有这么一个类
  43. private:
  44. 	double m_R;
  46. 	//在类中可以让另一个类 作为本类中的成员
  47. 	Point m_Center;
  48. };
  50. */
  51. /*circle.cpp代码
  52. #include"c.h"
  53. //在头文件中写声明，在cpp中写实现
  54. //设置半径
  55. void Circle::setR(double r)
  56. {
  57. 	m_R = r;
  58. }
  59. //获取半径
  60. double Circle::getR()
  61. {
  62. 	return m_R;
  63. }
  64. //设置圆心
  65. void Circle::setC(Point center)
  66. {
  67. 	m_Center = center;
  68. }
  69. //获取圆心
  70. Point Circle::getC()
  71. {
  72. 	return m_Center;
  73. }
  76. */
  77. /*P.cpp代码
  78. #include"point.h"
  79. //只需要留函数的所有实现
  81. //如果只写setX他是全局函数，
  82. // 但我们知道它是一个成员函数
  83. // 需要告诉他是哪个作用域下的
  84. 	//设置x
  85. void Point::setX(double x)//Point作用域下的成员函数
  86. {
  87. 	m_X = x;
  88. }
  89. //获取x
  90. double Point::getX()
  91. {
  92. 	return m_X;
  93. }
  94. //设置y
  95. void Point::setY(double y)
  96. {
  97. 	m_Y = y;
  98. }
  99. //获取y
  100. double Point::getY()
  101. {
  102. 	return m_Y;
  103. }
  105. */
  106. #include<iostream>
  107. using namespace std;
  108. #include"point.h"
  109. #include"c.h"
  110. //判断点和圆之间的位置关系
  111. void isInCircle(Circle &c, Point &p)
  112. {
  113. 	//计算两点之间距离的平方
  114. 	double distance= (p.getX() - c.getC().getX())* (p.getX() - c.getC().getX())
  115. 		+ (p.getY() - c.getC().getY()) * (p.getY() - c.getC().getY());
  116. 	//计算半径的平方
  117. 	double rDistance= c.getR() * c.getR();
  118. 	if (distance == rDistance)
  119. 	{
  120. 		cout << "点在圆上" << endl;
  121. 	}
  122. 	else if (distance > rDistance)
  123. 	{
  124. 		cout << "点在圆外" << endl;
  125. 	}
  126. 	else
  127. 	{
  128. 		cout << "点在圆内" << endl;
  129. 	}
  130. }
  131. int main()
  132. {
  133. 	//创建圆
  134. 	Circle c;
  135. 	c.setR(10);
  136. 	Point cp;
  137. 	cp.setX(10);
  138. 	cp.setY(0);
  139. 	c.setC(cp);
  140. 	//创建点
  141. 	Point p1,p2,p3;
  142. 	p1.setX(10);
  143. 	p1.setY(9);
  144. 	p2.setX(10);
  145. 	p2.setY(10);
  146. 	p3.setX(10);
  147. 	p3.setY(11);
  148. 	isInCircle(c, p1);
  149. 	isInCircle(c, p2);
  150. 	isInCircle(c, p3);
  151. 	system("pause");//按任意键继续
  152. 	return 0;
  153. }

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

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

  

闽ICP备14008679号