• C++学习寄录（八.继承）

    继承的语法：`class 子类 : 继承方式 父类`

    class A : public B;

    A 类称为子类 或 派生类

    B 类称为父类 或 基类

    1.基本使用

    未使用继承的代码比较冗余重复

    1. #include <iostream>
    2. #include <fstream>
    3. #include <string>
    4. #include <chrono>
    5. #include <ctime>
    6. #include <thread>
    7.  
    8. using namespace std;
    9.  
    10. //Java页面
    11. class Java 
    12. {
    13. public:
    14. 	void header()
    15. 	{
    16. 		std::cout << "首页、公开课、登录、注册...（公共头部）" << std::endl;
    17. 	}
    18. 	void footer()
    19. 	{
    20. 		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    21. 	}
    22. 	void left()
    23. 	{
    24. 		cout << "Java,Python,C++...(公共分类列表)" << endl;
    25. 	}
    26. 	void content()
    27. 	{
    28. 		cout << "JAVA学科视频" << endl;
    29. 	}
    30. };
    31. //Python页面
    32. class Python
    33. {
    34. public:
    35. 	void header()
    36. 	{
    37. 		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
    38. 	}
    39. 	void footer()
    40. 	{
    41. 		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    42. 	}
    43. 	void left()
    44. 	{
    45. 		cout << "Java,Python,C++...(公共分类列表)" << endl;
    46. 	}
    47. 	void content()
    48. 	{
    49. 		cout << "Python学科视频" << endl;
    50. 	}
    51. };
    52. //C++页面
    53. class CPP 
    54. {
    55. public:
    56. 	void header()
    57. 	{
    58. 		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
    59. 	}
    60. 	void footer()
    61. 	{
    62. 		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    63. 	}
    64. 	void left()
    65. 	{
    66. 		cout << "Java,Python,C++...(公共分类列表)" << endl;
    67. 	}
    68. 	void content()
    69. 	{
    70. 		cout << "C++学科视频" << endl;
    71. 	}
    72. };
    73.  
    74. void test01()
    75. {
    76. 	//Java页面
    77. 	cout << "Java下载视频页面如下： " << endl;
    78. 	Java ja;
    79. 	ja.header();
    80. 	ja.footer();
    81. 	ja.left();
    82. 	ja.content();
    83. 	cout << "--------------------" << endl;
    84.  
    85. 	//Python页面
    86. 	cout << "Python下载视频页面如下： " << endl;
    87. 	Python py;
    88. 	py.header();
    89. 	py.footer();
    90. 	py.left();
    91. 	py.content();
    92. 	cout << "--------------------" << endl;
    93.  
    94. 	//C++页面
    95. 	cout << "C++下载视频页面如下： " << endl;
    96. 	CPP cp;
    97. 	cp.header();
    98. 	cp.footer();
    99. 	cp.left();
    100. 	cp.content();
    101.  
    102. }
    103.  
    104. int main() {
    105.  
    106. 	test01();
    107. 	return 0;
    108. }
    109.  
    110.  
    111.  
    112.  
    113.

    使用继承后

    1. #include <iostream>
    2. #include <fstream>
    3. #include <string>
    4. #include <chrono>
    5. #include <ctime>
    6. #include <thread>
    7.  
    8. using namespace std;
    9.  
    10. //公共页面
    11. class BasePage
    12. {
    13. public:
    14. 	void header()
    15. 	{
    16. 		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
    17. 	}
    18.  
    19. 	void footer()
    20. 	{
    21. 		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    22. 	}
    23. 	void left()
    24. 	{
    25. 		cout << "Java,Python,C++...(公共分类列表)" << endl;
    26. 	}
    27.  
    28. };
    29.  
    30. //Java页面
    31. class Java : public BasePage
    32. {
    33. public:
    34. 	void content()
    35. 	{
    36. 		cout << "JAVA学科视频" << endl;
    37. 	}
    38. };
    39. //Python页面
    40. class Python : public BasePage
    41. {
    42. public:
    43. 	void content()
    44. 	{
    45. 		cout << "Python学科视频" << endl;
    46. 	}
    47. };
    48. //C++页面
    49. class CPP : public BasePage
    50. {
    51. public:
    52. 	void content()
    53. 	{
    54. 		cout << "C++学科视频" << endl;
    55. 	}
    56. };
    57.  
    58. void test01()
    59. {
    60. 	//Java页面
    61. 	cout << "Java下载视频页面如下： " << endl;
    62. 	Java ja;
    63. 	ja.header();
    64. 	ja.footer();
    65. 	ja.left();
    66. 	ja.content();
    67. 	cout << "--------------------" << endl;
    68.  
    69. 	//Python页面
    70. 	cout << "Python下载视频页面如下： " << endl;
    71. 	Python py;
    72. 	py.header();
    73. 	py.footer();
    74. 	py.left();
    75. 	py.content();
    76. 	cout << "--------------------" << endl;
    77.  
    78. 	//C++页面
    79. 	cout << "C++下载视频页面如下： " << endl;
    80. 	CPP cp;
    81. 	cp.header();
    82. 	cp.footer();
    83. 	cp.left();
    84. 	cp.content();
    85.  
    86.  
    87. }
    88.  
    89. int main() {
    90.  
    91. 	test01();
    92. 	return 0;
    93. }
    94.  
    95.  
    96.  
    97.  
    98.

    继承方式

     2.继承中构造和析构顺序

    子类继承父类后，当创建子类对象，也会调用父类的构造函数

    问题：父类和子类的构造和析构顺序是谁先谁后？

    答：继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

    代码如下

    1. #include <iostream>
    2. #include <fstream>
    3. #include <string>
    4. #include <chrono>
    5. #include <ctime>
    6. #include <thread>
    7.  
    8. using namespace std;
    9.  
    10. class Base 
    11. {
    12. public:
    13. 	Base()
    14. 	{
    15. 		cout << "Base构造函数!" << endl;
    16. 	}
    17. 	~Base()
    18. 	{
    19. 		cout << "Base析构函数!" << endl;
    20. 	}
    21. };
    22.  
    23. class Son : public Base
    24. {
    25. public:
    26. 	Son()
    27. 	{
    28. 		cout << "Son构造函数!" << endl;
    29. 	}
    30. 	~Son()
    31. 	{
    32. 		cout << "Son析构函数!" << endl;
    33. 	}
    34.  
    35. };
    36.  
    37. int main() {
    38.  
    39. 	//继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
    40. 	Son s;
    41. 	return 0;
    42. }
    43.  
    44.  
    45.  
    46.  
    47.

    输出为：

    Base构造函数!
    Son构造函数!
    Son析构函数!
    Base析构函数!

    3.继承同名成员处理方式

    当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

    * 访问子类同名成员 直接访问即可

    * 访问父类同名成员 需要加作用域

    代码如下

    1. #include <iostream>
    2. #include <fstream>
    3. #include <string>
    4. #include <chrono>
    5. #include <ctime>
    6. #include <thread>
    7.  
    8. using namespace std;
    9.  
    10. class Base {
    11. public:
    12. 	Base()
    13. 	{
    14. 		m_A = 100;
    15. 	}
    16.  
    17. 	void func()
    18. 	{
    19. 		cout << "Base - func()调用" << endl;
    20. 	}
    21.  
    22. 	void func(int a)
    23. 	{
    24. 		cout << "Base - func(int a)调用" << endl;
    25. 	}
    26.  
    27. public:
    28. 	int m_A;
    29. };
    30.  
    31.  
    32. class Son : public Base {
    33. public:
    34. 	Son()
    35. 	{
    36. 		m_A = 200;
    37. 	}
    38.  
    39. 	//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
    40. 	//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
    41. 	void func()
    42. 	{
    43. 		cout << "Son - func()调用" << endl;
    44. 	}
    45. public:
    46. 	int m_A;
    47. };
    48.  
    49. int main() {
    50.  
    51. 	Son s;
    52.  
    53. 	cout << "Son下的m_A = " << s.m_A << endl;
    54. 	cout << "Base下的m_A = " << s.Base::m_A << endl;
    55.  
    56. 	s.func();
    57. 	s.Base::func();
    58. 	s.Base::func(10);
    59.  
    60. 	return 0;
    61. }
    62.  
    63.  
    64.  
    65.  
    66.

    输出为

    Son下的m_A = 200
    Base下的m_A = 100
    Son - func()调用
    Base - func()调用
    Base - func(int a)调用

    总结：

    1. 子类对象可以直接访问到子类中同名成员

    2. 子类对象加作用域可以访问到父类同名成员

    3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

    4.继承同名静态成员处理方式

    问题：继承中同名的静态成员在子类对象上如何进行访问？

    静态成员和非静态成员出现同名，处理方式一致

    - 访问子类同名成员 直接访问即可

    - 访问父类同名成员 需要加作用域

    代码

    1. #include <iostream>
    2. #include <fstream>
    3. #include <string>
    4. #include <chrono>
    5. #include <ctime>
    6. #include <thread>
    7.  
    8. using namespace std;
    9.  
    10. class Base {
    11. public:
    12. 	static void func()
    13. 	{
    14. 		cout << "Base - static void func()" << endl;
    15. 	}
    16. 	static void func(int a)
    17. 	{
    18. 		cout << "Base - static void func(int a)" << endl;
    19. 	}
    20.  
    21. 	static int m_A;
    22. };
    23.  
    24. int Base::m_A = 100;
    25.  
    26. class Son : public Base {
    27. public:
    28. 	static void func()
    29. 	{
    30. 		cout << "Son - static void func()" << endl;
    31. 	}
    32. 	static int m_A;
    33. };
    34.  
    35. int Son::m_A = 200;
    36.  
    37. //同名成员属性
    38. void test01()
    39. {
    40. 	//通过对象访问
    41. 	cout << "通过对象访问： " << endl;
    42. 	Son s;
    43. 	cout << "Son  下 m_A = " << s.m_A << endl;
    44. 	cout << "Base 下 m_A = " << s.Base::m_A << endl;
    45.  
    46. 	//通过类名访问
    47. 	cout << "通过类名访问： " << endl;
    48. 	cout << "Son  下 m_A = " << Son::m_A << endl;
    49. 	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
    50. }
    51.  
    52. //同名成员函数
    53. void test02()
    54. {
    55. 	//通过对象访问
    56. 	cout << "通过对象访问： " << endl;
    57. 	Son s;
    58. 	s.func();
    59. 	s.Base::func();
    60.  
    61. 	cout << "通过类名访问： " << endl;
    62. 	Son::func();
    63. 	Son::Base::func();
    64. 	//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
    65. 	Son::Base::func(100);
    66. }
    67. int main() {
    68.  
    69. 	test01();
    70. 	// test02();
    71.  
    72. 	system("pause");
    73.  
    74. 	return 0;
    75. }
    76.  
    77.  
    78.  
    79.  
    80.

    输出为：

    通过对象访问： 
    Son  下 m_A = 200
    Base 下 m_A = 100
    通过类名访问： 
    Son  下 m_A = 200
    Base 下 m_A = 100
    sh: 1: pause: not found

    总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

    5.多继承语法

    语法：` class 子类 ：继承方式 父类1 ， 继承方式 父类2...`

    多继承可能会引发父类中有同名成员出现，需要加作用域区分

    1. #include <iostream>
    2. #include <fstream>
    3. #include <string>
    4. #include <chrono>
    5. #include <ctime>
    6. #include <thread>
    7.  
    8. using namespace std;
    9.  
    10. class Base1 {
    11. public:
    12. 	Base1()
    13. 	{
    14. 		m_A = 100;
    15. 	}
    16. public:
    17. 	int m_A;
    18. };
    19.  
    20. class Base2 {
    21. public:
    22. 	Base2()
    23. 	{
    24. 		m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确
    25. 	}
    26. public:
    27. 	int m_A;
    28. };
    29.  
    30. //语法：class 子类：继承方式 父类1 ，继承方式 父类2 
    31. class Son : public Base2, public Base1 
    32. {
    33. public:
    34. 	Son()
    35. 	{
    36. 		m_C = 300;
    37. 		m_D = 400;
    38. 	}
    39. public:
    40. 	int m_C;
    41. 	int m_D;
    42. };
    43.  
    44.  
    45. //多继承容易产生成员同名的情况
    46. //通过使用类名作用域可以区分调用哪一个基类的成员
    47. void test01()
    48. {
    49. 	Son s;
    50. 	cout << "sizeof Son = " << sizeof(s) << endl;
    51. 	cout << s.Base1::m_A << endl;
    52. 	cout << s.Base2::m_A << endl;
    53. }
    54.  
    55. int main() {
    56.  
    57. 	test01();
    58.  
    59. 	return 0;
    60. }
    61.  
    62.  
    63.  
    64.  
    65.

    输出为：

    sizeof Son = 16
    100
    200

    总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域

  • 相关阅读:
    机器人制作开源方案 | 家庭清扫拾物机器人
    题解_notion(持续更新ing)
    记mapboxGL实现鼠标经过高亮时的一个问题
    一个基于RedisTemplate静态工具类
    element plus封装el-select添加后缀图标并添加远程搜索和对话框功能
    V2X应用 汇总
    【路径规划-PRM路径规划】基于RRT算法避障路径规划附完整matlab代码
    Web3.0简介
    GAN Step By Step -- Step2 GAN的详细介绍及其应用
    MySQL八股文背诵版
  • 原文地址：https://blog.csdn.net/qq_46454669/article/details/134699485