C++多态

深入剖析C++多态、VPTR指针、虚函数表

C++虚函数表分析

C++继承中重载、重写、重定义的区别：

C++虚函数表剖析

C++获取虚表地址和虚函数地址时的两个强制类型转换

类型兼容性原则

　　类型兼容规则是指在需要基类对象的任何地方，都可以使用公有派生类的对象来替代。通过公有继承，派生类得到了基类中除构造函数、析构函数之外的所有成员。这样，公有派生类实际就具备了基类的所有功能，凡是基类能解决的问题，公有派生类都可以解决。

　　类型兼容规则中所指的替代包括以下情况：（1）子类对象可以当作父类对象；（2）使用子类对象可以直接赋值给父类对象；（3）子类对象可以直接初始化父类对象；父类指针可以直接指向子类对象；父类引用可以直接引用子类对象。

　　在替代之后，派生类对象就可以作为基类的对象使用，但是只能使用从基类继承的成员。

class Animal{
public:
    Animal(){
        cout << "Animal默认构造函数" << endl; 
    }

    void aniSpeak(){
        cout << "Animal speak" << endl;
    }
    Animal(int m){
        cout << "Animal有参构造函数" << endl;
        m_Age = m;
    }
    Animal(const Animal&p){
        cout << "Animal拷贝构造函数" << endl;
    }

    int m_Age;
};

class Sheep:public Animal{
public:
    void sheSpeak(){
        cout << "Sheep speak" << endl;
    }

    Sheep(){ cout << "Sheep默认构造函数" << endl; }

    Sheep(int m){
        cout << "Sheep有参构造函数" << endl;
        m_sheAge = m;
    }

    Sheep(const Sheep& sp){
        cout << "Sheep拷贝构造函数" << endl;
    }

    int m_sheAge;
};

//父类指针和父类引用，只能执行父类函数
void doSpeak(Animal &animal){
    animal.aniSpeak();
}

void doSpeak2(Animal *animal){
    animal->aniSpeak();
}

void test01(){
    Animal animal;
    animal.aniSpeak(); //animal speak
    
    //复习继承中创建子类对象时的构造函数
    //-----------------------
    //子类调用某种构造函数时，先调用父类中对应的构造函数
    //-----------------------
    cout << "------sheep默认------" << endl;
    Sheep sheep; 
    cout << "--------------------" << endl;

    cout << "------sheep有参------" << endl;
    Sheep sheep0(0);
    cout << "--------------------" << endl;

    cout << "-----sheep拷贝-------" << endl;
    Sheep sheep1 = sheep;
    cout << "--------------------" << endl;

    //子类对象初始化父类对象
    //-----------------
    //空指针也可以访问成员函数，但要注意this指针
    //Animal *animalPtr = NULL;
    //animalPtr->aniSpeak();
    //-----------------

    //父类对象通过new在堆上初始化
    Animal *animalequ0 = new Sheep; 
    Animal *animalequ1 = new Sheep();
    Animal *animalequ2 = new Sheep(1);

    //父类对象在栈上初始化
    Animal *animalPtr = NULL;
    animalPtr = &sheep;
    animalPtr->aniSpeak(); //animal speak

    //子类对象直接赋值给父类对象
    Animal animalequ3 = sheep;
    Animal animalequ4(sheep);

    //子类对象直接当父类对象
    sheep.aniSpeak(); //animal speak

    //父类对象或指针指向子类对象
    doSpeak(sheep); //animal speak
    doSpeak2(&sheep); //animal speak
}

多态引出

　　上述代码中，由于类型兼容性原则不管传入子类还是父类对象，都是调用的父类函数，但我们想传入子类对象调用子类函数，传入父类对象调用父类函数，即同样的调用语句有多种不同的表现形态。

　　为此，引入多态来解决该问题，多态实现的基础：（1）要有继承；（2）要有虚函数重写；（3）父类指针(引用)指向子类对象。

1. 虚函数

　　虚函数机制是实现多态的关键技术，对于父类与子类的同名函数，父类同名函数必须声明为virtual函数，子类的的同名函数前面的virtual可写可不写。

2. 重写/重定义/重载

　　重载overload：是函数名相同，参数列表不同。重载只是在同一个类的内部存在，但是不能靠返回类型来判断。

　　重写override：也叫做覆盖。子类重新定义父类中有相同名称和参数的虚函数。两者的函数特征相同。但是具体实现不同，主要是在继承关系中出现的 。

　　重写需要注意：

