创建对象 stu1 时，执行派生类的构造函数Student::Student()，它并没有指明要调用基类的哪一个构造函数，从运行结果可以很明显地看出来，系统默认调用了不带参数的构造函数，也就是People::People()。

创建对象 stu2 时，执行派生类的构造函数Student::Student(char *name, int age, float score)，它指明了基类的构造函数。

对于析构函数

析构函数也不能被继承。与构造函数不同的是，在派生类的析构函数中不用显式地调用基类的析构函数，因为每个类只有一个析构函数，编译器知道如何选择，无需我们干涉。

析构函数的执行顺序和构造函数的执行顺序也是刚好相反：

• 创建派生类对象时，构造函数的执行顺序和继承顺序相同，即先执行基类构造函数，再执行派生类构造函数。
• 而销毁派生类对象时，析构函数的执行顺序和继承顺序相反，即先执行派生类析构函数，再执行基类析构函数。

多继承和多继承的对象内存模型

c++不仅有单继承，还有多继承

class D: public A, private B, protected C{
//类D新增加的成员
}

D 是多继承形式的派生类，它以公有的方式继承 A 类，以私有的方式继承 B 类，以保护的方式继承 C 类。D 根据不同的继承方式获取 A、B、C 中的成员，确定它们在派生类中的访问权限。

多继承下的构造：

基类构造函数的调用顺序和和它们在派生类构造函数中出现的顺序无关，而是和声明派生类时基类出现的顺序相同（和类中的变量相似），像上面的例子就会先构造A，再构造B，然后是C，最后是D；

命名冲突：

当两个或多个基类中有同名的成员（成员变量或成员函数）时，如果直接访问该成员，就会产生命名冲突，编译器不知道使用哪个基类的成员。这个时候需要在成员名字前面加上类名和域解析符::，以显式地指明到底使用哪个类的成员，消除二义性。

内存模型：

直接上例子：

#include 
using namespace std;
//基类A
class A{
public:
    A(int a, int b);
protected:
    int m_a;
    int m_b;
};
A::A(int a, int b): m_a(a), m_b(b){ }
//基类B
class B{
public:
    B(int b, int c);
protected:
    int m_b;
    int m_c;
};
B::B(int b, int c): m_b(b), m_c(c){ }
//派生类C
class C: public A, public B{
public:
    C(int a, int b, int c, int d);
public:
    void display();
private:
    int m_a;
    int m_c;
    int m_d;
};
C::C(int a, int b, int c, int d): A(a, b), B(b, c), m_a(a), m_c(c), m_d(d){ }
void C::display(){
    printf("A::m_a=%d, A::m_b=%d\n", A::m_a, A::m_b);
    printf("B::m_b=%d, B::m_c=%d\n", B::m_b, B::m_c);
    printf("C::m_a=%d, C::m_c=%d, C::m_d=%d\n", C::m_a, C::m_c, m_d);
}
int main(){
    C obj_c(10, 20, 30, 40);
    obj_c.display();
    return 0;
}

借助指针突破访问权限：

想想指针 指向的是内存的地址，对象指针指向的是对象的内存地址，而通过内存模型可以知道private也是在连续的内存中，所以！！！只要使用指针偏移就可以强行访问private成员变量；例如：

图中假设 obj 对象的起始地址为 0X1000，m_a（public）、m_b（public）、m_c （private）与对象开头分别相距 0、4、8 个字节，我们将这段距离称为偏移（Offset）

要知道：

int b = p -> m_b;

会转换成：int b = * (int*)( (int)p + sizeof(int) );

实际上就是：int b = * (int*) ( (int)p + 4 );

有：

所以：int c = * (int* )( (int)p + sizeof(int)*2 );//就是这么简单

虚继承

1.什么是虚继承和虚基类

多继承容易产生命名冲突：经典的菱形继承

第一类问题：在一个派生类中保留间接基类的多份同名成员，虽然可以在不同的成员变量中分别存放不同的数据，但大多数情况下这是多余的：因为保留多份成员变量不仅占用较多的存储空间，还容易产生命名冲突。假如类 A 有一个成员变量 a，那么在类 D 中直接访问 a 就会产生歧义，编译器不知道它究竟来自 A -->B-->D 这条路径，还是来自 A-->C-->D 这条路径。

为了消除歧义，我们可以在 m_a 的前面指明它具体来自哪个类（用域来处理）

但是内存中还是存在两份间接基类，是消耗内存的，所以为了解决多继承时的命名冲突和冗余数据问题，就 提出了虚继承，使得在派生类中只保留一份间接基类的成员。

//间接基类A
class A{ //虚基类
protected:
    int m_a;
};
//直接基类B
class B: virtual public A{  //虚继承
protected:
    int m_b;
};
//直接基类C
class C: virtual public A{  //虚继承
protected:
    int m_c;
};
//派生类D
class D: public B, public C{
public:
    void seta(int a){ m_a = a; }  //正确
    void setb(int b){ m_b = b; }  //正确
    void setc(int c){ m_c = c; }  //正确
    void setd(int d){ m_d = d; }  //正确
private:
    int m_d;
};
int main(){
    D d;
    return 0;
}

虚继承的目的是让某个类做出声明，承诺愿意共享它的基类。其中，这个被共享的基类就称为虚基类。

可以看出一个问题：必须在虚派生的真实需求出现前就已经完成虚派生的操作，即在出现D的需求前，就要把B、C设定成虚继承；

