• 黑马程序员C++类和对象【6】—— 继承（一文万字带你搞懂C++继承 —— 你还不知道怎么学C++继承吗？不知道虚继承底层原理吗？）

    目录

    😎继承的基本语法

    普通实现：

    继承实现：

     总结：

    派生类中的成员，包含两大部分：

    😎继承方式 

    继承方式一共有三种：

    示例：

     😎继承中的对象模型

    通过工具验证：

    结论：

     😎继承中构造和析构顺序

    问题：

    总结：

    😎继承同名成员处理方式

    问题：

    总结：

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

    问题：

    示例：

    总结： 

    😎多继承语法

    语法：

    示例：

     总结：

    😎菱形继承（C++特色） 

    菱形继承概念：

    典型的菱形继承案例（草泥马）：

    菱形继承问题：

    菱形继承的问题二： 

    总结：

    虚继承解决菱形继承问题的底层原理图解：

     结语：

            博客制作不易，画图有点费眼，要是觉得博客对您有帮助，请一键三连嗷！

                                                                                                          —— By CSDN码雨

     

    继承是面向对象三大特性之一

    有些类与类之间存在特殊的关系，例如下图中：

     我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

    这个时候我们就可以考虑利用继承的技术，减少重复代码。

    😎继承的基本语法

    例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同

    接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处

    普通实现：

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

    如上面代码所示：程序中出现了大量重复的代码。我们现在就需要想办法解决这个问题。

    继承实现：

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

     总结：

    继承的好处：可以减少重复的代码

    class A : public B;

    A 类称为子类 或 派生类

    B 类称为父类 或 基类

    派生类中的成员，包含两大部分：

    一类是从基类继承过来的，一类是自己增加的成员。

    从基类继承过过来的表现其共性，而新增的成员体现了其个性。

    😎继承方式 

    根据上面的过程我们已经知道了继承的语法：class 子类 : 继承方式 父类

    继承方式一共有三种：

    • 公共继承
    • 保护继承
    • 私有继承

     父类里面private的内容，子类不管哪种方式继承都拿不到。

    如果是公有继承：那么父类除私有外，其他的都是原来的权限不变。

    如果是保护继承：除私有外都变为了protected保护权限。

    如果是私有继承：除父类私有的以外，其他的都变成了private私有权限。

    示例：

    1. class Base1
    2. {
    3. public: 
    4. 	int m_A;
    5. protected:
    6. 	int m_B;
    7. private:
    8. 	int m_C;
    9. };
    10.  
    11. //公共继承
    12. class Son1 :public Base1
    13. {
    14. public:
    15. 	void func()
    16. 	{
    17. 		m_A; //可访问 public权限
    18. 		m_B; //可访问 protected权限
    19. 		//m_C; //不可访问父类的私有权限
    20. 	}
    21. };
    22.  
    23. void myClass()
    24. {
    25. 	Son1 s1;
    26. 	s1.m_A; //其他类只能访问到公共权限
    27.     //s1.m_B;//到子类Son1中，m_B变成了保护权限，类外访问不到。
    28. }
    29.  
    30. //保护继承
    31. class Base2
    32. {
    33. public:
    34. 	int m_A;
    35. protected:
    36. 	int m_B;
    37. private:
    38. 	int m_C;
    39. };
    40.  
    41. class Son2:protected Base2
    42. {
    43. public:
    44. 	void func()
    45. 	{
    46. 		m_A; //可访问 protected权限
    47. 		m_B; //可访问 protected权限
    48. 		//m_C; //不可访问
    49. 	}
    50. };
    51. void myClass2()
    52. {
    53. 	Son2 s;
    54. 	//s.m_A; //不可访问，保护继承，父类的公有属性来到Son2中变为保护权限，类外访问不到
    55.  
    56. //私有继承
    57. class Base3
    58. {
    59. public:
    60. 	int m_A;
    61. protected:
    62. 	int m_B;
    63. private:
    64. 	int m_C;
    65. };
    66. class Son3:private Base3
    67. {
    68. public:
    69. 	void func()
    70. 	{
    71. 		m_A; //可访问 private权限
    72. 		m_B; //可访问 private权限
    73. 		//m_C; //不可访问
    74. 	}
    75. };
    76. class GrandSon3 :public Son3
    77. {
    78. public:
    79. 	void func()
    80. 	{
    81. 		//Son3是私有继承，所以继承Son3的属性（私有权限）在GrandSon3中都无法访问到
    82. 		//m_A;
    83. 		//m_B;
    84. 		//m_C;
    85. 	}
    86. };

    回顾一下继承方式不同，子类权限的表示：

    首先，对于父类而言，父类中隐私的东西，子类不管什么方式继承都无法访问；

    如果是公共继承，父类中的公有和保护属性的访问权限没有变化，如果是保护继承，公有和保护权限变成了保护，如果是私有继承，这两个权限就都变成了私有。

     😎继承中的对象模型

    问题：从父类继承过来的成员，哪些属于子类对象中？

    1. class Base
    2. {
    3. public:
    4. 	int m_A;
    5. protected:
    6. 	int m_B;
    7. private:
    8. 	int m_C; //私有成员只是被隐藏了，但是还是会继承下去
    9. };
    10.  
    11. //公共继承
    12. class Son :public Base
    13. {
    14. public:
    15. 	int m_D;
    16. };
    17.  
    18. void test01()
    19. {
    20.     //16
    21.     //父类中所有非静态成员属性都会被子类继承下去
    22.     //父类中私有成员属性 是被编译器给隐藏了，因此是访问不到的，但是确实是被继承了
    23. 	cout << "sizeof Son = " << sizeof(Son) << endl;
    24. }
    25.  
    26. int main() {
    27.  
    28. 	test01();
    29.  
    30. 	system("pause");
    31.  
    32. 	return 0;
    33. }

    通过工具验证：

    打开开发人员命令提示符工具。

     如何找到文件位置，复制，然后在工具里面跳转到项目文件所在盘，“cd 文件路径”，跳转之后再输入dir，定位到当前CPP文件的盘符

    然后输入： cl /d1 reportSingleClassLayout查看的类名 所属文件名

    上面一串英文的意思就是报告单个类的布局。

    结论：

            父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

     😎继承中构造和析构顺序

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

    问题：

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

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

    说明是先构造父类，再子类，析构相反

    总结：

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

    😎继承同名成员处理方式

    问题：

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

    • 访问子类同名成员 直接访问即可（就近原则，正常访问的是子类的）
    • 访问父类同名成员 需要加作用域
    1. class Base {
    2. public:
    3. 	Base()
    4. 	{
    5. 		m_A = 100;
    6. 	}
    7.  
    8. 	void func()
    9. 	{
    10. 		cout << "Base - func()调用" << endl;
    11. 	}
    12.  
    13. 	void func(int a)
    14. 	{
    15. 		cout << "Base - func(int a)调用" << endl;
    16. 	}
    17.  
    18. public:
    19. 	int m_A;
    20. };
    21.  
    22.  
    23. class Son : public Base {
    24. public:
    25. 	Son()
    26. 	{
    27. 		m_A = 200;
    28. 	}
    29.  
    30. 	//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
    31. 	void func()
    32. 	{
    33. 		cout << "Son - func()调用" << endl;
    34. 	}
    35. public:
    36. 	int m_A;
    37. };
    38.  
    39. void test01()
    40. {
    41. 	Son s;
    42.  
    43. 	cout << "Son下的m_A = " << s.m_A << endl;
    44. 	cout << "Base下的m_A = " << s.Base::m_A << endl;
    45.  
    46. 	s.func();
    47. 	s.Base::func();
    48.  
    49. 	//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数（只要是func的全部隐藏，不能直接访问）,想要访问只能加作用域。
    50.     s.func(100);    //报错
    51. 	s.Base::func(10);
    52.  
    53. }
    54. int main() {
    55.  
    56. 	test01();
    57.  
    58. 	system("pause");
    59. 	return EXIT_SUCCESS;
    60. }

    总结：

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

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

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

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

    问题：

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

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

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

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

    示例：

    1. class Base {
    2. public:
    3. 	static void func()
    4. 	{
    5. 		cout << "Base - static void func()" << endl;
    6. 	}
    7. 	static void func(int a)
    8. 	{
    9. 		cout << "Base - static void func(int a)" << endl;
    10. 	}
    11. 	//静态成员属性（编译阶段分配到内存，所有对象共享同一份数据）
    12. 	static int m_A;
    13. };
    14. //类内声明，类外初始化
    15. int Base::m_A = 100;
    16.  
    17. class Son : public Base {
    18. public:
    19. 	static void func()
    20. 	{
    21. 		cout << "Son - static void func()" << endl;
    22. 	}
    23. 	static int m_A;
    24. };
    25.  
    26. int Son::m_A = 200;
    27.  
    28. //同名成员属性
    29. void test01()
    30. {
    31. 	//通过对象访问
    32. 	cout << "通过对象访问： " << endl;
    33. 	Son s;
    34. 	cout << "Son  下 m_A = " << s.m_A << endl;
    35. 	cout << "Base 下 m_A = " << s.Base::m_A << endl;
    36.  
    37. 	//通过类名访问（静态成员变量专属福利）
    38. 	cout << "通过类名访问： " << endl;
    39. 	cout << "Son  下 m_A = " << Son::m_A << endl;
    40.     //第一个::代表通过类目方式访问,第二个::代表访问父类作用域下
    41. 	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
    42. }
    43.  
    44. //同名成员函数
    45. void test02()
    46. {
    47. 	//通过对象访问
    48. 	cout << "通过对象访问： " << endl;
    49. 	Son s;
    50. 	s.func();
    51. 	s.Base::func();
    52.  
    53. 	cout << "通过类名访问： " << endl;
    54. 	Son::func();
    55. 	Son::Base::func();
    56. 	//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
    57. 	Son::Base::func(100);
    58. }
    59. int main() {
    60.  
    61. 	//test01();
    62. 	test02();
    63.  
    64. 	system("pause");
    65.  
    66. 	return 0;
    67. }

    总结： 

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

    😎多继承语法

    C++允许一个类继承多个类

    语法：

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

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

            C++实际开发中不建议用多继承

    示例：

    1. class Base1 {
    2. public:
    3. 	Base1()
    4. 	{
    5. 		m_A = 100;
    6. 	}
    7. public:
    8. 	int m_A;
    9. };
    10.  
    11. class Base2 {
    12. public:
    13. 	Base2()
    14. 	{
    15. 		m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确
    16. 	}
    17. public:
    18. 	int m_A;
    19. };
    20.  
    21. //子类需要继承Base1和Base2
    22. //语法：class 子类：继承方式 父类1 ，继承方式 父类2 …
    23. class Son : public Base2, public Base1 
    24. {
    25. public:
    26. 	Son()
    27. 	{
    28. 		m_C = 300;
    29. 		m_D = 400;
    30. 	}
    31. public:
    32. 	int m_C;
    33. 	int m_D;
    34. };
    35.  
    36.  
    37. //多继承容易产生成员同名的情况
    38. //通过使用类名作用域可以区分调用哪一个基类的成员
    39. void test01()
    40. {
    41. 	Son s;
    42.     //16    也可以使用开发者工具验证（前面已经说了）
    43. 	cout << "sizeof Son = " << sizeof(s) << endl;
    44.  
    45.     //当父类中出现同名成员，需要加作用域区分
    46. 	cout << s.Base1::m_A << endl;
    47. 	cout << s.Base2::m_A << endl;
    48. }
    49.  
    50. int main() {
    51.  
    52. 	test01();
    53.  
    54. 	system("pause");
    55.  
    56. 	return 0;
    57. }

    sizeof的结果： 

     

     总结：

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

    😎菱形继承（C++特色） 

    菱形继承概念：

            两个派生类继承同一个基类

            又有某个类同时继承者两个派生类

            这种继承被称为菱形继承，或者钻石继承

    典型的菱形继承案例（草泥马）：

     

    菱形继承问题：

    1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。

    2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

    1. //动物类
    2. class Animal
    3. {
    4. public:
    5. 	int m_Age;
    6. };
    7.  
    8. //利用虚继承，解决菱形继承问题。
    9. //继承前加virtual关键字后，变为虚继承
    10. //此时公共的父类Animal称为虚基类
    11. class Sheep : virtual public Animal {};        //羊类
    12. class Tuo   : virtual public Animal {};        //驼类
    13. class SheepTuo : public Sheep, public Tuo {};  //羊驼类
    14.  
    15. void test01()
    16. {
    17. 	SheepTuo st;
    18.  
    19. 	st.Sheep::m_Age = 10;
    20. 	st.Tuo::m_Age = 20;
    21.  
    22.     //当出现菱形继承的时候，两个父类拥有系统数据，需要加以作用域区分
    23. 	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
    24. 	cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
    25.  
    26.     //这份数据我们知道，只要有一份就行了，菱形继承导致数据有两份，资源浪费。
    27. 	cout << "st.m_Age = " << st.m_Age << endl;
    28. }
    29.  
    30.  
    31. int main() {
    32.  
    33. 	test01();
    34.  
    35. 	system("pause");
    36.  
    37. 	return 0;
    38. }

    菱形继承的问题二： 

    加virtual虚继承之前：

    利用虚继承，解决菱形继承的问题。

    总结：

    • 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义

    • 利用虚继承可以解决菱形继承问题

    虚继承解决菱形继承问题的底层原理图解：

                                            虚继承解决菱形继承问题的底层剖析                      —— By CSDN码雨

     

     

     

     结语：

            博客制作不易，画图有点费眼，要是觉得博客对您有帮助，请一键三连嗷！

                                                                                                          —— By CSDN码雨

  • 相关阅读:
    Jquery 老项目引入vue,elementui
    《杂七杂八》：Linux（Kali）终端快捷键
    技术分享 | MySQL Shell 定制化部署 MySQL 实例
    （附源码）基于Springboot智慧园区管理系统-计算机毕设 88160
    计算机毕业设计（附源码）python众筹平台
    使用openssl工具生成CSR文件
    [翻译] 使用 TensorFlow 进行分布式训练
    图文带你彻底弄懂MySQL事务原子性之UndoLog
    Ajax：异步的 JavaScript 和 XML
    【服务器 | 宝塔】宝塔面板卸载重装教程：清理删除宝塔面板并重新开始
  • 原文地址：https://blog.csdn.net/m0_62853489/article/details/127639391