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

转自:http://blog.csdn.net/chgaowei/article/details/6427731

为了支持c++的多态性,才用了动态绑定和静态绑定。理解他们的区别有助于更好的理解多态性,以及在编程的过程中避免犯错误。
需要理解四个名词:
1、对象的静态类型:对象在声明时采用的类型。是在编译期确定的。
2、对象的动态类型:目前所指对象的类型。是在运行期决定的。对象的动态类型可以更改,但是静态类型无法更改。
关于对象的静态类型和动态类型,看一个示例:

 1 class B
 2 {
 3 }
 4 class C : public B
 5 {
 6 }
 7 class D : public B
 8 {
 9 }
10 D* pD = new D();//pD的静态类型是它声明的类型D*,动态类型也是D*
11 B* pB = pD;//pB的静态类型是它声明的类型B*,动态类型是pB所指向的对象pD的类型D*
12 C* pC = new C();
13 pB = pC;//pB的动态类型是可以更改的,现在它的动态类型是C*
1 3、静态绑定:绑定的是对象的静态类型,某特性(比如函数)依赖于对象的静态类型,发生在编译期。
2 4、动态绑定:绑定的是对象的动态类型,某特性(比如函数)依赖于对象的动态类型,发生在运行期。
 1 class B
 2 {
 3     void DoSomething();
 4     virtual void vfun();
 5 }
 6 class C : public B
 7 {
 8     void DoSomething();//首先说明一下,这个子类重新定义了父类的no-virtual函数,这是一个不好的设计,会导致名称遮掩;这里只是为了说明动态绑定和静态绑定才这样使用。
 9     virtual void vfun();
10 }
11 class D : public B
12 {
13     void DoSomething();
14     virtual void vfun();
15 }
16 D* pD = new D();
17 B* pB = pD;

让我们看一下,pD->DoSomething()和pB->DoSomething()调用的是同一个函数吗?
不是的,虽然pD和pB都指向同一个对象。因为函数DoSomething是一个no-virtual函数,它是静态绑定的,也就是编译器会在编译期根据对象的静态类型来选择函数。pD的静态类型是D*,那么编译器在处理pD->DoSomething()的时候会将它指向D::DoSomething()。同理,pB的静态类型是B*,那pB->DoSomething()调用的就是B::DoSomething()。

让我们再来看一下,pD->vfun()和pB->vfun()调用的是同一个函数吗?
是的。因为vfun是一个虚函数,它动态绑定的,也就是说它绑定的是对象的动态类型,pB和pD虽然静态类型不同,但是他们同时指向一个对象,他们的动态类型是相同的,都是D*,所以,他们的调用的是同一个函数:D::vfun()。

上面都是针对对象指针的情况,对于引用(reference)的情况同样适用。

指针和引用的动态类型和静态类型可能会不一致,但是对象的动态类型和静态类型是一致的。
D D;
D.DoSomething()和D.vfun()永远调用的都是D::DoSomething()和D::vfun()。

至于那些事动态绑定,那些事静态绑定,有篇文章总结的非常好:
我总结了一句话:只有虚函数才使用的是动态绑定,其他的全部是静态绑定。目前我还没有发现不适用这句话的,如果有错误,希望你可以指出来。

特别需要注意的地方
当缺省参数和虚函数一起出现的时候情况有点复杂,极易出错。我们知道,虚函数是动态绑定的,但是为了执行效率,缺省参数是静态绑定的。

 1 class B
 2 {
 3  virtual void vfun(int i = 10);
 4 }
 5 class D : public B
 6 {
 7  virtual void vfun(int i = 20);
 8 }
 9 D* pD = new D();
10 B* pB = pD;
11 pD->vfun();
12 pB->vfun();

有上面的分析可知pD->vfun()和pB->vfun()调用都是函数D::vfun(),但是他们的缺省参数是多少?
分析一下,缺省参数是静态绑定的,pD->vfun()时,pD的静态类型是D*,所以它的缺省参数应该是20;同理,pB->vfun()的缺省参数应该是10。编写代码验证了一下,正确。
对于这个特性,估计没有人会喜欢。所以,永远记住:
“绝不重新定义继承而来的缺省参数(Never redefine function’s inherited default parameters value.)”

关于c++语言
目前我基本上都是在c++的子集“面向对象编程”下工作,对于更复杂的知识了解的还不是很多。即便如此,到目前为止编程时需要注意的东西已经很多,而且后面可能还会继续增多,这也许是很多人反对c++的原因。
c++是Google的四大官方语言之一。但是Google近几年确推出了go语言,而且定位是和c/c++相似。考虑这种情况,我认为可能是Google的程序员们深感c++的复杂,所以想开发一种c++的替代语言。有时间要了解一下go语言,看它在类似c++的问题上时如何取舍的。

时间: 2025-01-02 18:35:13

