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

深入理解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++》这本书。