类的兼容性原则

父类指针可以new子类对象，子类指针不可以new父类对象，但是可以接收强转的已经存在的父类指针
父类指针指向本类对象，调用的虚函数和普通函数都是自己的
将子类指针指向父类对象，虚函数执行的是父类的，也可以调用子类函数（这种操作是错误的，编译会报错，虽然可通过指针强转，但是不建议这样做，可能会导致未知错误）
父类指针指向子类对象，虚函数执行的是子类的，并且不能调用子类的函数
父类指针与子类指针之间赋值可以理解为指针所指内容的一种浅拷贝
Father *f = (Father*)Child * 子类的虚函数指针覆盖父类的，并且子类特有的函数指针不会拷贝过去
Child *c = (Child*)new Father父类的虚函数指针覆盖子类的，同时也有子类特有的函数指针

class A{
public:
    void printA(){
        cout << "printA()" << endl;
    }
    virtual void print(){
        cout << "A::print()" << endl;
    }
};
class B:public A{
public:
    void printB(){
        cout << "printB()" << endl;
    }
    virtual void print() override{
        cout << "B::print() b = " << b << endl;
    }
    
private:
    int b;
};
int main( )
{
    // 1、指向自己的类对象（将父类对象赋值给父类指针）
    A *a = new A;
    // 1.1 调用自己的函数
    a->printA();        // printA()
    // 1.2 调用虚函数
    a->print();         // A::print()
    
    // 2、将指向父类的父类指针强转为子类指针（将父类对象赋值给子类指针）
    // b = new A;       // error: incompatible pointer types assigning to 'B *' from 'A *'
    B *b = (B*)new A;
    // 2.1 调用父类函数
    b->printA();        // printA()
    // 2.2 调用虚函数（执行父类的）
    b->print();         // A::print()   调用父类的
    // 2.3 可以调用子类函数
    b->printB();        // printB() b = 0
    
    // 3、将子类对象赋值给父类指针
    a = new B;
    // 3.1 调用父类函数
    a->printA();        // printA()
    // 3.2 调用子类的函数
    // a->printB();     // error: no member named 'printB' in 'A'; did you mean 'printA'?
    // 3.3 调用虚函数（执行子类的）
    a->print();         // B::print() b = 0
    
    // 4、指向子类对象的子类指针强转为父类指针（效果等同情况3）
    b = new B;
    a = (A*)b;
    a->printA();        // printA()
    //a->printB();      // error: no member named 'printB' in 'A'
    a->print();         // B::print() b = 0
    
    return 0;
}