深入理解C++的动态绑定和静态绑定的相关文章

【转】深入理解C++的动态绑定和静态绑定 & 不要重定义虚函数中的默认参数

为了支持c++的多态性,才用了动态绑定和静态绑定.理解他们的区别有助于更好的理解多态性,以及在编程的过程中避免犯错误.需要理解四个名词:1.对象的静态类型:对象在声明时采用的类型.是在编译期确定的.2.对象的动态类型:目前所指对象的类型.是在运行期决定的.对象的动态类型可以更改,但是静态类型无法更改.关于对象的静态类型和动态类型,看一个示例: class B { } class C : public B { } class D : public B { } D* pD = new D();//p

java中的动态绑定与静态绑定

首先是方法的参数是父类对象,传入子类对象是否可行 然后引出Parent p = new Children(); 这句代码不是很理解,google的过程中引出向上转型 要理解向上转型又引出了动态绑定 从动态绑定又引出了静态绑定   程序绑定的概念: 绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来.对java来说,绑定分为静态绑定和动态绑定:或者叫做前期绑定和后期绑定   静态绑定: 在程序执行前方法已经被绑定,此时由编译器或其它连接程序实现.例如:C. 针对java简单的可以理解为程序

再次探讨C++的动态绑定和静态绑定

以前在学习C++的时候,对动态绑定和静态绑定的理解是:静态绑定是编译时决定的,非虚函数基本都是静态绑定:而动态绑定用于虚函数,是为了实现多态.这样理解没什么大的问题,但我一直疑惑的是,既然静态绑定可以在编译的时候觉得,为什么动态绑定不可以呢? 这篇文章写的很好:http://blog.csdn.net/chgaowei/article/details/6427731 我知道了 静态类型 和 动态类型 两个概念(惭愧): 1.对象的静态类型:对象在声明时采用的类型.是在编译期确定的. 2.对象的动

动态绑定与静态绑定

对指针来说: 动态类型与静态类型: 动态类型是所指向的对象类型,这发生在程序运行期,静态类型是声明时指针时候,指针本身的类型,这发生在编译期 所以说静态类型声明好后就不发生改变了,动态类型,可以运行改变,也就是允许指向不同的对象类型 如: //基类 class A { public: // }; //子类 class B:public A { // }; // pa静态类型为 A ,动态类型也是 A A *pa = new A(); //pb静态类型为B,动态类型也是B B *pb = new

c++的动态绑定和静态绑定

为了支持c++的多态性,才用了动态绑定和静态绑定. 1.对象的静态类型:对象在声明时采用的类型.是在编译期确定的. 2.对象的动态类型:目前所指对象的声明.在运行期决定.对象的动态类型可以更改,但是静态类型无法更改. 关于对象的静态类型和动态类型,看一个示例: class A{}; class B: public A{}; class C: public A{}; int main() { C *pc=new C();//pc的静态类型是它声明的类型C*,动态类型也是C* A *pa=pc;//

java的动态绑定和静态绑定

首先是方法的参数是父类对象,传入子类对象是否可行然后引出Parent p = new Children();这句代码不是很理解,google的过程中引出向上转型要理解向上转型又引出了动态绑定从动态绑定又引出了静态绑定 程序绑定的概念:绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来.对java来说,绑定分为静态绑定和动态绑定:或者叫做前期绑定和后期绑定 静态绑定:在程序执行前方法已经被绑定,此时由编译器或其它连接程序实现.例如:C.针对java简单的可以理解为程序编译期的绑定:这里特别

动态绑定 vs 静态绑定

动态绑定(又名后期绑定) 动态绑定是指编译器在编译阶段不知道要调用哪个方法,直到运行时才能确定.让我们用个例子来解释.譬如我们有一个叫作'SuperClass'的父类,还有一个继承它的子类'SubClass'.现在SuperClass引用也可以赋给SubClass类型的对象.如果SuperClass中有个someMethod()的方法,而子类也重写了这个方法,那么当调用SuperClass引用的这个方法的时候,编译器不知道该调用父类还是子类的方法,因为编译器不知道对象到底是什么类型,只有到运行时

交换机端口安全配置实验(MAC动态绑定和静态绑定)

1. 根据拓扑完成上图 ,可以配置pc的地址为192.168.1.1-192.168.1.42. 配置安全端口Switch>enableswitch#conf tSwitch(config)#interface f0/1Switch(config-if)#switchport mode access 配置access模式Switch(config-if)#switchport port-security 开启安全端口Switch(config-if)# do show port inter f0

函数的动态绑定和静态绑定

先看一个例子:Widget类中有个虚函数和一个非虚函数.指针变量pWidget的值是NULL.通过指针调用非虚函数和虚函数. class Widget{ public: virtual void virtual_flip(){ cout << "virtual func" << endl; } void nonvirtual_flip(){ cout << "nonvirtual func" << endl; } };