　　　　（1）被重写的函数不能是static的。必须是virtual的

　　　　（2）重写函数必须有相同的类型，名称和参数列表

　　　　（3）重写函数的访问权限可以不同。尽管virtual是private的，子类中重写改写为public,protected也是可以的。

　　重定义redefining：也叫做隐藏。子类重新定义父类中有相同名称的非虚函数 ( 参数列表可以不同 ) 。如果一个类，存在和父类相同的函数，那么，这个类将会覆盖其父类的方法，除非你在调用的时候，强制转换为父类类型或加上父类作用域，否则试图对子类和父类做类似重载的调用是不能成功的（详见：C++继承：继承中的同名处理）。 

class Parent0
{
public:
    //以下三个函数在同一个类中表现为重载
    virtual void fun(){
        cout << "func1()" << endl;
    }
    virtual void fun(int i){
        cout << "func2()" << endl;
    }
    virtual void fun(int i, int j){
        cout << "func3()" << endl;
    }
    int abc(){
        cout << "abc" << endl;
    }
    virtual void fun(int i, int j, int k, int r){
        cout << "fun(i,j,k,r)" << endl;
    }
};

class Parent1
{
public:
    int abc(){
        return 0;
    }
};

class Son :public Parent1
{
public:
    int abc(){//非虚函数重写--->重定义
        cout << "abc" << endl;
        return 1;
    }
};

class Parent2
{
public:
    virtual void fun(int i, int j){
        cout << "func3()" << endl;
    }
};

class Son :public Parent2
{
public:
    void fun(int i, int j){//与父类相同，這是虚函数重写
        cout << "fun(int i,int j)" << endl;
    }
};

多态

　　多态，就是根据实际的对象类型决定函数调用语句的具体调用目标。总结一句话就是，同样的调用语句有多种不同的表现形态。

　　多态分为静态多态（运算符重载、函数重载）和动态多态（派生类、虚函数），两者主要的区别：函数地址是早绑定（静态联编）还是晚绑定（动态联编）。即，在编译阶段确定好地址还是在运行时才确定地址。

class Animal{
public:
    virtual void speak(){ //在父类中声明虚函数，可以实现多态，动态联编
        cout << "Animal speak" << endl;
    }
};

class Sheep :public Animal{
public:
    void speak(){ //发生多态时，子类对父类中的成员函数进行重写，virtual可写可不写
        cout << "Sheep speak" << endl;
    }
};

void doSpeak(Animal &animal){
    animal.speak();
}

//想通过父类引用指向子类对象，即输出sheep speak
void test01(){
    Sheep sheep;
    doSpeak(sheep); //sheep speak;

    Animal amimal0 = sheep;
    animal0.speak(); //sheep speak;

    Animal *animal = new Sheep();
    animal->speak(); //sheep speak;
}

多态原理剖析

　　类似于虚继承中的虚基类指针和虚基类表，多态中的虚函数会有虚函数指针和虚函数表，通过开发人员工具可以清楚的看到虚函数指针和虚函数表的内部结构和存储位置。

1. 不同继承状态下的结构分析

　　（1）一般继承（无虚函数覆盖）

class Animal{
public:
    virtual void aniSpeak(){
        cout << "Animal speak" << endl;
    }

};

class Sheep:public Animal{
public:
    virtual void sheSpeak(){
        cout << "Sheep speak" << endl;
    }
};

　　图中所示：虚函数按照其声明顺序放于表中；父类的虚函数在子类的虚函数前面。

　　（2）一般继承（有虚函数覆盖）

class Animal{
public:
    virtual void aniSpeak(){
        cout << "Animal speak" << endl;
    }

};

class Sheep:public Animal{
public:
    virtual void sheSpeak(){
        cout << "Sheep speak" << endl;
    }
    virtual void aniSpeak(){
        cout << "Sheep not speak" << endl;
    }
};

　　图中所示：子类中重写的aniSpeak函数在虚函数表中覆盖了之前的父类函数；未重写的函数，并没有发生改变。

　　（3）多继承（无虚函数覆盖）

class Animal{
public:
    virtual void aniSpeak(){
        cout << "Animal speak" << endl;
    }

};

class Sheep{
public:
    virtual void sheSpeak(){
        cout << "Sheep speak" << endl;
    }
};

class Tuo :public Animal, public Sheep{
public:
    virtual void TuoSpeak(){
        cout << "Tuo speak" << endl;
    }
};

　　图中所示：（1）每个父类都有自己的虚表；（2）子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的），这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

