一、继承的基本语法

class 子类 : 继承方式父类

子类也称为派生类
父类也成为基类

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

一类是从基类继承过来的
一类是自己增加的成员
注：从基类继承过来的表现其共性，而增加的成员体现了其个性。

二、继承的方式

继承方式一共有三种

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

注：父类中私有成员不论是何种继承，均不可访问

#include <iostream>
using namespace std;
// 公共继承
class Base1
{
public:
      int m_a;
protected:
      int m_b;
private:
      int m_c;
};
class Son1 : public Base1
{
public:
      void func()
      {
            m_a = 10; // 父类中的公共权限成员，到子类中依然是公共权限
            m_b = 10; // 父类中的保护权限成员，到子类中依然是保护权限
      }
};
void test01()
{
      Son1 s1;
      s1.m_a = 100; //公共权限类内类外皆可以访问
}


// 保护继承
class Base2
{
public:
      int m_a;
protected:
      int m_b;
private:
      int m_c;
};
class Son2 : protected Base2
{
public:
      void func()
      {
            m_a = 10; // 父类中的公共权限成员，到子类中依然是保护权限
            m_b = 10; // 父类中的保护权限成员，到子类中依然是保护权限
      }
};

void test02()
{
      Son2 s1;
   // s1.m_a = 100; //在 Son2 中 m_a 变为保护权限，因此类外访问不到
}


// 私有继承
class Base3
{
public:
      int m_a;
protected:
      int m_b;
private:
      int m_c;
};
class Son3 : private Base3
{
public:
      void func()
      {
            m_a = 10; // 父类中的公共权限成员，到子类中依然是私有权限
            m_b = 10; // 父类中的保护权限成员，到子类中依然是私有权限
      }
};
class GrandSon3 : public Son3
{
public:
      void func()
      {
        //  m_a = 100; //到了 Son3 中 m_a 变为私有，即使是儿子，也访问不到
      }
};
void test03()
{
      Son3 s1;
   // s1.m_a = 100; //在 Son2 中 m_a 变为私有权限，因此类外访问不到
}
int main()
{
      test01();
      test02();      
      test03();
      system("pause");
      return 0;
}

三、继承中的对象模型

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

在父类中所有非静态成员属性都会被子类继承下去
父类中的私有成员属性是被编译器隐藏了，因此是访问不到的，但是确实被继承下去了

#include <iostream>
using namespace std;

class Base
{
public:
      int m_A;
protected:
      int m_B;
private:
      int m_C;
};
class Son : public Base
{
public:
      int m_D;
};
void test01()
{
      cout <<"size of Son = " << sizeof(Son) << endl;  //j结果为 16
}

注：可以利用开发人员命令提示符来查看单个类的分布图

首先跳转盼复
跳转文件路径 cd 具体路径
查看命名
c1 / d1 reporSingleClassLayout类名文件名称

四、继承中构造和析构顺序 —————> 先进后出

子类继承父类后，当创建子类对象，也会调用父类的构造函数
问题：子类与父类的构造和析构顺序是谁先谁后？

#include <iostream>
using namespace std;
class Base
{
public:
      Base()
      {
            cout << "Base 构造函数" << endl;
      }
      ~Base()
      {
            cout << "Base 析构函数" << endl;
      }
};
class Son : public Base
{
public:
      Son()
      {
            cout << "Son 构造函数" << endl;
      }
      ~Son()
      {
            cout << "Son 析构函数" << endl;
      }
};
void test01()
{
      Son s;
      //继承中的构造和析构顺序如下：
      // 先构造父类，在构造子类，析构的顺序与构造的顺序相反
}
int main()
{
      test01();
      system("pause");
      return 0;
}