• 继承是面向对象的三大特性之一
  • 有些类与类之间存在特殊的关系，我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。这个时候我们就可以考虑利用继承的技术了，减少重复代码。

    继承的基本语法

    例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同
    接下来我们分别利用普通写法和继承写法来实现网页中的内容，看一下继承存在的意义以及好处
  1. #include <iostream>
  2. using namespace std;
  4. // 基础页面
  5. class BasePage {
  6. public:
  7.     void header() {
  8.         cout << "头部" << endl;
  9.     }
  10.     void footer() {
  11.         cout << "底部" << endl;
  12.     }
  13.     void aside() {
  14.         cout << "侧部" << endl;
  15.     }
  16. };
  17. // 继承的好处：减少重复代码
  18. // 语法：class 子类 : 继承方式 父类
  19. // 子类  也称为  派生类
  20. // 父类  也称为  基类
  22. // Java页面
  23. class Java :public BasePage {
  24. public:
  25.     void content() {
  26.         cout << "Java学科视频" << endl;
  27.     }
  28. };
  29. // Python页面
  30. class Python :public BasePage {
  31. public:
  32.     void content() {
  33.         cout << "Python学科视频" << endl;
  34.     }
  35. };
  36. // C++页面
  37. class CPP : public BasePage {
  38. public:
  39.     void content() {
  40.         cout << "C++学科视频" << endl;
  41.     }
  42. };
  44. void test01() {
  45.     Java ja;
  46.     ja.header();
  47.     ja.aside();
  48.     ja.content();
  49.     ja.footer();
  50.     Python py;
  51.     py.header();
  52.     py.aside();
  53.     py.content();
  54.     py.footer();
  55.     CPP cpp;
  56.     cpp.header();
  57.     cpp.aside();
  58.     cpp.content();
  59.     cpp.footer();
  60. }
  61. int main(void) {
  62.     test01();
  64.     return 0;
  65. }

总结：

继承的好处：可以减少重复代码
class A : public B;
A类称为子类 或 派生类
B 类称为父类 或 基类

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

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

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

继承方式

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

继承方式一共有三种：（父类私有成员，子类无法继承）

  • 公共继承，原来父类除了私有成员的其他成员权限不变
  • 保护继承，public变为protected
  • 私有继承，public和protected变为private
  1. #include <iostream>
  2. using namespace std;
  4. // 继承方式
  6. // 公共继承
  7. class Base1 {
  8. public:
  9.     int m_A;
  10. protected:
  11.     int m_B;
  12. private:
  13.     int m_C;
  14. };
  16. class Son1 : public Base1 {
  17. public:
  18.     void func() {
  19.         m_A = 10; // 父类中的公共权限成员，到子类中依然是公共权限
  20.         m_B = 10; // 父类中的保护权限成员，到子类中依然是保护权限
  21.         // m_C = 10; // 父类中的私有权限成员，子类访问不到
  22.     }
  23. };
  25. void test01() {
  26.     Son1 s;
  27.     s.func();
  28.     cout << "m_A = " << s.m_A << endl;
  29.     //cout << "m_B = " << s.m_B << endl; 错误，m_B是保护权限，无法访问
  30. }
  32. // 保护继承
  33. class Son2 : protected Base1 {
  34. public:
  35.     void func() {
  36.         m_A = 10; // 父类中的公共权限成员，到子类中是保护权限
  37.         m_B = 20; // 父类中的保护权限成员，到子类中依然是保护权限
  38.     }
  39. };
  40. void test02() {
  41.     Son2 s;
  42.     s.func();
  43.     //cout << "m_A = " << s.m_A << endl;   保护权限无法访问
  44.     //cout << "m_B = " << s.m_B << endl;   保护权限无法访问
  45. }
  47. // 私有继承
  48. class Son3 : private Base1 {
  49. public:
  50.     void func() {
  51.         m_A = 10; // 父类中的公共权限成员，到子类中变成私有权限
  52.         m_B = 20; // 父类中的保护权限成员，到子类中变成也私有权限
  53.     }
  54. };
  56. class GrandSon3 : public Son3 {
  57.     void func() {
  58.         //m_A = 100; // 到了Son3中，m_A变为了私有成员，即使是儿子，也是访问不到的
  59.         //m_b = 100; // 到了Son3中，m_B变为了私有成员，即使是儿子，也是访问不到的
  60.     }
  61. };
  63. void test03() {
  64.     Son3 s;
  65.     s.func();
  66.     // cout << "m_A = " << s.m_A << endl;  私有权限无法访问
  67.     // cout << "m_B = " << s.m_B << endl;  私有权限无法访问
  68. }
  70. int main(void) {
  71.     test01();
  72.     test02();
  73.     test03();
  75.     return 0;
  76. }

