C++中的静态绑定和动态绑定

C++在面向对象编程中,存在着静态绑定和动态绑定的定义,本节即是主要讲述这两点区分。
我是在一个类的继承体系中分析的,因此下面所说的对象一般就是指一个类的实例。
首先我们需要明确几个名词定义:

  • 静态类型:对象在声明时采用的类型,在编译期既已确定;
  • 动态类型:通常是指一个指针或引用目前所指对象的类型,是在运行期决定的;
  • 静态绑定:绑定的是静态类型,所对应的函数或属性依赖于对象的静态类型,发生在编译期;
  • 动态绑定:绑定的是动态类型,所对应的函数或属性依赖于对象的动态类型,发生在运行期;

从上面的定义也可以看出,非虚函数一般都是静态绑定,而虚函数都是动态绑定(如此才可实现多态性)。
先看代码和运行结果:

 1 class A
 2 {
 3 public:
 4     /*virtual*/ void func(){ std::cout << "A::func()\n"; }
 5 };
 6 class B : public A
 7 {
 8 public:
 9     void func(){ std::cout << "B::func()\n"; }
10 };
11 class C : public A
12 {
13 public:
14     void func(){ std::cout << "C::func()\n"; }
15 };

下面逐步分析测试代码及结果,

1 C* pc = new C(); //pc的静态类型是它声明的类型C*,动态类型也是C*;
2 B* pb = new B(); //pb的静态类型和动态类型也都是B*;
3 A* pa = pc;      //pa的静态类型是它声明的类型A*,动态类型是pa所指向的对象pc的类型C*;
4 pa = pb;         //pa的动态类型可以更改,现在它的动态类型是B*,但其静态类型仍是声明时候的A*;
5 C *pnull = NULL; //pnull的静态类型是它声明的类型C*,没有动态类型,因为它指向了NULL;

如果明白上面代码的意思,请继续, 

1 pa->func();      //A::func() pa的静态类型永远都是A*,不管其指向的是哪个子类,都是直接调用A::func();
2 pc->func();      //C::func() pc的动、静态类型都是C*,因此调用C::func();
3 pnull->func();   //C::func() 不用奇怪为什么空指针也可以调用函数,因为这在编译期就确定了,和指针空不空没关系;

 如果注释掉类C中的func函数定义,其他不变,即

1 class C : public A
2 {
3 };
4 
5 pa->func();      //A::func() 理由同上;
6 pc->func();      //A::func() pc在类C中找不到func的定义,因此到其基类中寻找;
7 pnull->func();   //A::func() 原因也解释过了;

如果为A中的void func()函数添加virtual特性,其他不变,即

1 class A
2 {
3 public:
4     virtual void func(){ std::cout << "A::func()\n"; }
5 };
6 
7 pa->func();      //B::func() 因为有了virtual虚函数特性,pa的动态类型指向B*,因此先在B中查找,找到后直接调用;
8 pc->func();      //C::func() pc的动、静态类型都是C*,因此也是先在C中查找;
9 pnull->func();   //空指针异常,因为是func是virtual函数,因此对func的调用只能等到运行期才能确定,然后才发现pnull是空指针;

分析:
在上面的例子中,

1. 如果基类A中的func不是virtual函数,那么不论pa、pb、pc指向哪个子类对象,对func的调用都是在定义pa、pb、pc时的静态类型决定,早已在编译期确定了。

    同样的空指针也能够直接调用no-virtual函数而不报错(这也说明一定要做空指针检查啊!),因此静态绑定不能实现多态;

2. 如果func是虚函数,那所有的调用都要等到运行时根据其指向对象的类型才能确定,比起静态绑定自然是要有性能损失的,但是却能实现多态特性;

 本文代码里都是针对指针的情况来分析的,但是对于引用的情况同样适用。

至此总结一下静态绑定和动态绑定的区别
1. 静态绑定发生在编译期,动态绑定发生在运行期;

2. 对象的动态类型可以更改,但是静态类型无法更改;

3. 要想实现动态,必须使用动态绑定;

4. 在继承体系中只有虚函数使用的是动态绑定,其他的全部是静态绑定;

 建议:

绝对不要重新定义继承而来的非虚(non-virtual)函数(《Effective C++ 第三版》条款36),因为这样导致函数调用由对象声明时的静态类型确定了,而和对象本身脱离了关系,没有多态,也这将给程序留下不可预知的隐患和莫名其妙的BUG;

 

另外,在动态绑定也即在virtual函数中,要注意默认参数的使用。当缺省参数和virtual函数一起使用的时候一定要谨慎,不然出了问题怕是很难排查。
看下面的代码:

 1 class E
 2 {
 3 public:
 4     virtual void func(int i = 0)
 5     { 
 6         std::cout << "E::func()\t"<< i <<"\n";
 7     }
 8 };
 9 class F : public E
10 {
11 public:
12     virtual void func(int i = 1)
13     {
14         std::cout << "F::func()\t" << i <<"\n";
15     }
16 };
17 
18 void test2()
19 {
20     F* pf = new F();
21     E* pe = pf;
22     pf->func(); //F::func() 1  正常,就该如此;
23     pe->func(); //F::func() 0  哇哦,这是什么情况,调用了子类的函数,却使用了基类中参数的默认值!
24 }

为什么会有这种情况,请看《Effective C++ 第三版》 条款37。
这里只给出建议:
绝对不要重新定义一个继承而来的virtual函数的缺省参数值,因为缺省参数值都是静态绑定(为了执行效率),而virtual函数却是动态绑定。

 

posted @ 2014-04-10 23:44  lizhenghn  阅读(17062)  评论(5编辑  收藏
无觅关联推荐,快速提升流量