深入理解C++的静态绑定和动态绑定

拼搏现实的明天。 2022-06-13 09:29 293阅读 0赞

**深入理解C++的静态绑定和动态绑定**

理解静态绑定和动态绑定，需要先理解四个名词：

1、对象的静态类型：对象在声明时采用的类型，是在编译期确定的。

2、对象的动态类型：目前所指对象的类型，是在运行期决定的。

对象的动态类型可以更改，但是静态类型无法更改。例如：

class A{...};
    class B:public A{...};
    class C:public A{...};
    
    C* pC = new C();     //pC的静态类型为它的声明类型C*,动态类型也是C*
    A* pA = new C();     //pA的静态类型为它的声明类型A*，动态类型为C*
    B* pB = new B();
    pB = pC;             //pB的动态类型是可以更改的，现在它的动态类型为C*

3、静态绑定：在编译期，根据变量的静态类型（变量声明为基类还是派生类）来决定调用哪个函数，用基类声明的，就调用基类的方法，用派生类声明的就调用派生类的方法。

4、动态绑定：在运行期，根据变量实际指向的对象类型（该变量指向基类还是派生类）来决定调用哪个函数。

C++中非虚函数都是静态绑定的，虚函数是动态绑定的.

例如

#include <iostream>
    using namespace std;
    
    class A
    {
    public:
         virtual void f1()          //虚函数，采用动态绑定
         {
              cout<<"A::f1()"<<endl;     
         }
         void f2()                  //非虚函数，采用静态绑定
         {
              cout<<"A::f2()"<<endl;  
         }
    };
    
    class B:public A
    {
    public:
         virutal void f1()
         {
              cout<<"B::f1()"<<endl;
         }
         void f2()               //这里重新定义了父类的non-virtual函数，是一个不好的设计，因为它会覆盖掉从父类继承而来的函数f1()
         {
              cout<<"B::f2"<<endl;
         }
    };
    
    int main()
    {
         B* pB = new B();
         A* pA = new B();
         pA->f1();          //调用B::f1()
         pA->f2();          //调用A::f2()
         pB->f1();          //调用B::f1()
         pB->f2();          //调用B::f2()
         return 0;
    }

由于函数f2()是non-virtual函数，所以采用静态绑定， 编译期会在编译期根据对象的静态类型选择函数 ，pA的静态类型为A\*,所以pA->f2();调用A::f2()。函数f1()是virtual函数，采用的是动态绑定，虽然pA的静态类型为A\*，但是pA的动态类型为B，所以pA->f1();调用B::f1()。

上面都是针对对象指针的情况，对于引用（reference）的情况同样适用.至于哪些是动态绑定，哪些是静态绑定，记住一句话：**只有虚函数是动态绑定，其他都是静态绑定**。

**特殊情况：**当缺省参数和虚函数一起存在时，情况有些复杂，因为C++为了执行效率，对于虚函数的缺省参数，C++采用的是静态绑定。

例如：

class A
    {
    public:
         virtual void printVal(int x = 5)
         {
              cout<<"x = "<<x<<endl;
         }
    };
    class B:public A
    {
    public:
         virtual void printVal(int x = 10) 
         {
              cout<<"x = "<<x<<endl;
         }
    };
    
    B* pB = new B();
    A* pA = pB;
    pB->printVal();
    pA->printVal();

我们知道，pB->printVal();和pA->printVal();都将调用B::printVal()，但是它们的缺省参数是多少呢？由于缺省参数是静态绑定的，pB的静态类型为B\*，所以pB->printVal()的缺省参数是10，而pA的静态类型为A\*，所以pA->printVal()的缺省参数是5.

记住一句话：绝不重新定义继承而来的缺省参数值。具体可参考《Effective C++》这本书。