　　（4）多继承（有虚函数覆盖）

class Animal{
public:
    virtual void aniSpeak(){
        cout << "Animal speak" << endl;
    }

};

class Sheep{
public:
    virtual void sheSpeak(){
        cout << "Sheep speak" << endl;
    }
};

class Tuo :public Animal, public Sheep{
public:
    virtual void aniSpeak(){
        cout << "Tuo not speak" << endl;
    }
    virtual void sheSpeak(){
        cout << "Sheep not speak" << endl;
    }
    virtual void TuoSpeak(){
        cout << "Tuo speak" << endl;
    }
};

　　图中所示：子类重写了aniSpeak()函数、sheSpeak()函数，在虚函数表中覆盖了之前的父类函数。

2. 虚函数指针和虚函数表

　　实现多态的流程：虚函数指针->虚函数表->函数指针->入口地址，虚函数表（vftable）属于类，或者说这个类的所有对象共享一个虚函数表；虚函数指针（vfptr）属于单个对象。

　　在程序调用时，先创建对象，编译器在对象的内存结构头部添加一个虚函数指针，进行动态绑定，虚函数指针指向对象所属类的虚函数表。

　　虚函数表是一个指针数组，其元素是虚函数的指针，每个元素对应一个函数的指针。如果子类对父类中的一个或多个虚函数进行重写，子类的虚函数表中的元素顺序，会按照父类中的虚函数顺序存储，之后才是自己类的函数顺序。

class Animal{
public:
    virtual void AniSpeak(){
        cout << "Animal speak" << endl;
    }
    virtual void aniSpeak(){
        cout << "Animal speak" << endl;
    }
    

};

class Tuo :public Animal{
public:
    
    virtual void TuoSpeak(){
        cout << "Tuo speak" << endl;
    }
    virtual void aniSpeak(){
        cout << "Tuo not speak" << endl;
    }
    virtual void AniSpeak(){
        cout << "Sheep not speak" << endl;
    }
    int m_Age;
};

　　编译器根本不会去区分，传进来的是子类对象还是父类对象，而是关心print()是否为虚函数。如果是虚函数，就根据不同对象的vptr指针找属于自己的函数。父类对象和子类对象都有vfptr指针，传入对象不同，编译器会根据vfptr指针，到属于自己虚函数表中找自己的函数。即：vptr--->虚函数表------>函数的入口地址，从而实现了迟绑定(在运行的时候，才会去判断)。

　　如果不是虚函数，那么这种绑定关系在编译的时候就已经确定的，也就是静态联编！

　　虚函数表（vftable）存储着所有虚函数的位置，由于其动态绑定特性，在重写（override）后在子类中存储的虚函数位置与父类中不相同，这样才会实现同样的调用语句传入不同类型的参数有多种不同的表现形态，详见如下示例。

class A {
public:
    virtual void vfunc1();
    virtual void vfunc2();
    void func1();
    void func2();
private:
    int m_data1, m_data2;
};

class B : public A {
public:
    virtual void vfunc1();
    void func1();
private:
    int m_data3;
};

class C: public B {
public:
    virtual void vfunc2();
    void func2();
private:
    int m_data1, m_data4;
};

　　从上图中可看出， 实例化一个对象，可以想象为每个对象为一个结构体，首元素为指针，其余为自身数据（只包括非静态数据，不包括静态成员和非虚函数）。对象的地址，是数组中首元素的地址，即虚函数指针，虚函数指针指向虚函数表（虚函数指针的值为虚函数表的地址），可以通过地址偏移访问到每个成员属性和成员函数，具体见下一小节。

3. 深入剖析虚函数表

　　（1）确定虚函数指针的存在

class Parent1{
public:
        Parent1(int a=0){
            this->a = a;}
        void print(){ 
            cout<<"parent"<<endl;}  
private:
        int a;
};
class Parent2{
public:
        Parent2(int a=0){
            this->a = a;}
        virtual void print(){ 
            cout<<"parent"<<endl;}  
private:
        int a;
};

void main(int argc, char const *argv[]){
        cout<<"Parent1"<<sizeof(Parent1)<<endl; //4
        cout<<"Parent2"<<sizeof(Parent2)<<endl; //8
        return 0;
}

　　通过sizeof运算符我们可以查看一个对象所占的空间，对于一个只有函数（无虚函数）没有属性的空类对象，它的空间长度为1，而对于有虚函数、没有属性的空类对象，无论虚函数的数量为多少，空间长度都为4，这是因为它包含一个指向虚表的指针，指针内存放的是虚表的地址。

