迟绑定早绑定

最新推荐文章于 2024-11-14 23:41:42 发布
最新推荐文章于 2024-11-14 23:41:42 发布
阅读量2.4k 收藏
点赞数
文章标签： binding 编译器 function linker compiler java

1、        概念
首先，什么是绑定？( what`s the definition of binding? )

c++编程思想上有说到：
Connecting a function call to a function body is called binding.（将函数体和函数调用关联起来，就叫绑定）
然后，那么什么是早绑定？（Early binding）
When binding is performed before the program is run (by the compiler and linker), it' s called early binding
在程序运行之前（也就是编译和链接时），执行的绑定是早绑定。
然后，什么是迟绑定？（late binding）
late binding, which means the binding occurs at runtime, based on the type of the object.
When a language implements late binding, there must be some mechanism to determine the

type of the object at runtime and call the appropriate member function

迟绑定发生在运行时，基于不同类型的对象。当一种语言实现迟绑定时，必须有某种机制确定对象的具体类型然后调用合适的成员函数。
2、         结论
2.1对于含有虚拟函数的类来说：
Ø        虚函数表是与类关联的，也就是说，一个类只有一张虚函数表。（从这个方面上说，虚函数类似于类的静态函数）（父类有一个Vtable，子类也有一个Vtable）
Ø        VTable中虚函数的位置是由基类决定的，所以，哪怕你在派生类中不是按基类的顺序来重写虚函数，派生类的VTable中虚函数的存放顺序和基类的也是一样的。
Ø        虚函数指针VPtr是与对象关联的，每个对象都有一个虚函数指针，但是，同类的对象的虚函数指针的值是相同的。因为都指向该类的虚函数表。
Ø        虚函数指针VPtr的值是在调用构造函数时进行初始化的（自动完成）。

2.2 C++迟绑定实现机理流程（编译器都是类似于此种方式实现的）：
（1）为每个含有虚函数的类（基类以及派生类）都创建一张虚函数表(VTable，存储于常量区)，依次存放虚函数的地址。对于派生类来说，如果没有重写其基类的虚函数，那么，将会在VTable中存放基类的虚函数地址。
（2）为每个含有虚函数的类的对象，创建一个指针(VPtr)，指向这个类的虚函数表（所以说，同类对象的VPtr的值是一样的[*VPtr相同，但VPtr不同]，也就是说，虚函数，在这一点上，类似于类的static函数，是所有对象共有的。）（此过程发生在运行期自动调用构造函数的过程中）
（3）通过强制转换将派生类对象的地址/引用 赋给基类指针/变量（也就是向上类型转换UpCasting）（此步决定了基类指针首先寻址的虚函数表，也就是现在派生类的虚函数表中寻址，如果在派生类的虚函数表中没有找到此虚函数，则向上一级基类的虚函数表中寻找此虚函数，依次类推。由此可见，虽然代码相同，却实现了调用不同类函数的目的，也就是多态）
（4）然后，通过基类指针/引用对象 来调用虚函数（即：polymorphic call），就会通过此时基类对象的VPtr指针在所指向虚函数表中寻址(一般是从表头地址开始，加上一定的偏移量)找到相应的函数地址，也就是之前派生类VPtr指针指向的虚函数表的函数地址。
 

2．3晚绑定原理
编译器对每个包含虚函数的类创建一个表（称为V TA B L E）。在V TA B L E中，编译器放置特定类的虚函数地址。在每个带有虚函数的类中，编译器秘密地置一指针，称为v p o i n t e r（缩写为V P T R），指向这个对象的V TA B L E。通过基类指针做虚函数调用时（也就是做多态调用时），编译器静态地插入取得这个V P T R，并在V TA B L E表中查找函数地址的代码，这样就能调用正确的函数使晚捆绑发生。为每个类设置V TA B L E（编译期）、初始化V P T R（运行期构造函数中）、为虚函数调用插入代码（运行期多态调用时），所有这些都是自动发生的，所以我们不必担心这些。利用虚函数，这个对象的合适的函数就能被调用，哪怕在编译器还不知道这个对象的特定类型的情况下。（《C++编程思想》）
2.4早绑定和晚绑定优缺点
早绑定,晚绑定,早晚都要绑定。绑定指在对象和其类型间建立关联的过程。
早绑定指在对象申明的时候就和他的类型建立了关联。
晚绑定是指我们的代码在运行时再检查对象是否提供了我们所需要的方法和属性。
 很多人说C#和Java是早绑定的,javascript,python是迟绑定的,其实这个说法并不全对
一方面,C#和Java是强类型的,在变量声明的时候就说明了类型,从这里来讲当然是早绑定的,于是我们才能在IDE中享受代码提示带来的方便,因为ide通过你的申明就能知道你的对象是什么类型,具有什么方法和属性,然后提示给你,同时编译的时候也可以帮你检查许多类型转换的错误.

另一方面:无论C#和Java在实现他们很重要的一个功能:多态的时候,都是用晚绑定,比如你的父类中定义了virtual的方法,那么这个方法可能会在你的子类中重载,具体你用什么子类,是变量申明时所不知道的,在C++编译器会在编译的时候为这些类加上一个指针，指针指向一个虚表，虚表中存在着真实的函数,这个是就是一个晚绑定了
早绑定的优点是:

Ø        编译效率

Ø        代码提示(代码智能感知)

Ø        编译时类型检查

晚绑定的优点是:

Ø        不用申明类型

Ø        对象类型可以随时更改

参考资料：
http://blog.youkuaiyun.com/faithmy509/archive/2009/05/21/4207625.aspx

http://www.cnblogs.com/yizhu2000/archive/2007/07/12/815628.html

http://blog.sina.com.cn/s/blog_63797eb20100gni8.html（C++ 多态迟绑定原理）

本文来自优快云博客，转载请标明出处：http://blog.youkuaiyun.com/braveyly/archive/2010/05/03/5549978.aspx

本文来自优快云博客，转载请标明出处：http://blog.youkuaiyun.com/braveyly/archive/2010/05/03/5549978.aspx

本文来自优快云博客，转载请标明出处：http://blog.youkuaiyun.com/braveyly/archive/2010/05/03/5549978.aspx

merlin_q
关注
C++ 多态（迟绑定）真正原理
beckle_ye的专栏
10-19 3031
今天看到一篇帖子关于虚函数的问题，原以为自己已经对c++虚函数，多态了解的不错了，但是，还是发现有一些模糊点，所以，又回头重新总结了一番。 有了不小的收获，下面，就和大家一起来分享一下，也希望对一些朋友起到一定的帮助。首先先梳理一下概念，以前似乎对概念不是很重视，其实不然，真正对一个东西的定义了解了很透，才能去深入挖掘这个东西的内涵。 好，首先，什么是绑定？( what`s t
C++调用空指针对象的成员函数——静态绑定与动态绑定
jiange_zh的博客
08-06 2180
最近代码中看到调用空指针对象的成员函数的写法，联想起上次碰到的问题：C++类的成员函数存储方式（是否属于类的对象）两者的本质是一样的，上次只是简单地讨论了下，这次从编译器的角度，来谈一谈这个知识点。一个简单的例子：class MyClass { public: int i; void hello() { printf("hello\n"
迟绑定早绑定，迟早都要绑定
杀出条血路来
05-02 3499
1、        概念首先，什么是绑定？( what`s the definition of binding? )c++编程思想上有说到：Connecting a function call to a function body is called binding.（将函数体和函数调用关联起来，就叫绑定）然后，那么什么是早绑定？（Early binding）When bind
类的早期绑定&迟绑定
浪潮之巅的专栏
01-19 527
对于以下的例子：#include<iostream> using namespace std; class animal { public: void sleep(){ cout<<"animal sleep"<<endl; } void breathe(){ cout<<"animal breathe"<<endl;
python闭包变量迟绑定
zx_good_night的博客
03-18 375
def foo(): return [lambda x: i + x for i in range(4)] print([x(3) for x in foo()])[6, 6, 6, 6]上述问题产生的原因是Python闭包的延迟绑定。这意味着内部函数被调用时，参数的值在闭包内进行查找。因此，当任何由foo()返回的函数被调用时，i的值将在附近的范围进行查找。那时，不管返回的函数是否被调...
java 迟绑定_迟绑定早绑定，迟早都要绑定 | 学步园
weixin_42503009的博客
02-19 387
1、概念首先，什么是绑定？( what`s the definition of binding? )c++编程思想上有说到：Connecting a function call to a function body is called binding.(将函数体和函数调用关联起来，就叫绑定)然后，那么什么是早绑定？(Early binding)When binding is performed b...
XML注释、迟绑定 COM 及其它
03-16
1、我想从某个方法中使用该方法的 XML 说明文档，这可能吗？...我还能使用它吗？我曾考虑在需要时动态生成一个程序集，但这 样做似乎有些过度。...而这个组件实现了 IDispatch 接口。3、我们的开发团队在整个 Windows ...
c++ 对比虚函数的动态绑定
11-08
在C++编程语言中，虚函数与动态绑定是面向对象编程中的重要概念，它们使得程序在运行时能够根据对象的实际类型来调用相应的成员函数，从而实现多态性。下面将详细解析C++中虚函数的动态绑定机制，以及如何通过示例...
AS绑定式与非绑定式播放音乐
qq_73704657的博客
11-14 407
绑定式服务定义：绑定服务是一种特殊类型的服务，它允许应用程序组件（如活动）与服务进行交互，从而发送请求、接收结果并与其进行通信。特点服务没有用户界面，可以在后台执行长时间运行的操作。通过绑定，组件可以获取服务的对象实例，直接调用服务中的函数，或获取服务中的状态和数据信息。服务的生命周期与其绑定的组件密切相关。当没有任何组件绑定时，服务会自动被销毁。组件之间可以通过Messenger、Binder或AIDL进行通信。普通方式（启动式服务）定义。
早绑定和晚绑定
CodingStart
06-22 7209
C++ 早绑定和晚绑定
函数延迟绑定的C++实现
Vicent_Chen的博客
04-17 708
本文基于C++实现了函数的延迟绑定，能够支持绑定除lambda以外的大部分函数
理解Python闭包与延迟绑定
xie_0723的博客
12-29 7735
Python闭包可能会在面试或者是工作中经常碰到，而提到Python的延迟绑定，肯定就离不开闭包的理解，今天总结下 关于闭包的概念以及一个延迟绑定的面试题。 Python闭包1.什么是闭包，闭包必须满足以下3个条件： 必须是一个嵌套的函数。 闭包函数必须返回嵌套函数。 嵌套函数必须引用一个外部的非全局的局部自由变量。 举个栗子# 嵌套函数但不是闭包 def nested(): def nst
python 踩坑系列之迟绑定
u011877410的博客
08-20 327
1.绑定     将函数体和函数调用关联起来，就叫绑定 2.迟绑定     在程序运行之前（也就是编译和链接时）执行的绑定是早绑定，迟绑定（late binding）是发生在运行时。 3.实例说明 def outer():     return [lambda x: x*i for i in range(3)] f1, f2, f3 = outer() print f1(1) prin...
Python中的late binding(延迟绑定)问题
june_young_fan的博客
06-07 764
延迟绑定 在Python中存在这样的一种机制，即函数或闭包中的变量值只有在函数或闭包中的内部函数执行的时候才会进行查找赋值。 下面通过一个小例子来说明这种情况： def create_multiplier(): return [lambda x : x*i for i in range(3)] for func in create_multiplier(): print...
C++什么时候进行迟绑定？
beckle_ye的专栏
10-19 874
上一篇帖子详细讨论了迟绑定的原理，那么，什么时候编译器会进行迟绑定呢？或者编译器根据什么来决定要不要进行迟绑定呢？C++编程思想说： It’s important to realize that upcasting deals only with addresses. If the compiler has an object, it knows the exact type and ther
C++多态：深入虚函数，理解晚绑定
popvip44的博客
05-26 1642
C++的多态特性是通过晚绑定实现的。晚绑定（late binding），指的是编译器或解释器程序在运行前，不知道对象的类型。使用晚绑定，无需检查对象的类型，只需要检查对象是否支持特性和方法即可。  在C++中，晚绑定通常发生在使用virtual声明成员函数时。此时，C++创建一个虚函数表，当某个函数被调用时需要从这个表中查找该函数的实际位置。通常，晚绑定也叫做动态函数分派(dynamic disp
Python中的迟绑定机制
thompson的博客
08-08 206
一个小案例，讲清Python中的迟绑定机制
在C++中使用委托实现延迟绑定
qq_33945243的博客
03-24 323
在C++中使用委托实现延迟绑定
关于迟绑定、动态联接与Java虚拟机（应用服务器）
hk201406的专栏
07-02 698
迟绑定是指在运行时选择用到的库。标准的Java迟绑定实现代码示例如下： interface Service { /* ... */ } Class cls = Class.forName(className);   // 常从XML配置中读取类名 Service svc = (Service)cls.newInstance(); 实际上，迟绑定是动态联接库（含Java的cl
– 来自百度多态其实可以简单看成就是用户执行同样的行为，但是因为执行者的差异，展现出不同的效果通常语言中会使用继承和动态绑定来实习这一目的(当然，你个年轻人不讲武德，用函数绑定来干这一件事情另谈)常规多态class A {public: virtual void f() {std::cout << "A\n";}};class B: public A {public: void f() {std::cout << "B\n";}};class C: public A {public: void f() {std::cout << "C\n";}};void demo(A* a) { a->f();}int main() { demo(new A); demo(new B); demo(new C); return 0;}12345678910111213141516171819202122232425直接使用std::function第二种并算不上一种方法，但是在只有一个两个虚函数时还是有用途的class A {public: std::function<void()> f; explicit A(std::function<void()>&&fun): f(std::move(fun)){}};void demo(A* a) { a->f();}int main() { demo(new A([]() {std::cout << "A\n";})); demo(new A([]() {std::cout << "B\n";})); demo(new A([]() {std::cout << "C\n";}));}123456789101112131415上述都是迟绑定在c++里面，若是要实现多态的话，实现多态利用的虚表来实现的迟绑定（类似于std::function），虚表中存放好对应函数的调用地址，以此来实现运行时选择但是，运行时绑定也不是没有负担C++中内存布局函数不能内联和优化虚表再怎么都需要占用一个指针的空间，不然，如何存放虚表指针由于是运行时决定，而不是早绑定，需要通过虚表去寻找调用地址，中间存在一个过程（虽然可以忽略不计，但是不计较今天怎么说CRTP呢？）。c++的虚表可以满足需求了c++是一门多样化的语言多样化让c++变得可以选择的方式变多了（比如上述的直接利用std::function来搞，你只管实现，剩下的交给编译器）CRTP，一般类似于这种形式template<typename T>class A {public: T* self() {return static_cast<T*>(this);} };class B: public A<B>{ };123456789核心在于，父类是个模板，模板有个参数是子类对于父类来说，只需要知道子类的名称可以生成一个指针就可以了父类在实例化时只需要有子类的声明的就ok了，由于传入的模板类会继承自己，所以自己可以向下转这个指针。于是，我们就可以这样玩：template <typename D> class Base { void f_impl(); int add_impl(int a, int b); D *self() { return static_cast<D *>(this); }protected: Base() {}public: void f() { self()->f_impl(); } int add(int a, int b) { return self()->add_impl(a, b); }};class A : public Base<A> {public: int x; A(int v): x(v) {} int add_impl(int a, int b) {return x + a + b;} void f_impl() { std::cout << "A\n"; }};class B : public Base<B> {public: int x; B(int v): x(v) {} int add_impl(int a, int b) {return x + a + b;} void f_impl() { std::cout << "B\n"; }};int main() { Base<A> *t = new A(1); t->f(); std::cout << t->add(1, 2) << "\n"; Base<B> *p = new B(1); p->f(); std::cout << p->add(1, 2) << "\n"; return 0;}12345678910111213141516171819202122232425262728293031323334353637不让父类生成对象父类只声明具体函数实现其实只是交给编译器，去codegen 生成了 几分不同的 base <T> 的类所有行为发生在编译期上述main代码里面还是重复代码了，我们是“多态”，当然要做一个统一的动作呢统一动作呢，当然也要统一生成
最新发布
04-04
### C++中的多态实现方式 C++支持两种主要的多态形式：静态多态（编译期多态）和动态多态（运行时多态）。 - **静态多态**通常由函数重载和模板机制提供，在编译阶段完成绑定。这种多态不涉及任何运行时开销。 - **动态多态**则依赖于虚函数机制，允许通过基类指针或引用调用派生类的方法[^2]。 #### 虚函数与动态绑定 虚函数是C++中实现动态多态的核心工具之一。它利用虚拟表（vtable）来存储指向具体方法的地址列表，从而实现在运行时决定调用哪个版本的函数。这种方式虽然灵活，但在每次调用虚函数时都需要额外查找操作，因此会产生一定的性能开销[^3]。 --- ### CRTP模式及其工作原理 CRTP（Curiously Recurring Template Pattern）是一种基于模板元编程的技术，用于在编译期间实现类似于继承的行为。其基本思想是让派生类作为模板参数传递给基类，从而使基类能够访问派生类的成员和类型定义[^1]。 以下是CRTP的一个典型例子： ```cpp template<typename Derived> class Base { public: void interface() { static_cast<Derived*>(this)->implementation(); } }; class Derived : public Base<Derived> { private: friend class Base<Derived>; void implementation() { // 具体实现逻辑 } }; ``` 在这个例子中，`Base` 类通过 `static_cast` 将自己转换为具体的派生类类型，并调用该类型的私有方法 `implementation()`。由于整个过程发生在编译期，所以不需要借助虚函数表或其他运行时机制，也就避免了相应的性能损失。 --- ### 编译期绑定 vs 运行时绑定 | 特性 | 编译期绑定 (CRTP) | 运行时绑定 (虚函数) | |---------------------|--------------------------------------------|--------------------------------------| | **绑定时间** | 编译器解析 | 程序执行过程中 | | **灵活性** | 不支持完全未知的子类 | 支持任意数量的未预见子类 | | **性能影响** | 几乎无额外成本 | 存在 vtable 查找带来的轻微延迟 | | **适用场景** | 性能敏感场合 | 设计复杂、扩展性强的应用框架 | 对于高性能需求的场景，比如数值计算库 Eigen 或通用算法库 Boost，更倾向于采用 CRTP 来减少不必要的运行时开销。 --- ### 结论 综上所述，C++ 提供了多种手段来实现多态行为。如果目标是最优性能，则应优先考虑像 CRTP 这样的技术；而当系统的重点在于可维护性和扩展能力时，传统的虚函数可能是更好的选择。最终的选择取决于实际应用的需求权衡。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值