继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？
// 利用开发人员命令提示工具查看对象模型
// 跳转盘符 E:
// 跳转文件路径 cd 具体路径下
// 查看命令：
// cl d1 reportSingleClassLayout类名 文件名

  1. #include <iostream>
  2. using namespace std;
  4. class Base {
  5. public:
  6.     int m_A;
  7. protected:
  8.     int m_B;
  9. private:
  10.     int m_C;
  11. };
  13. class Son : public Base {
  14. public:
  15.     int m_D;
  16. };
  17. // 利用开发人员命令提示工具查看对象模型
  18. // 跳转盘符  E:
  19. // 跳转文件路径  cd 具体路径下
  20. // 查看命令：
  21. //   cl d1 reportSingleClassLayout类名 文件名
  23. void test01() {
  24.     // 16
  25.     // 父类中所有非静态成员属性都会被子类继承下去
  26.     // 父类中私有成员属性 是被编译器给隐藏了，因此是访问不到的，但是确实被继承我去了。
  27.     cout << "size of Son = " << sizeof(Son) << endl;
  28. }
  30. int main(void) {
  31.     test01();
  33.     return 0;
  34. }

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

继承中构造和析构顺序

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

  1. #include <iostream>
  2. using namespace std;
  4. // 继承中的构造和析构顺序
  5. class Base {
  6. public:
  7.     Base() {
  8.         cout << "Base构造函数！" << endl;
  9.     }
  11.     ~Base() {
  12.         cout << "Base析构函数！" << endl;
  13.     }
  14. };
  16. class Son : public Base {
  17. public:
  18.     Son() {
  19.         cout << "Son构造函数！" << endl;
  20.     }
  22.     ~Son() {
  23.         cout << "Son析构函数！" << endl;
  24.     }
  25. };
  27. void test01() {
  28.     // 继承中的构造和析构顺序如下：
  29.     // 先构造父类，再构造子类，析构的顺序与构造的顺序相反，栈模型
  30.     Son s;
  31. }
  33. int main(void) {
  35.     test01();
  37.     return 0;
  38. }

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

继承同名成员处理方式

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

  • 访问子类同名成员，直接访问即可
  • 访问父类同名成员，需要加作用域
  1. #include <iostream>
  2. using namespace std;
  4. // 继承中同名成员的处理
  5. class Base {
  6. public:
  7.     Base() {
  8.         m_A = 100;
  9.     }
  10.     void func() {
  11.         cout << "Base - func()函数调用" << endl;
  12.     }
  13.     void func(int a) {
  14.         cout << "Base - func(int a)函数调用" << endl;
  15.     }
  16.     int m_A;
  17. };
  19. class Son : public Base {
  20. public:
  21.     Son() {
  22.         m_A = 200;
  23.     }
  24.     void func() {
  25.         cout << "Son - func()函数调用" << endl;
  26.     }
  27.     int m_A;
  28. };
  30. // 同名成员属性处理
  31. void test01() {
  32.     Son s;
  33.     cout << "Son下的 m_A = " << s.m_A << endl;
  34.     // 如果通过子类对象 访问到父类中的同名成员，需要加作用域
  35.     cout << "Base下的 m_A = " << s.Base::m_A << endl;
  36. }
  38. // 同名成员函数处理
  39. void test02() {
  40.     Son s;
  41.     s.func(); // 直接调用  调用的是子类中的同名成员
  43.     // 如何调用父类中的同名成员函数呢？
  44.     s.Base::func();
  46.     // 如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
  47.     // 如果想访问到父类中被隐藏的同名成员函数，需要加作用域
  48.     s.Base::func(100);
  49. }
  51. int main(void) {
  52.     //test01();
  53.     test02();
  55.     return 0;
  56. }

总结：

  1. 子类对象可以直接访问到子类中同名成员
  2. 子类对象加作用域可以访问到父类同名成员
  3. 当子类与父类拥有同名的成员函数时，子类会隐藏父类中所有的同名成员函数，加作用域可以访问到父类中的同名函数

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