　　（2）虚函数指针的个数

　　子类中的虚函数指针个数和继承的类个数相关，继承的每个类仅产生一个虚函数指针。

　　（3）编译器寻找虚函数地址

　　对象本身地址类型为class *，但指针内的值为整型，因此需要涉及到C++指针类型间强制转换（详见C++指针类型间强制转换）。对象包含一个指向虚表的指针，指针内存放的是虚表的地址,指针的长度为4个字节。

　　①tuo 对象相当于一个结构体，首元素是虚指针，后面是继承的数据及自身的其他数据

　　②&tuo 对象的地址，结构体的地址，首元素的地址，也是虚函数指针vfptr的地址，空间长度为四个字节

　　③(int *)(&tuo) &tuo的类型为class Tuo*，需要强转为int *，因为int*和指针都是4个字节，可以互相转换，为了后面用int进行解释

　　④*(int*)(&tuo) 用int类型解释&tuo指向的数据，取到了虚函数表（同样相当于指针数组）的地址值，也是指针数组的首元素的地址值

　　⑤(int*)*(int *)(&tuo) 地址值为整型，需将其转化为合法地址，虚函数表里面存储的是函数指针（函数的入口地址），函数指针为4个字节，强转为int *，对虚函数表的地址取前四个字节

　　⑥*(int*)*(int *)(&tuo) 对地址解引用，得到第一个函数指针

　　⑦((void(*)()) (*(int_*)*(int_ *)(&tuo)))() 通过函数指针进行函数调用（详见C语言函数指针和回调函数）

class Animal{
public:
    virtual void AniSpeak(){
        cout << "Animal speak" << endl;
    }
    virtual void aniSpeak(){
        cout << "Animal speak" << endl;
    }
};

class Tuo :public Animal{
public:
    Tuo(){ m_Age = 10; }
    virtual void TuoSpeak(){
        cout << "Tuo speak" << endl;
    }
    virtual void aniSpeak(){
        cout << "Tuo not speak" << endl;
    }
    virtual void AniSpeak(){
        cout << "Sheep not speak" << endl;
    }
    int m_Age;
};

void test03(){
    cout << "----------------class Tuo---------------" << endl;
    //虽然地址没有类型，但是地址的值(8位十六进制数字),为整型值，将地址解释为其他类型（float或char）没有意义
    //由于虚函数指针和函数指针均为4个字节，强转时必须也为4个字节，否则在取数据时会出现错误
    typedef long int_;

    Tuo tuo;
    //cout << (float*)*(float*)(&tuo) << endl; //*(float*)(&tuo)将对象地址强转为float*，将其指向的数据按float进行解释为浮点型，但浮点型无法作为合法地址
    cout << *(int*)*(int*)(&tuo) << endl; //*(int*)(&tuo)将对象地址强转为int*，将其指向的数据按int进行解释为整型，整型可以强转作为合法地址

    //它包含一个指向虚表的指针，指针内存放的是虚表的地址,指针的长度为4个字节
    //tuo 对象相当于一个指针数组，首元素是虚指针，后面是继承的数据及自身的其他数据
    //&tuo 对象的地址，指针数组的地址，首元素的地址，也是虚函数指针vfptr的地址，空间长度为四个字节
    //(int *)(&tuo) &tuo的类型为class Tuo*，需要强转为int *，因为int*和指针都是4个字节，可以互相转换，为了后面用int进行解释
    //*(int*)(&tuo) 用int类型解释&tuo指向的数据，取到了虚函数表（同样相当于指针数组）的地址值，也是指针数组的首元素的地址值
    //(int*)*(int *)(&tuo) 地址值为整型，需将其转化为合法地址，虚函数表里面存储的是函数指针（函数的入口地址），函数指针为4个字节，强转为int *，对虚函数表的地址取前四个字节
    //*(int*)*(int *)(&tuo) 对地址解引用，得到第一个函数指针
    //((void(*)()) (*(int_*)*(int_ *)(&tuo)))() 通过函数指针进行函数调用

    int_ p0 = (*((int_ *)(&tuo) + 1));
    cout << p0 << endl;

    ((void(*)()) (*(int_*)*(int_ *)(&tuo)))();

    typedef void(*func)();
    func p = (func)(*(int_*)*(int_*)(&tuo));
    p();
}
    

