**继承（inheritance）**机制是面向对象程序设计，使代码可以复用的最重要的手段。它允许程序员在保持原有类特性的基础上进行扩展，以增加功能。这样产生新的类，称为派生类。
继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。
以前我们接触的复用都是函数复用，而继承是类设计层次的复用。
🐛 举例： 对于一个学校来说，是有职位与身份的分明的，比如说：校长、数学老师、英语老师、学生、保安.......等等职位，如果我们想对其进行区分，我们可以设计一些类出来：
class Teacher
{
private:
string _name;
int _age;
int _Workid;
// ...
};
class Student
{
private:
string _name;
int _age;
int _Stuid;
// ...
}; 这样子确实是把这几个类设计出来的，但是可以明显发现，我们的代码是不是太过于冗余了，基本都是重复出现的！有些信息是公共的，有些信息是每个角色独有的！
这个时候我们的继承的作用就来了！有了继承，我们可以实现复用的功能，大大减少冗余！
🐛 解决方法： 我们将公共的信息放到一个 People 类中去：
// 基类
class People
{
public:
void Print()
{
cout << "name: " << _name << "age: " << _age << endl;
}
protected:
string _name = "liren";
int _age = 250;
};
/*
继承后父类的People的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和
Teacher复用了People的成员。下面我们使用监视窗口查看Student和Teacher对象，可以看到变量的复用。
调用Print可以看到成员函数的复用。
*/
// 派生类（子类）
// Teacher以public的方式继承了People
class Teacher : public People
{
// ...
private:
int _Workid = 324;
};
//派生类（子类）
// Student以public的方式继承了People
class Student : public People
{
// ...
private:
int _Stuid = 811;
};
int main()
{
People p;
p.Print();
Teacher t;
t.Print();
Student s;
s.Print();
return 0;
}🚩 运行结果：
name: liren age: 250
name: liren age: 250
name: liren age: 250 🐛 从运行结果就可以看出，**Student**类与 Teacher 类共享了他们的基类也就是 People 类的内容，并且两个子类（派生类）还能拓展出各自的其他成员函数或变量，这就是继承的作用！
Ⅱ. 继承的定义
1、继承的定义格式
派生类 继承方式 基类
👇 👇 👇
class Student : public People {
public:
int _Stuid; // 学号
}; 我们以上面为例子，People 是父类，也称为基类。而 Student 叫做子类，也称为派生类。
🔴 注意：c++ 中若不写继承方式，默认就是 private 继承！
2、访问限定符与继承关系
在学习继承方式之前，我们得将这些访问限定符了解透，他们分别是 public（公有）、private（私有）、protected（保护）。
① public 修饰的成员，在类外可以直接访问。
② protected 和 private 修饰的成员，不能在类外随便访问。
③ 定义为 protected 可以让父类成员不能在类外被直接访问，但可以在子类直接访问！
👶 注意：不可访问不代表不可继承，本质上都继承下来了，只是能不能访问到而已！
有了这些访问限定符，就有了以下的继承关系：
3、继承基类成员访问方式的变化
这里的表格的九种情况分别代表基类的成员在派生类成员当中相对的权限位置，比如基类的 protected 成员，以 private 继承，相当于派生类中的 private 成员，也就是说只能通过在子类的类内或基类的类内进行修改，其他地方是不允许访问的，其他情况也是这样子推导的。
总结：
① 父类的 private 成员在子类中无论以何种方式继承都是不可见的。 这里的不可见指的是父类的私有成员还是被继承到了子类对象中，但是语法上限制了子类对象不管在类里面还是类外都不能去访问父类的 private 成员。
② 父类 private 成员在子类种不能被访问，如果父类成员不想在类外被直接访问，但是想让它们在子类中能被访问，可定义为 protected。 不难看出，保护成员限定符是因继承才出现的。
③ 实际上，上面的表格我们通过观察不难发现，父类的私有成员在子类都是不可见的，父类的其他成员在子类的访问方式等于 Min(成员在父类的访问限定符，继承方式)：public > protected > private。
也就是说，类成员和继承方式里面的权限，取小的那个作为继承下来的对象权限！
④ 使用关键字 class 时默认的继承方式是 private，使用 struct 时默认的继承方式是 public，但是最好还是显式的写出继承方式，提高代码可读性。
⑤ 一共九种组合，实际上是大佬们早期设计的时候想复杂了，实际中父类成员基本都是保护和公有，继承方式基本都是用公有继承，几乎很少使用 protected / private 继承。 而且也不提倡使用 protected / private 继承，因为 protected / private 继承下来的成员都只能在子类里使用，实际扩展维护性不强。
🐛 以 public 继承为例：
🐛 以 private 继承为例：
Ⅲ. 父类和子类对象赋值转换
那么有了继承关系，如果我们将子类赋值给父类，这样子可以吗？
答案是可以的！子类不仅仅可以赋值给父类，还能赋给父类的指针、父类的引用！
class Person
{
public:
string _name = "liren";
int _age = 250;
int _sex;
};
// Student以public的方式继承了Person
class Student : public Person
{
private:
int _No = 911;
};
int main()
{
Student s;
// 子类对象可以赋值给父类对象/指针/引用
Person p = s;
Person* pp = &s;
Person& rp = s;
// s = p; // 父类不能赋给子类
return 0;
} 派生类对象可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这种操作我们称之为 "切割"（或切片），寓意是把子类中父类的那部分切过来赋值过去，这也称为向上转型！
📌 注意事项：
① 父类对象不能直接赋值给子类对象。
Student s; // 子类
Person p; // 父类
s = p; ❌ ② 【基类的指针】可以通过强制类型转换赋值给【派生类的指针】，这个过程称为向下转型。但必须是基类的指针转化为其所指向的派生类对象时才是安全的。（这里基类如果使用了多态机制，则可以使用 dynamic_cast 来进行识别后进行安全转换）
class Person
{
protected :
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public :
int _No ; // 学号
};
void Test ()
{
Student sobj ;
// 1. 子类对象可以赋值给父类对象/指针/引用
Person pobj = sobj ;
Person* pp = &sobj;
Person& rp = sobj;
// 2. 基类对象不能赋值给派生类对象❌
sobj = pobj;
// 3. 基类的指针可以通过强制类型转换赋值给派生类的指针
pp = &sobj;
Student* ps1 = (Student*)pp; // 这种情况转换时可以的。
ps1->_No = 10;
pp = &pobj;
Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
ps2->_No = 10;
}❓ 问题： 如果父类和子类有同名的变量，当子类给父类赋值之后，父类用的是继承的变量还是自己的变量❓❓❓
💡 解答： 有同名的变量是没有影响的，也就是说，子类如果有和父类一样的同名变量，那他就同时拥有了两个同名变量，只不过他们的作用域不一样，其实他们构成了隐藏（下面会讲），其中一个是属于子类自己的，另一个是属于他继承父类的。所以子类给父类赋值后，切割的是继承的那个同名变量，那个子类自己的同名变量是不会被赋值过去的！
Ⅳ. 继承中的作用域
-
在继承体系中**【基类】和【派生类】**都有独立的作用域。
-
子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。
💭 在子类成员函数中，可以使用如下方式进行显式访问：
基类::基类成员
🔺 注意： 成员函数在同一个类里面可以重名，此时构成了重载，而同一个类中成员变量一定不能重名！
// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected:
string _name = "liren"; // 姓名
int _num = 250; // 身份证号
};
class Student : public Person
{
public:
void Print()
{
cout << " 姓名:" << _name << endl;
cout << " 身份证号:" << Person::_num << endl;
cout << " 学号:" << _num << endl;
}
protected:
int _num = 999; // 学号
};
int main()
{
Student s1;
s1.Print();
return 0;
}
🚩 运行结果：
姓名:liren
身份证号:250
学号:999-
需要注意的是函数名相同，并且不在一个作用域中，则构成隐藏。它们不会构造重载，因为它们不在同一个作用域。（注意：如果只是函数名和参数列表、返回值都相同的话，则是构成重写，也就是覆盖，是后面多态的内容！）
// B中的fun和A中的fun不是构成重载，因为不是在同一作用域 // B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。 class A { public: void func() { cout << "func()" << endl; } }; class B : public A { public: void func(int i) { A::func(); cout << "func(int i)->" << i << endl; } }; int main() { B b; b.func(10); return 0; } 🚩 运行结果： func() func(int i)->10 💡 解读：函数重载要求在同一作用域，我们说了，子类和父类都有独立的作用域，因为不是在同一作用域，
B中的func和A中的func不可能构成重载，正确答案是构成隐藏。B中的func和A中的func构成隐藏，成员函数满足函数名相同就构成隐藏。 -
注意在实际中在继承体系里面最好不要定义同名的成员。
-
还有一种情况是析构函数中的隐藏：这个比较特殊，因为多态的一些原因，任何类的析构函数名都会被统一处理成
destructor()，这样子的话，子类的析构函数就会和父类的析构函数构成隐藏（更严谨的说是覆盖，后面多态会讲），所以在子类的析构函数中调用父类的析构函数需要指定父类的作用域。 但是一般情况下编译器会自己帮我们去调用父类的析构函数，所以无需我们在子类的析构函数中调用父类的析构函数！（后面会讲） -
假设
A是基类，B继承了A，并且他们两个都有同名的函数，这样子就构成了重定义（隐藏）。这个时候我们看如下代码：class A { public: void test(float a) { cout << a << endl; } }; class B :public A { public: void test(int b) { cout << b; } }; int main() { A* a = new B; B* b = new B; a->test(1.1); b->test(1.1); return 0; } 🚩 运行结果： 1.1 1 我们会发现，其实
a此时依然是A*类型，所以a仍然调用的是A类中的test，这与后面学的多态是不同的。
Ⅴ. 继承与友元
友元关系不能继承，也就是说父类的友元类不能访问子类私有和保护成员！这就好比你爹的朋友不一定是你的朋友！
class Student;
class Person
{
public:
friend void Display(const Person& p, const Student& s); // 父类的友元
protected:
string _name; // 姓名
};
class Student : public Person
{
protected:
int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
cout << p._name << endl;
cout << s._stuNum << endl; ❌
}
int main()
{
Person p;
Student s;
Display(p, s);
return 0;
}
🚩 运行结果：
“Student::_stuNum”: 无法访问 protected 成员(在“Student”类中声明)Ⅵ. 继承与静态成员
父类定义了 static 静态成员，则整个继承体系里面中有一个这样的成员，可以理解为共享，父类的静态成员可以在子类共享，父类和子类都能去访问它。
💅 注意：静态成员是一定不被包含在对象空间中的！
无论派生出多少个子类，都只有一个 static 成员实例：
class Person
{
public :
Person () { ++ _count ; }
protected :
string _name; // 姓名
public :
static int _count; // 统计人的个数。
};
int Person::_count = 0; // 静态成员需要在类外完成初始化
class Student : public Person
{
protected :
int _stuNum; // 学号
};
class Graduate : public Student
{
protected :
string _seminarCourse; // 研究科目
};
int main()
{
Student s1;
Student s2;
Student s3;
Graduate s4;
Person s;
cout << "大家都可以访问" << endl;
cout << "人数 : " << Person::_count << endl;
cout << "人数 : " << Student::_count << endl;
cout << "人数 : " << s4._count << endl;
cout << "大家也都可以变动" << endl;
s3._count = 0;
cout << "人数 : " << Person::_count << endl;
cout << "并且他们的地址也都是一样的，因为所有继承体系中只有一个" << endl;
cout << "人数 : " << &Person::_count << endl;
cout << "人数 : " << &Student::_count << endl;
cout << "人数 : " << &s4._count << endl;
return 0;
}
🚩 运行结果：
大家都可以访问
人数 : 5
人数 : 5
人数 : 5
大家也都可以变动
人数 : 0
并且他们的地址也都是一样的，因为所有继承体系中只有一个
人数 : 00007FF7B9710440
人数 : 00007FF7B9710440
人数 : 00007FF7B9710440 💡 解析： 这里每次定义一个子类 Student 和 Graduate，他们都会去调用父类的构造函数进行初始化（继承的构造函数的关系，下面会讲），所以每次 _count 都会加加，定义了五个后就变成了五。最后又将 _count 设为 0。最后的地址可看出他们共享一个 _count。
Ⅶ. 派生类的默认成员函数
六个默认成员函数，“ 默认 ” 的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢❓❓❓
1、派生类的构造函数
① 父类成员需调用自己的构造完成初始化。 即子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。
② 如果父类没有默认的构造函数，也就是父类有自己写的需要传值的构造函数，则必须在子类构造函数的初始化列表中显式调用，放在构造函数体内初始化也会报错。
③ 子类对象初始化先调用父类构造再调子类构造函数体初始化。
class Person
{
public:
/* 父类构造函数 */
Person(const char* name = "lirendada")
:_name(name)
{
cout << "Person()" << endl;
}
protected:
string _name;
};
class Student : public Person
{
public:
/* 子类构造函数 */
Student(const char* name, int num)
:Person(name), // 父类成员，调用父类的构造函数完成初始化
_num(num)
{
cout << "Student()" << endl;
}
protected:
int _num;
};
int main()
{
Student s("yangtong", 811);
return 0;
}
🚩 运行结果：
Person()
Student() 🔺 注意： 有个细节，就是在派生类的构造函数的初始化列表中，出现了 Person(s)，其实这个就是我们上面讲的父类与子类的对象赋值转化，这里将子类的对象 s 拿去 Person 类中拷贝构造，实际上就是切割 s 后赋值给父类，把 s 中关于 Person 类的内容切给 this 指向的对象，完成父类成员的拷贝构造！
调用父类构造函数初始化继承自父类的成员，自己再初始化自己的成员。析构、拷贝构造、赋值重载也是类似的。
**❓ 思考：**如何设计一个不能被继承的类❓❓❓
💡 方法一： 将父类的构造函数设为 private
class A
{
private:
A() {} // 将A的构造函数私有化
};
class B : public A
{
};
int main()
{
B b; //❌
return 0;
}
🚩 运行结果：
error C2280: “B::B(void)”: 尝试引用已删除的函数
message : 编译器已在此处生成“B::B”
message : “B::B(void)”: 由于基类调用已删除或不可访问的函数“A::A(void)”，因此已隐式删除函数 父类 A 的构造函数私有化后 B 就无法构造对象，因为 B 的构造函数必须要调用 A 的。
但此时好像 A 也没办法构造了：
A a; // ❌ 这波属于是自损八百了，A 也没法构造了，但是我们可以这么玩：（后期讲单例模式会细说）
class A
{
public:
static A CreateObject() // 提供一个获取对象的方式
{
return A();
}
private:
A()
{
cout << "A()" << endl;
}
};
class B : public A {};
int main()
{
A a = A::CreateObject();
return 0;
}
🚩 运行结果：
A() 此时我们提供一个获取对象的成员函数即可，这里加上 static 的目的是让函数在静态区先行生成一份，这样子就不用等到对象生成的时候访问不到！
💡 方法二： 使用 final 关键字修饰类：（**final**在多态中会讲到）
class A final
{
public:
int _a;
};
class B : public A
{};
🚩 运行结果：
error C3246: “B”: 无法从“A”继承，因为它已被声明为“final”
message : 参见“A”的声明2、派生类的拷贝构造函数
🐛 派生类的拷贝构造函数必须显式调用基类的拷贝构造完成基类的拷贝初始化。
class Person
{
public:
/* 父类构造函数 */
Person(const char* name = "lirendada")
:_name(name)
{
cout << "Person()" << endl;
}
/* 父类拷贝构造函数 */
Person(const Person& p)
:_name(p._name)
{
cout << "Constructor Person()" << endl;
}
protected:
string _name;
};
class Student : public Person
{
public:
/* 子类构造函数 */
Student(const char* name, int num)
:Person(name) // 父类成员，调用父类的构造函数完成初始化
,_num(num)
{
cout << "Student()" << endl;
}
/* 子类拷贝构造函数 */
Student(const Student& s)
:Person(s) // 子类的拷贝构造函数必须调用父类的拷贝构造完成拷贝初始化。
, _num(s._num)
{
cout << "Constructor Student()" << endl;
}
protected:
int _num;
};
int main()
{
Student s("yangtong", 811);
Student s1(s);
return 0;
}
🚩 运行结果：
Person()
Student()
Constructor Person()
Constructor Student()3、派生类的赋值运算符重载
子类的 operator= 必须要显式调用父类的 operator= 完成父类的拷贝。
class Person
{
public:
/* 父类构造函数 */
Person(const char* name = "lirendada")
:_name(name)
{
cout << "Person()" << endl;
}
/* 父类拷贝赋值运算符重载 */
Person operator=(const Person& p)
{
cout << "Person& operator=(const Person& p)" << endl;
if (this != &p)
{
_name = p._name;
}
return *this;
}
protected:
string _name;
};
class Student : public Person
{
public:
/* 子类构造函数 */
Student(const char* name, int num)
:Person(name) // 父类成员，调用父类的构造函数完成初始化
, _num(num)
{
cout << "Student()" << endl;
}
/* 子类拷贝赋值运算符重载 */
Student operator=(const Student& s)
{
cout << "Student& operator=(const Student& s)" << endl;
if (this != &s)
{
// 小心这里是隐藏，所以要强调是父类的operator=()函数
Person::operator=(s);
_num = s._num;
}
return *this;
}
protected:
int _num;
};
int main()
{
Student s("yangtong", 811);
Student s1("liren", 324);
s = s1;
return 0;
}
🚩 运行结果：
Person()
Student()
Person()
Student()
Student& operator=(const Student& s)
Person& operator=(const Person& p) 当我们在写子类的赋值重载的时候，要调用父类的赋值重载的时候，如果没有加作用域，我们就会陷入死循环，为什么❓❓❓
因为如果不显式的指明是 Person 的赋值重载，在不同的作用域里面，子类的赋值重载和父类的赋值重载形成了隐藏关系，所以默认调的是子类的赋值重载，所以陷入了死循环。
💡 解决方法： 显式的指明是调用 Person 的赋值重载，即 Person::operator=(s)；
4、派生类的析构函数
派生类的析构函数会处理完成后自动调用基类的析构函数清理基类成员。因为这样才能保证先清理派生类成员再清理基类成员的顺序（符合栈的先入后出的顺序），所以不需要我们显式调用父类的析构函数。（可以参考继承中作用域的第五点）
🔺 注意： 如果显式调用了父类的析构函数，如果父类的成员有指针且开辟了内存，那很有可能会造成二次析构内存导致程序奔溃！
class Person
{
public:
/* 父类构造函数 */
Person(const char* name = "lirendada")
:_name(name)
{
cout << "Person()" << endl;
}
/* 父类析构函数 */
~Person()
{
cout << "~Person()" << endl;
}
protected:
string _name;
};
class Student : public Person
{
public:
/* 子类构造函数 */
Student(const char* name, int num)
:Person(name) // 父类成员，调用父类的构造函数完成初始化
, _num(num)
{
cout << "Student()" << endl;
}
/* 子类析构函数 */
~Student()
{
cout << "~Student()" << endl;
}
protected:
int _num;
};
int main()
{
Student s("yangtong", 811);
return 0;
}
🚩 运行结果：
Person()
Student()
~Student()
~Person()Ⅷ. 复杂的菱形继承与菱形虚拟继承
1、菱形继承的概念以及问题
- 单继承：一个子类只有一个直接父类时，称该继承关系为单继承。
- 多继承：一个子类有两个或以上直接父类时，称该继承关系为多继承。
🔺 注意： 初始化列表中的初始化顺序跟成员的声明顺序有关，继承成员初始化的顺序，则是按继承的顺序算的，而不是初始化列表中的顺序，如上面的 Assistant 如果先构造的话，会先去构造 Student，再去构造 Teacher。
多继承中指针偏移的一道题：
class Base1
{
public:
int _b1;
};
class Base2
{
public:
int _b2;
};
class Derive : public Base1, public Base2
{
public:
int _d;
};
int main()
{
Derive d;
Base1* p1 = &d;
Base2* p2 = &d;
Derive* p3 = &d;
return 0;
}A.p1 == p2 == p3
B.p1 < p2 < p3
C.p1 == p3 != p2
D.p1 != p2 != p3 分析：p1 和 p2 虽然都是其父类，但在子类内存模型中，其位置不同，所以 p1 和 p2 所指子类的位置也不相同，因此 p1 != p2。由于 p1 对象是第一个被继承的父类类型，所以其地址与子类对象的地址 p3 所指位置都为子类对象的起始位置，因此 p1 == p3，所以 C 选项是正确的。
- 菱形继承：菱形继承是多继承的一种特殊情况，如下图所示：
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。比如下图中在 Assistant 的对象中 Person 成员会有两份，此时访问 _name 和 _num 会出现二义性问题。
class Person
{
public:
string _name; // 姓名
};
class Student : public Person
{
protected:
int _num; //学号
};
class Teacher : public Person
{
protected:
int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse; // 主修课程
};
int main()
{
// 这样会有二义性无法明确知道访问的是哪一个
Assistant a;
//a._name = "peter"; ❌
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
return 0;
}
💡 解析： 通过指定访问冗余成员的作用域，解决了二义性，但是还是没有解决数据冗余的问题！
数据冗余带来的最大问题是空间的浪费，假设 Person 是这样子的：
class Person
{
public:
string _name;
int _hugeArr[100000]; // 如果数据很大，浪费的可不是一点点了
};
如果数据很大的话，会造成大量的空间浪费！！！我们也知道，C++ 是不能容忍数据冗余和二义性的存在的，于是提出了一个解决方案： 虚继承(virtual)。
2、通过虚继承解决菱形继承问题 -- virtual
解决方案：在位于继承体系的腰部位置的类中加上一个 virtual 关键字：
🔺 注意： 虚继承的 virtual 与后面要学的多态的 virtual 是不一样的！
代码如下：
class Person
{
public:
string _name;
};
// 虚继承
class Student : virtual public Person
{
protected:
int _num;
};
// 虚继承
class Teacher : virtual public Person
{
protected:
int _id;
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse;
};
int main()
{
Assistant a;
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
return 0;
}
加上 virtual 表示虚继承，此时就能完美解决了菱形继承带来的数据冗余和二义性问题。
再配合刚刚我们讲的指定作用域，二义性也可以得到很好的解决。
那么问题来啦，C++编译器是如何通过虚继承解决数据冗余和二义性的呢❓
由于编译器对监视窗口做了优化，我们并不能看到什么猫腻，所以我们打开编译器的内存窗口看一下，并对下面的代码进行观察：
class A
{
public:
int _a;
};
class B : public A
//class B : virtual public A
{
public:
int _b;
};
class C : public A
//class C : virtual public A
{
public:
int _c;
};
class D : public B, public C {
public:
int _d;
};
int main()
{
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
return 0;
}
很明显可以看到，在内存中，d 继承两个不同空间地址的 A，且有不同的值，这样子就造成了二义性和数据冗余......
那我们现在来看一下菱形继承中的内存变化！
这里可以分析出 D 对象中将 A 放到的了对象组成的最下面，这个 A 同时属于 B 和 C ，但是编译器是怎么做到的呢？并且上面的 B 和 C 成员变量中，这两个地址是干嘛的？请看下面！
3、虚基表与虚基表指针
上面的两个地址其实是一个指针，称为虚基表指针，它们都指向一个虚基表，其中虚基表存的是偏移量，通过这个偏移量可以在内存中找到当前类距离 A 类多远，根据这个偏移量来进行访问 A 类。
注意： 虚基表中第一个位置是存放多态机制中虚表偏移量的位置（这个后面接触了多态后会讲），第二个位置存放当前类对象存储距离公共虚基类的偏移量的位置。
我们可以调用其他的内存窗口进行观察！注意这里是小端机，所以高位为高地址，低位为低地址！
以这里第一个虚基表指针 0x00547b48 为例，他的虚基表里第二个位置的偏移量为 0x00000014，也就是 20 个字节，因为这里每行是 4 个字节，所以也就是向下走 5 行，可以发现就到达了存放公共虚基类成员 _a 的内存位置！
问题：为什么 D 对象中 B 类和 C 类要去找 A 类呢❓❓❓
那么大家看看当下面的赋值发生时，D 类变量 d 是不是要去找出 B 或者 C 成员中的 A 才能赋值过去：
D d;
B b = d;
C c = d; 🐛 解析：我们用 D 类对象 d 赋值给父类 B 和 C，这个时候就会出现切片的情况，那我们肯定也要把他们的公共基类 A 的成员变量也切过去呀，所以我们肯定要有这个偏移量才能找到公共基类 A 的成员变量的位置，才能进行切片操作！
更好的说法是，在虚继承中，派生类继承的虚基类只有一份，这就需要在派生类对象中存储虚基类对象的地址，以及偏移量信息，以便于派生类和虚基类之间的访问。虚基表就是为了实现这个目的而存在的。
需要注意的是，由于虚基类被多个派生类所继承，因此虚基类的构造函数和析构函数可能会被多次调用。为了避免这种情况，虚基类的构造函数和析构函数通常会被设计成可重入的，以确保其正确性和可靠性。（涉及到线程安全等问题）
下面是上面的 Person 关系菱形虚拟继承的原理解释：
Ⅸ. 继承与组合
- 继承是一种
is-a的关系。也就是说每个派生类对象都是一个基类对象。 - 组合是一种
has-a的关系。假设B组合了A，每个B对象中都有一个A对象。 - 优先使用对象组合，而不是类继承
- 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用（
white-box reuse）。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度地破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。 - 组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用（
black-box reuse），因为组合对象的内部细节是不可见的（也就是不能访问私有成员，一般只能访问接口函数）。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。 - 实际尽量多去用组合，因为组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用组合，就用组合。
// Car和BMW Car和Benz构成is-a的关系
class Car
{
protected:
string _colour = "白色"; // 颜色
string _num = "陕ABIT00"; // 车牌号
};
class BMW : public Car
{
public:
void Drive() {cout << "好开-操控" << endl;}
};
class Benz : public Car
{
public:
void Drive() {cout << "好坐-舒适" << endl;}
};
// Tire和Car构成has-a的关系
class Tire
{
protected:
string _brand = "Michelin"; // 品牌
size_t _size = 17; // 尺寸
};
class Car
{
protected:
string _colour = "白色"; // 颜色
string _num = "陕ABIT00"; // 车牌号
Tire _t; // 轮胎
};
Ⅹ. 继承的总结和反思
-
很多人说
C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。 -
多继承可以认为是
C++的缺陷之一，很多后来的OOP语言都没有多继承，如Java。 -
虽然虚继承解决了菱形继承的坑，但是也付出了一定的代价：
- 对象模型更加复杂，学习成本更高了。
- 有一定的效率影响。
继承的常见面试题
-
什么是菱形继承？菱形继承的问题是什么？
-
什么是菱形虚拟继承？如何解决数据冗余和二义性的？
-
继承和组合的区别？什么时候用继承？什么时候用组合？