问题：继承中同名的静态成员在子类对象上如何进行访问？
静态成员和非静态成员出现同名，处理方式一致

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域
  1. #include <iostream>
  2. using namespace std;
  3. // 继承中的同名静态成员处理方式
  4. class Base {
  5. public:
  6.     static int m_A;
  8.     static void func() {
  9.         cout << "Base - static void func()" << endl;
  10.     }
  11.     static void func(int a) {
  12.         cout << "Base - static void func(int a)" << endl;
  13.     }
  14. };
  15. // 类外初始化
  16. int Base::m_A = 100;
  18. class Son :public Base {
  19. public:
  20.     Son() {
  21.         Base::m_A = 300;
  22.     }
  23.     static int m_A;
  24.     static void func() {
  25.         cout << "Son - static void func()" << endl;
  26.     }
  27. };
  28. int Son::m_A = 200;
  30. // 同名静态成员属性
  31. void test01() {
  32.     // 通过对象访问
  33.     cout << "通过对象访问：" << endl;
  34.     Son s;
  35.     cout << "Son 下 m_A = " << s.m_A << endl;
  36.     cout << "Base 下 m_A = " << s.Base::m_A << endl;
  38.     // 通过类名访问
  39.     cout << "通过类名访问：" << endl;
  40.     cout << "Son 下 m_A = " << Son::m_A << endl;
  41.     // 第一个::代表通过类名方式访问  第二个::代表访问父类作用域下的
  42.     cout << "Base 下 m_A = " << Son::Base::m_A << endl;
  43.     cout << "Base 下 m_A = " << Base::m_A << endl;
  44. }
  45. // 同名静态成员函数
  46. void test02() {
  47.     // 1.通过对象访问
  48.     cout << "通过对象访问：" << endl;
  49.     Son s;
  50.     s.func();
  51.     s.Base::func();
  53.     // 2.通过类名访问
  54.     cout << "通过类名访问：" << endl;
  55.     Son::func();
  56.     Son::Base::func();
  58.     // 子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
  59.     // 如果想要访问父类中被隐藏同名成员，需要加作用域
  60.     Son::Base::func(10);
  61. }
  63. int main(void) {
  64.     test01();
  65.     test02();
  67.     return 0;
  68. }

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

多继承语法

C++允许一个类继承多个类
语法：class 子类 ： 继承方式 父类1, 继承方式 父类2......

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

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

  1. #include <iostream>
  2. using namespace std;
  3. // 多继承语法
  4. class Base1 {
  5. public:
  6.     Base1() {
  7.         m_A = 100;
  8.         m_E = 500;
  9.     }
  11.     int m_A;
  12.     int m_E;
  13. };
  15. class Base2 {
  16. public:
  17.     Base2() {
  18.         m_B = 100;
  19.         m_E = 600;
  20.     }
  22.     int m_B;
  23.     int m_E;
  24. };
  26. // 子类  需要继承Base1和Base2
  27. // 语法：class 子类 : 继承方式 父类1, 继承方式 父类2...
  28. class Son : public Base1, public Base2 {
  29. public:
  30.     Son() {
  31.         m_C = 300;
  32.         m_D = 400;
  33.     }
  34.     int m_C;
  35.     int m_D;
  36. };
  38. void test01() {
  39.     Son s;
  40.     cout << "m_A = " << s.m_A << endl;
  41.     cout << "m_B = " << s.m_B << endl;
  42.     cout << "m_C = " << s.m_C << endl;
  43.     cout << "m_D = " << s.m_D << endl;
  44.     // 当父类中出现同名成员，需要加入作用域区分
  45.     cout << "Base1下 m_E = " << s.Base1::m_E << endl;
  46.     cout << "Base2下 m_E = " << s.Base2::m_E << endl;
  47. }
  49. int main(void) {
  50.     test01();
  52.     return 0;
  53. }

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

菱形继承

菱形继承概念：

两个派生类继承同一个基类
又有某个类同时继承两个派生类
这种继承称为菱形继承

菱形继承问题：

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
  2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。 ```cpp

    include

    using namespace std;

// 动物类 class Animal { public: int m_Age; }; // 利用虚继承 可以解决菱形继承的问题 // 在继承之前加上关键字 virtual 变为虚继承 // Animal类称为 虚基类

// 羊类 class Sheep :virtual public Animal {

};

// 驼类 class Tuo :virtual public Animal {

};

// 羊驼类 class SheepTuo :public Sheep, public Tuo {

};

void test01() { SheepTuo st;

  1. st.Sheep::m_Age = 18;
  2. st.Tuo::m_Age = 28;
  3. // 当菱形继承，两个父类拥有相同数据，需要加以作用域区分
  4. cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
  5. cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
  6. cout << "st.m_Age = " << st.m_Age << endl;
  8. // 这份数据我们知道  只要有一份就可以，菱形继承导致数据有两份，资源浪费

}

int main() { test01();

return 0;

} ``` 总结：

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