2020.3.25 C++

#include <iostream>

using namespace std;
/*
class Base
{
public:
    //静态成员属于类 而不属于对象
    static int num;
    static int data;
    static void shoDate();
};
//静态成员在类内声明，在类外定义
 int Base::num=100;
 int Base::data=200;

 class Son:public Base
 {
 public:
    static int data;//父类和子类 静态成员同名
    static int shoDate(void);
 };
 int Son::data=300;
 void test01()
 {
     //从Base类中访问
     cout<<Base::num<<endl;
     // Son 也拥有了静态成员num
     cout<<Son::num<<endl;
     //父和子类 静态成员 同名 在子类中 访问子类中的成员
     cout<<Son::data<<endl;
     //父和子类 静态成员 同名 访问父类中的成员 必须加 Base::
     cout<<Son::Base::data<<endl;
 }

class Base1
{
public:
    int a;
};
class Base2
{
public:
    int b;
};
class Son:public Base1,public Base2
{
public:
};
void test02()
{
    Son ob;
    ob.a=100;
    ob.b=200;
}

class Animal
{
public:
    int data;
};
class Sheep:public Animal
{
public:
};
class Tuo:public Animal
{
public:
};
class SheepTuo:public Sheep,public Tuo
{
public:
};
void test03()
{
    SheepTuo st;

    st.Sheep::data=200;
}

class Animal
{
public:
void sleep(void)
{
    cout<<"animal 动物在睡觉"<<endl;
}
};
class Cat:public Animal
{
public:
void sleep(void)
{
    cout<<"cat 猫在睡觉"<<endl;
}
};
void test04()
{
    //用基类（指针或引用） 保存 子对象（向上转账）
    Animal *p= new Cat;
    p->sleep();

    Cat cat;
    Animal &ob= cat;
    ob.sleep();
}

class Animal
{
public:
    //虚函数
    virtual void sleep(void)
    {
        cout<<"animal 动物睡觉"<<endl;
    }
};
class Cat:public Animal
{
public:
    virtual void sleep(void)
{
    cout<<"猫在睡觉"<<endl;
}
};
void test05()
{
    Animal *p =new Cat;
    p->sleep();//调用的是cat中sleep
}
 */
class Base
{
public:
    virtual void sleep(void)
    {
        cout<<"父亲在睡觉"<<endl;
    }
};
class Son1:public Base
{
public:
    virtual void sleep(void)
    {
        cout<<"Son1在安静的睡觉"<<endl;
    }
};
class Son2:public Base
{
public:
    virtual void sleep()
    {
        cout<<"Son2在轻度的睡觉"<<endl;
    }
};
class Son3:public Base
{
public:
    virtual void sleep()
    {
        cout<<"Son3在雨声般的睡觉"<<endl;
    }
};
class Son4:public Base
{
public:
    virtual void sleep()
    {
        cout<<"Son4在鼾声如雷"<<endl;
    }
};
void showData(Base &ob)
{
    ob.sleep();
}
void test06()
{
    Son1 ob1;
    Son2 ob2;
    Son3 ob3;
    Son4 ob4;

    showData(ob1);
    showData(ob2);
    showData(ob3);
    showData(ob4);
}
int main(int argc, char *argv[])
{
    test06();
    return 0;
}
问题:C++的动态捆绑机制是怎么样的？
首先，我们看看编译器如何处理虚函数。当编译器发现我们的类中有虚函数的时候，编译器
会创建一张虚函数表，把虚函数的函数入口地址放到虚函数表中，并且在类中秘密增加一个
指针，这个指针就是vpointer(缩写vptr)，这个指针是指向对象的虚函数表。在多态调用的
时候，根据vptr指针，找到虚函数表来实现动态绑定。