　　在取虚表地址的代码中，我们可以看到这个虚表指针是没有名字的，因此就无法像我们平常使用指针那样直接调用变量来引用内容，只能通过*(int*)&tuo的方式获取指针的内容。

　　（4）通过对象指针寻找成员地址

//--------------------------
//通过对象指针查找对象成员
//--------------------------
class Person{
public:
    Person(){ m_A = 10; m_B = 20; }

    int m_A;
    float m_B;
};

void test01(){
    Person person;
    //通过对象地址查找对象成员
    int m_a = 0;
    m_a = *(int *)(&person);
    cout << m_a << endl;
}

　　具体寻址原理与编译器寻找虚函数地址同。

　　（5）内存中对象和虚函数表的数据结构

class Animal{
public:
    virtual void AniSpeak(){
        cout << "Animal speak" << endl;
    }
    virtual void aniSpeak(){
        cout << "Animal speak" << endl;
    }
};

class Tuo :public Animal{
public:
    Tuo(){ m_Age = 10.1; }
    virtual void TuoSpeak(){
        cout << "Tuo speak" << endl;
    }
    virtual void aniSpeak(){
        cout << "Tuo not speak" << endl;
    }
    virtual void AniSpeak(){
        cout << "Sheep not speak" << endl;
    }
    float m_Age;
};

void test08(){
    
    Tuo tuo;

    //对象内存的数据结构类似结构体，首元素为指针，其余为自身数据
    int* mptr = NULL;
    mptr = (int*)(&tuo);
    cout << mptr[0] << endl;
    //cout << mptr[1] << endl;
    cout << *((float*)(&tuo)+1) << endl;

    //虚函数表为指针数组
    typedef void(*func)();
    func* mtab = NULL;
    mtab = (func*)((*(int*)(&tuo)));
    func f = mtab[0];
    f();
}

　　内存中对象的数据结构类似结构体，首元素为指针，其余为自身数据，虚函数表的数据结构为指针数组。

4. 构造函数中能否实现多态　

　　该问题等价于虚函数指针什么时候初始化?

class Parent{
public:
    Parent(int a=0){
            this->a = a;
            print();
    }
    virtual void print(){
    cout<<"Parent"<<endl;
    }
private:
    int a;
};
class Son:public Parent{
    Son(int a=0,int b=0):Parent(a){ //初始化列表
        this->b = b;
        print();
    }
    virtual void print(){
    cout<<"Son"<<endl;
    }
};
void main(){
        Son s;
        return 0;
}

　　代码中构造子类对象，但调用的是父类的print，因此构造函数中不能实现多态。

　　①对象在创建的时,由编译器对VPTR指针进行初始化 

　　②只有当对象的构造完全结束后VPTR的指向才最终确定，即子类对象创建过程中虚函数指针指向会发生变化 

　　③父类对象的VPTR指向父类虚函数表 

　　④子类对象的VPTR指向子类虚函数表

　　当定义一个子类对象的时候比较麻烦，因为构造子类对象的时候会首先调用父类的构造函数然后再调用子类的构造函数。当调用父类的构造函数的时候，此时会创建Vptr指针（也可以认为Vptr指针是属于父类的成员，所以在子类中重写虚函数的时候virtual关键字可以省略，因为编译器会识别父类有虚函数，然后就会生成Vptr指针变量），该指针会指向父类的虚函数表；然后再调用子类的构造函数，此时Vptr又被赋值指向子类的虚函数表。 

　　（执行父类的构造函数的时候Vptr指针指向的是父类的虚函数表，所以只能执行父类的虚函数）
5. 非虚函数

　　（1）虚函数才有虚函数表，非虚函数没有虚函数表，直接编译时静态联编访问；（2）非虚函数不能通过对象指针进行访问，因为非虚函数和静态成员不属于对象。

抽象类和纯虚函数

　　 在程序设计中，如果仅仅为了设计一些虚函数接口，打算在子类中对其进行重写，那么不需要在父类中对虚函数的函数体提供无意义的代码，可以通过纯虚函数满足需求。

　　纯虚函数的语法格式：  virtual 返回值类型 函数名 () = 0;   只需要将函数体完全替换为 = 0即可，纯虚函数必须在子类中进行实现，在子类外实现是无效的。

注意：

　　（1）如果父类中出现了一个纯虚函数，则这个类变为了抽象类，抽象类不可实例对象；

　　（2）如果父类为抽象类，子类继承父类后，必须实现父类所有的纯虚函数，否则子类也为抽象类，也无法实例对象

