目录
- 基类和派生类的内存分配
- 基类和派生类的成员归属
- 多态的实现
基类和派生类的内存分配
类包括成员变量（data member）和成员函数（member function）。
成员变量分为静态数据（static data）和非静态数据（non-static data），成员函数分为静态成员函数（static function）、非静态成员函数（non-static function）和虚拟成员函数（vritual function）。
C++编译器将类的静态数据、静态成员函数以及非静态成员函数存储在类对象存储空间之外，并且无论该类声明了多少对象，在内存中只存有一份。
虚拟成员函数也存储在类对象存储空间之外，编译器为每个虚拟成员函数产生一个指针，并将这些指针存储在一个被称为虚基表的表格中。
类对象的存储空间中包括：非静态数据以及指向虚基表的指针。
看个例子，为了方便观察做个字节对齐。
//4字节对齐
#pragma pack(push, 4)
class C
{
int age;
static int year;//静态成员变量，不占用类的空间
public:
C()
{
age = 12;
printf("C()\n");
}
~C() = default;
// virtual ~C() = default;//定义了虚函数，则是多态类,会生成虚函数地址表
void TestFunc(){
printf("age=%d\n",age);
}
};
class D : public C
{
int price;
public:
D(){
price = 2000;
printf("D()\n");
}
void TestFunc(){
printf("price=%d\n",price);
}
};
#pragma pack(pop)
//测试调用
D dd;
printf("sizeof(C)=%ld\n",sizeof(C));
printf("sizeof(D)=%ld\n",sizeof(D));
打印
sizeof(C)=4
sizeof(D)=8
观察一：非多态类
类C的析构函数不是虚函数，此时C和D都不是多态类，也就是普通的类。类的大小就是非静态成员变量的大小之和。
观察D dd的内存分配：
dd @0x7fffffffe388 D
[C] @0x7fffffffe388 C
age 12 int
year <optimized out>
price 2000 int
观察dd占用的内存，共8字节，前4字节是0c，转换成十进制是12，也就是基类C中age的大小；后4字节转换成十进制是2000，也就是派生类D中price的大小。
0c 00 00 00 d0 07 00 00
观察二：多态类
把上面例子基类C的虚函数定义为virtual虚函数，则C和D是多态类，打印：
sizeof(C)=12
sizeof(D)=16
C和D的大小分别比非多态类大了8字节，多的8字节其实是指向虚函数表的指针，看下面，比上面多了个vptr。
dd @0x7fffffffe380 D
[C] @0x7fffffffe380 C
[vptr] _vptr.C
age 12 int
year <optimized out>
price 2000 int
观察dd占用的内存，共16字节，前8字节是指向虚函数表的指针；后8字节的前4字节转换10进制是12，也就是基类C中age的大小，后4字节转换成十进制是2000，也就是派生类D中price的大小。
50 d9 55 55 55 55 00 00 0c 00 00 00 d0 07 00 00
一个总结
1、一个类的对象所占用的空间大小：非静态成员变量之和，多态类再加上指向虚基表的指针大小。
2、静态变量year是全局变量被优化，不占用类的大小。
3、类D的对象dd，和基类C的指针地址一样。
4、多态类占用空间比非多态类大8字节，多的8字节其实是指向虚函数表的指针[vptr]。
5、创建一个派生类对象时，先执行基类的构造，再执行派生类的构造，因此内存分配中，前面是基类的非静态成员变量，后面是派生类新增的非静态成员变量。
6、虚函数表指针是在基类构造时创建的，属于基类的一个成员，但派生类也可以访问。
一个多态派生类的对象所占用的内存空间：
基类和派生类的成员归属
访问范围
1、保护成员的可访问范围比私有成员大，比共有成员小。能访问私有成员的地方都能访问保护成员。
2、基类的私有成员只能在基类访问，派生类不能访问。
3、基类的保护成员可以在派生类的成员函数访问。
4、私有成员只能在类的成员函数访问，这和普通类的定义一致。
覆盖和扩充
1、派生类是对基类进行扩充和修改得到的，基类的所有成员自动成为派生类的成员（私有成员除外）。
2、所谓扩充，指的是派生类中可以添加新的成员变量和成员函数。
3、所谓覆盖，指的是派生类中可以重写从基类继承得到的成员。
一个总结
1、构造与析构顺序：构造时先执行基类的构造函数，再执行派生类的构造函数；析构时先执行派生类的析构函数，再执行基类的构造函数。
2、基类的私有成员，不能在派生类的成员函数访问。
3、基类的保护成员，可以在派生类的成员函数中访问。
4、派生类可以定义和基类中同名的成员变量和非虚成员函数，比如例中的age，基类内存中有个age，派生类新增成员内存中也有一个age，这两个成员变量没有联系。
5、派生类成员函数访问基类非私有成员，可以使用基类::访问。
6、基类的析构函数要定义为虚函数，否则在释放基类指针时不会执行派生类的析构函数，造成隐式的内存泄漏。
7、非多态情况下，派生类和基类是包含和被包含的关系，派生类包含了基类，因此派生类指针可以转换为基类指针，但基类指针不能转换为派生类指针(‘A’ is not polymorphic)。
8、多态情况下，基类和派生类指针可以相互转换，但要关注转换后指针是否有效，可以使用dynamic_cast转换，返回nullptr则转换失败。
//4字节对齐
#pragma pack(push, 4)
class A //基类
{
private:
int price;//私有成员，只能在基类的成员函数访问
protected:
int age;//保护成员，可以在派生类的成员函数中访问
public:
char name[20]= "chw";//公有成员，可以在任何地方访问
A()
{
price = 2000;
age = 17;
printf("A()\n");
}
virtual ~A()
{
printf("~A()\n");
}
void TestFunc()
{
printf("price=%d\n",price);
printf("age=%d\n",age);
printf("name=%s\n",name);
}
virtual void PrintThis()
{
printf("A=%p\n",this);
}
};
class B : public A //派生类
{
private:
int age;//派生类中可以重写从基类继承得到的成员
char addr[20];//派生类可以扩充新的成员变量
public:
B()
{
age = 27;
printf("B()\n");
}
~B()
{
printf("~B()\n");
}
//覆盖了基类的同名成员函数
void TestFunc()
{
//不能访问基类的私有成员
// printf("price=%d\n",price);// error: 'price' is a private member of 'A'
//可以访问基类的保护成员和公有成员
printf("age=%d\n",age);
printf("name=%s\n",name);
printf("A::age=%d\n",A::age);//基类成员被派生类覆盖，可以使用A::访问基类的成员
// A::TestFunc();//使用A::也可以访问基类的同名成员函数
printf("B=%p\n",this);
A::PrintThis();
}
};
//测试调用
B* bb = new B;
bb->TestFunc();
printf("**********分割线***********\n");
A* bb_a = dynamic_cast<A*>(bb);
bb_a->TestFunc();
printf("sizeof(A)=%ld\n",sizeof(A));
printf("sizeof(B)=%ld\n",sizeof(B));
delete bb;
//基类不能转换为派生类，因为类A没有虚函数，不是多态的
//如果类A成员函数TestFunc定义为virtual的，可以转换，但转换完成后aa_b==nullptr，不能使用
// A* aa = new A;
// B* aa_b = dynamic_cast<B*>(aa);//error: 'A' is not polymorphic
#pragma pack(pop)
打印
A()
B()
age=27
name=chw
A::age=17
B=0x5555559e15b0
A=0x5555559e15b0
**********分割线***********
price=2000
age=17
name=chw
sizeof(A)=36
sizeof(B)=60
~B()
~A()
内存占用
bb @0x5555559e15b0 B
[A] @0x5555559e15b0 A
[vptr] _vptr.A
age 17 int
name "chw\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" char[20]
price 2000 int
addr "nj\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" char[20]
age 27 int
打印分析：
1、派生类和基类指针地址是一样的（0x5555559e15b0）。
2、派生类重新定义了age，和基类的age是两个没有联系的变量。
3、sizeof(A) = 虚函数表指针(8字节) + price(4字节) + age(4字节) + name(20字节) = 36。
4、sizeof(B) = sizeof(A) + age(4字节) + addr(20字节) = 60。
多态的实现
多态的介绍参考：https://blog.csdn.net/weixin_40355471/article/details/124368317#_844。
通过基类指针或基类引用实现多态
1、对于普通函数，不用管指针是指向基类还是派生类，只和指针变量的数据类型相关，即定义指针变量时的指针数据类型，如果是基类，则始终调用基类的普通函数，如果是派生类，则始终调用派生类的普通函数。
2、对于虚函数，要看基类指针当前指向的是基类还是派生类，如果指向基类则调用基类的虚函数，如果指向派生类则调用派生类的虚函数。
3、派生类指针可以赋值给基类指针，但基类指针赋值给派生类指针时要注意转换的有效性，通常使用dynamic_cast转换，失败时返回nullptr。
4、因此通常使用基类指针或引用，根据基类指针是指向基类还是派生类，实现多态。
class A
{
public:
void out1()//普通函数
{
printf("A(out1)\n");
};
virtual ~A(){};
virtual void out2()//虚函数
{
printf("A(out2)\n");
}
};
class B:public A
{
public:
virtual ~B(){};
void out1()
{
printf("B(out1)\n");
}
void out2()
{
printf("B(out2)\n");
}
};
//测试调用
A *aa = new A;//基类指针，无论aa后面指向基类还是派生类，普通函数都是调用基类的普通函数
B *bb = new B;//派生类指针
aa->out1();//A(out1)
aa->out2();//A(out2)
bb->out1();//B(out1)
bb->out2();//B(out2)
aa = bb;//派生类指针赋值给基类指针
bb = dynamic_cast<B*>(aa);//基类指针可以转换成派生类指针，转换失败时返回nullptr
aa->out1();//A(out1)
aa->out2();//B(out2)
bb->out1();//B(out1)
bb->out2();//B(out2)
打印
A(out1)
A(out2)
B(out1)
B(out2)
A(out1)
B(out2)
B(out1)
B(out2)