即是虚派生只影响从指定了虚基类的派生类中进一步派生出来的类（继承BC的类，如E继承B，F继承C，就会有所影响），它不会影响派生类本身（BC）；

实际开发中，位于中间层次的基类将其继承声明为虚继承一般不会带来什么问题。使用虚继承的类层次是由一个人或者一个项目组一次性设计完成，这样不需要因为没有考虑到后面的需求而重新修改中间的函数； c++库iostream就是采用虚继承。

2.虚基类成员的的可见性

以菱形继承为例，假设 A 定义了一个名为 x 的成员变量，当我们在 D 中直接访问 x 时，会有三种可能性：

• 如果 B 和 C 中都没有 x 的定义，那么 x 将被解析为 A 的成员，此时不存在二义性。
• 如果 B 或 C 其中的一个类定义了 x，也不会有二义性，派生类的 x 比虚基类的 x 优先级更高。
• 如果 B 和 C 中都定义了 x，那么直接访问 x 将产生二义性问题。

第二类问题：就是BC中含有优先级相等的相同变量，这个时候只能用域解析来去除二义性。

不提倡在程序中使用多继承！！！只有在比较简单和不易出现二义性的情况或实在必要时才使用多继承，能用单一继承解决的问题就不要使用多继承。小伙子，这不是你能驾驭的????????????

3.虚继承的构造函数和内存模型：

与继承时的构造过程不同，最终派生类的构造函数必须要调用虚基类的构造函数。

#include 
using namespace std;
//虚基类A
class A{
public:
    A(int a);
protected:
    int m_a;
};
A::A(int a): m_a(a){ }
//直接派生类B
class B: virtual public A{
public:
    B(int a, int b);
public:
    void display();
protected:
    int m_b;
};
B::B(int a, int b): A(a), m_b(b){ }
void B::display(){
    cout<<"m_a="<class A{
protected:
    int m_a1;
    int m_a2;
};
class B: public A{
protected:
    int b1;
    int b2;
};
class C: public B{
protected:
    int c1;
    int c2;
};
class D: public C{
protected:
    int d1;
    int d2;
};
int main(){
    A obj_a;
    B obj_b;
    C obj_c;
    D obj_d;
    return 0;
}

A类所处的内存位置一直在前头

1）修改上面的代码，使得 A 是 B 的虚基类：

class B: virtual public A

A会移动到后面

2）再假设 A 是 B 的虚基类，B 又是 C 的虚基类

从上面的两张图中可以发现，虚继承时的派生类对象被分成了两部分：

• 不带阴影的一部分偏移量固定，不会随着继承层次的增加而改变，称为固定部分；
• 带有阴影的一部分是虚基类的子对象，偏移量会随着继承层次的增加而改变，称为共享部分

而有一个问题：如何计算共享部分的偏移量？

对于虚继承，将派生类分为固定部分和共享部分，并把共享部分放在最后，几乎所有的编译器都在这一点上达成了共识。主要的分歧就是如何计算共享部分的偏移，百花齐放，没有统一标准。

这里举例出VS的解决办法：

VC 引入了虚基类表，如果某个派生类有一个或多个虚基类，编译器就会在派生类对象中安插一个指针，指向虚基类表。虚基类表其实就是一个数组，数组中的元素存放的是各个虚基类的偏移字节数。

假设 A 是 B 的虚基类，同时 B 又是 C 的虚基类，那么各对象的内存模型如下图所示：

虚继承表中保存的是所有虚基类（包括直接继承和间接继承到的）相对于当前对象的偏移，这样通过派生类指针访问虚基类的成员变量时，不管继承层次都多深，只需要一次间接转换就可以。

这种方案还可以避免有多个虚基类时让派生类对象额外背负过多的指针，只需要背负一个指针即可。例如，假设 A、B、C、D 类的继承关系为：

内存模型为：

将派生类赋值给基类

发生数据类型转换时， int 类型的数据赋值给 float 类型的变量时，编译器会先把 int 类型的数据转换为 float 类型再赋值；类似的，类也可以发生数据类型转换，它也是一种数据类型；

不过这种转换只有在基类和派生类之间才有意义，并且只能将派生类赋值给基类，包括将派生类对象赋值给基类对象、将派生类指针赋值给基类指针、将派生类引用赋值给基类引用，这在 C++ 中称为向上转型（Upcasting）。相应地，将基类赋值给派生类称为向下转型。

上转型时非常安全的。

赋值的本质是将现有的数据写入已分配好的内存中，对象的内存只包含了成员变量，所以对象之间的赋值是成员变量的赋值，成员函数不存在赋值问题。

这种转换关系是不可逆的，只能用派生类对象给基类对象赋值，而不能用基类对象给派生类对象赋值。（因为基类不包含派生类的成员变量，无法对派生类的成员变量赋值。同理，同一基类的不同派生类对象之间也不能赋值）。

#include 
using namespace std;
//基类
class A{
public:
    A(int a);
public:
    void display();
public:
    int m_a;
};
A::A(int a): m_a(a){ }
void A::display(){
    cout<<"Class A: m_a="<

#include 
using namespace std;
//基类A
class A{
public:
    A(int a);
public:
    void display();
protected:
    int m_a;
};
A::A(int a): m_a(a){ }
void A::display(){
    cout<<"Class A: m_a="<//改改上述main函数中的内容
int main(){
    D d(4, 40, 400, 4000);
   
    A &ra = d;
    B &rb = d;
    C &rc = d;
   
    ra.display();
    rb.display();
    rc.display();
    return 0;
}