class Base1{
public:
    Base1(){
        cout << "默认构造函数" << endl;
    }
    ~Base1(){
        cout << "默认析构函数" << endl;
    }

    //virtual int getresult(){ return 0; }
    virtual int getresult() = 0;
    virtual int getresult0() = 0;
};

//这里声明是无效的，子类仍为抽象类
//int Base1::getresult(){
//    cout << "get" << endl;
//    return 0;
//}

class Son1 :public Base1{
public:
    Son1(){
        cout << "子类默认构造函数" << endl;
    }

    ~Son1(){
        cout << "子类默认析构函数" << endl;
    }

    int getresult0(){
        cout << "get0" << endl;
        return 0;
    }
    int getresult(){
        cout << "get" << endl;
        return 0;
    }

};

虚析构、纯虚析构

1. 虚析构

　　我们知道，仅仅发生继承时，创建子类对象后销毁，函数调用流程为：父类构造函数->子类构造函数->子类析构函数->父类析构函数；当发生多态时（父类指针指向子类对象），通过父类指针在堆上创建子类对象，然后销毁，调用流程为：父类构造函数->子类构造函数->父类析构函数，不会调用子类析构函数，因此子类中会出现内存泄漏问题。

　　解决方法：将父类中的析构函数定义为虚函数，语法格式为：  virtual ~类名(){ //Something }  

2. 纯虚析构

　　与纯虚函数写法一致，语法格式为： virtual ~类名() = 0; 

　　 注意：（1）纯虚析构需要类内声明，类外实现；（2）纯虚析构也是虚函数，该类也为抽象类；（3）子类不会继承父类的析构函数，当父类纯虚析构没有实现时，子类不是抽象类，可以创建创建对象。

class Base1{
public:
    Base1(){
        cout << "默认构造函数" << endl;
    }

    //发生多态时，普通析构函数不会调用子类析构函数，会导致子类内存泄漏
    //~Base1(){
    //    cout << "默认析构函数" << endl;
    //}

    //改为虚析构即可解决该问题
    //virtual ~Base1(){
    //    cout << "默认析构函数" << endl;
    //}

    //纯虚析构需要类内声明，类外实现
    //子类无法继承父类的构造和析构函数，因此需要在子类外实现
    //纯虚析构也是纯虚函数，需要实现，否则抽象类无法实例对象
    virtual ~Base1() = 0;
};

//父类、子类外实现纯虚析构函数
Base1::~Base1(){
    cout << "默认析构函数" << endl;
}

class Son1 :public Base1{
public:
    Son1(char* name){
        cout << "子类默认构造函数" << endl;
        this->m_Name = new char[strlen(name)+1];
        strcpy(m_Name, name);
    }

    ~Son1(){
        cout << "子类默认析构函数" << endl;
        if (this->m_Name != NULL){
            delete[] this->m_Name;
            this->m_Name = NULL;
        }
    }

    char *m_Name;

};

void test02(){
    Base1 *base = new Son1 ("Tom");
    delete base;

    //当父类的纯虚析构没有实现时，子类可以实例对象，也可以说明子类没有继承父类的析构函数
    //Son1 son("tom");
}

　　建议：尽量将析构函数都写为虚析构。

向上&向下类型转换

　　派生类继承于基类，除了继承基类的数据，派生类还有自身的数据，因此，基类大小<=派生类大小。

1. 向下类型转换

　　基类强转到派生类，称为向下类型转换，这种转换是不安全的，即操作范围容易越界。因为基类创建对象后的空间比派生类空间小，转为派生类后，操作易越界。

2. 向上类型转换

　　派生类强转到基类，称为向上类型转换，这种操作是安全的，因为派生类创建的空间比基类的空间大。

3. 多态

　　发生多态，及父类引用或指针指向子类对象，此时直接开辟的为派生类的空间，无论怎么强转，总是安全的。

class Base1{
public:
    Base1(){
        cout << "默认构造函数" << endl;
    }
    ~Base1(){
        cout << "默认析构函数" << endl;
    }
};

class Son1 :public Base1{
public:
    Son1(){
        cout << "子类默认构造函数" << endl;
    }

    ~Son1(){
        cout << "子类默认析构函数" << endl;
    }
};

void test02(){
    //向下类型转换
    Base1 *base0 = new Base1;
    Son1 *son0 = (Son1*)base0;

    //向上类型转换
    Son1 *son1 = new Son1;
    Base1 *base1 = (Base1*)son1;

    //多态
    Base1 *base2 = new Son1;
}