C++静态绑定和动态绑定_c++ 基于模板的静态绑定-CSDN博客

本文链接：https://blog.csdn.net/f2016913/article/details/70231785

一：静态绑定与动态绑定
静态绑定：编译时绑定，通过对象调用
动态绑定：运行时绑定，通过地址实现
多态–简单是意思是多种状态
静态多态：a:函数多态（重载） b:模板多态（类模板和函数模板）
动态多态： a:虚函数机制；b:RTTI

class Base
{
public:
      virtual void fun()
      {
            cout << "Base::fun()" << endl;
      }
};
class Driver:public Base
{
public:
      virtual void fun()
      {
            cout << "Driver::fun()" << endl;
      }
};
void Test()
{
      Driver obj1;
      Base*b1 = &obj1;
      Base&b2 = obj1;
      Base obj2;
      obj1.fun();//静态多态，调用派生类的Driver对象的fun()函数
      b1->fun();//动态多态，派生类重写了基类的虚函数，调用派生类Driver对象的fun()函数
      b2.fun();//动态多态，派生类重写了基类的虚函数，调用派生类Driver对象的fun()函数
      obj2.fun();//静态多态，调用基类的Driver对象的fun()函数
}

这里写图片描述
通过上面的实例我们可以知道只有采用“指针->函数（）”或“引用.函数（）”的方式调用c++的虚函数才会执行动态绑定，对于非虚函数不具有动态绑定的特性，所以无论采用什么方式调用都不会执行动态绑定；
虚函数的机制，主要通过虚函数的重写实现多态，多态的底层实现：可以参考继承和多态http://blog.csdn.net/f2016913/article/details/55225939
二：RTTI
RTTI机制的来源：在C++中存在虚函数，也就存在多态性，对于多态的对象，在程序编译时可能会出现无法确认对象的类型的情况，当类中有虚函数时，基类的指针可以指向任何派生类的对象，这时可能不知道基类指针到底指向那个派生类的对象，而类型的确定
要在运行时类型标志做出，为了获得一个对象的类型可以使用typeid函数；
1：两个操作符
（1）：typeid操作符，返回指针和引用所指的实际类型
（2）：dynamic_cast操作符，用来执行运行是类型的识别和装换，dynamic_cast用于将一个父类对象的指针转换为子类对象的指针或引用（动态转换）；
2：typeid函数
该函数的作用主要是让用户知道当前的变量时什么类型
如：例1

class A
{
public:
    void fun()
    {
        cout << "A::fun()" << endl;
    }
};
class B :public A
{
public:
    void fun()
    {
        cout << "B::fun()" << endl;
    }
};
void Test()
{
    A *pa = new A();
    A a;
    cout << typeid(pa).name() << endl;//class A*
    cout << typeid(a).name() << endl;//class A

    B *pb = new B();
    cout << typeid(pb).name() << endl;//class B*
}

这里写图片描述
在调用完typeid()函数之后，接着调用name()成员函数，因为typeid()函数是一个返回类型为const typeid_info&类型的函数，接下来简单了解type_info类；
3：type_info类

class type_info
{
public:
    virtual ~type_info();
    //在type_info类中重载了==运算符，该运算符用于比较两个对象的类型是否相等
    bool operator ==(const type_info&)const;
    //在type_info类中重载了！=运算符，该运算符用于比较两个对象的类型是否不相等
    bool operator !=(const type_info&)const;
    //使用成员函数name,该函数返回对象的类型的名字
    const char*name()const;

    bool before(const type_info&);
private:
    type_info(const type_info&);
    type_info&operator =(const type_info&);
    //type_info类的构造函数和赋值运算符都是私有的
};

( 1 )因为typr_info类的构造和赋值运算符重载都是私有，所以不允许用户自己创建，所以要使用type_info类的方法使用typeid函数。
（2）使用type_info类中重载的==与！=用于比较两个类型是否相等，如果两个对象的类型相等，则返回1，不相等返回0
这种方法也可以用于比较两个带有虚函数的类的对象是否相等如例1；
4：dynamic_cast<>运算符
dynamic_cast<>运算符用来执行运行时类型识别和转换
dynamic_cast<>可以实现两个方向的转换，upcast和downcast
upcast:把派生类的指针，引用转换成基类的指针和引用
downcast:：父类对象指针->子类指针/引用（用dynamic_cast转型是安全的）

class Base
{
public:
    virtual void fun()
    {
        cout << "Base::fun()" << endl;
    }
};
class Driver :public Base
{
public:
    virtual void fun()
    {
        cout << "Driver::fun()" << endl;
    }
};
void Test()
{

    Base  b;
    Driver d;

    Driver *pd = dynamic_cast<Driver*>(&b);//不需要转换返回0
    cout << pd << endl;

    Base *pb = dynamic_cast<Driver*>(&b);//不需要转换 返回0
    cout << pb<< endl;

    pb = &d;
    pd = dynamic_cast<Driver*>(pb);//转换成功非0
    cout << pd << endl;
}