多态和动态绑定(polymorphism and dynamic binding)

最新推荐文章于 2020-04-01 22:56:14 发布
最新推荐文章于 2020-04-01 22:56:14 发布
阅读量1.4k 收藏
点赞数
文章标签： binding c
本文探讨了C++中多态和动态绑定的概念及其重要性。通过这些特性，子类对象可以作为基类对象使用，使得函数可以根据实际对象类型而非引用类型执行相应的行为。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

FAQ 5.11 多态和动态绑定(polymorphism and dynamic binding)

C++的这种特点使新的代码多少可以替代一些旧的代码:

面向对象程序强大的真正原因不在于继承;而在于它可以将继承类对象当作基类对象来对待,支持这个特性的机制是多态和动态绑定(polymorphism and dynamic binding),

多态允许将一个继承类的对象传递给一个接受基类的引用或指针的函数.接受这种对象的函数被称为多态函数.

当一个多态函数调用一个使用基类引用或指针的成员函数时,动态绑定执行继承类的代码,尽管多态函数可能没有察觉到继承类的存在,这种代码的实现是依赖于对象的类型而不是依赖于引用或指针的类型,继承类的对象代替基类的对象并不需要使用对象的多态函数做任何改变.

 

jia_xiaoxin
关注
C++对象模型中的动态绑定(Dynamic Binding)详解及其应用场景与原理分析
03-25
内容概要：该篇文章全面解读了C++中的动态绑定(Dynamic Binding)，一个用于实现运行时多态的关键机制。文中解释了静态对象类型和动态对象类型、静态绑定与动态绑定的区别，以及实现动态绑定所需的三大前提——基类...
浅谈Java中的重载,重写,多态，静态绑定、动态绑定
08-28
静态绑定（Static Binding）和动态绑定（Dynamic Binding）是 Java 中的绑定机制。静态绑定是指在编译时确定方法的调用，例如，在上面的代码中，我们调用 `sup1.staticGet()`，在编译时，Java 编译器已经确定了这个...
虚函数（virtual）与多态（polymorphism）、动态绑定（dynamic binding）
churenxh的专栏
04-27 1255
虚函数（virtual）与多态（polymorphism）、动态绑定（dynamic binding）  首先介绍虚函数、多态、动态绑定的的概念：1．虚函数产生意义：就是“违反”“如果你以一个基类指针指向一个派生类的对象，那么通过该指针你就只能够调用基类所定义的成员函数”这条规定而诞生的。简言之，就是在派生类的成员函数前面加“virtual“关键字就变成了虚函数。基类指针就可以调用
Java中的多态(polymorphism)和动态绑定(dynamic binding)
lichengyu的专栏
11-29 3990
以下面代码为例，存在超类Employee和子类Manager，两个类中都有getSalary方法，但实现不同。一个对象变量可以引用多种实际类型的现象被称为多态(polymorphism)，运行时能够自动选择调用哪个方法的现象称为动态绑定(dynamic binding)。Employee类型的变量e既可以引用Employee类型又可以引用Manager类型，称为多态；调用e.getSalary时，根
C++ 中的虚函数和运行时多态 (polymorphism) - Virtual Functions and Runtime Polymorphism in C++
程永强
04-01 610
C++ 中的虚函数和运行时多态 (polymorphism) - Virtual Functions and Runtime Polymorphism in C++ The main thing to note about the program is that the derived class’s function is called using a base class pointer. 有关该程序的主要注意事项是使用基类指针调用派生类的函数。 The idea is that virtual fun
多态 编译器&运行期绑定
专注！切记浮躁
08-11 1600
名词解释： 多态： 面向对象语言的一个重要特征：多态（polymorphism）。以专业术语来讲，是一种运行期绑定(run-time binding)机制，,通过这种机制，实现函数名绑定到具体实现代码的目的。 入口地址： 执行程序时，构成程序的函数在内存中拥有自己的存储空间，而一个函数在内存中的起始地址被称为入口地址，函数名与入口地址是紧密相连的。 运行期绑定： 函数的地址在运行时确定
dynamic binding
diaoju3333的博客
01-18 195
Late binding, ordynamic binding,[1]is a computer programming mechanism in which the method being called upon an object or the function being called with arguments is looked up by name atruntim...
关于继承多态及动态绑定.pdf
12-05
动态绑定（Dynamic Binding 或 Late Binding）是C++实现多态性的基础。它涉及到虚函数表（Virtual Table，简称V-Table）。每个含有虚函数的类都有一个虚函数表，其中存储了该类所有虚函数的地址。在对象实例的内存...
Objective-C-2.0程序设计-第9章-多态、动态类型和动态绑定PPT课件.ppt
07-30
在Objective-C 2.0程序设计中，多态（Polymorphism）、动态类型（Dynamic Typing）和动态绑定（Dynamic Binding）是面向对象编程的重要概念，它们为代码提供了灵活性和可扩展性。本章主要围绕这三大主题展开，通过一...
ObjectiveC程序设计多态动态类型和动态绑定PPT教案学习.pptx
09-30
在Objective-C中，多态（Polymorphism）、动态类型（Dynamic Typing）和动态绑定（Dynamic Binding）是核心概念，它们是实现面向对象程序设计灵活性和可扩展性的关键。 9.1 多态（相同的名称，不同的类） 多态是指...
python的动态绑定
edward_zcl的博客
11-27 1193
这几天看了一本书，感觉写挺好的，作者有一小节是说用了python的动态特性，不同于C语言中的静态类，能够实现非常出乎意料的功能。这里面用到了动态绑定，一查才发现，这背后的知识更加丰富。。 先贴一张截图吧。。 这就是我看的那本书的那一小节的介绍。代码的话可以参考：https://download.youkuaiyun.com/download/edward_zcl/12001634 其中关于多重继承，类...
多态（Polymorphism）
songuo' s home
08-26 688
Polymorphic method invocations apply only to instance methods. You can always refer to an object with a more general reference variable type (a superclass or interface), but at runtime, the ONLY thi
python动态绑定的特性
u012631731的博客
01-17 439
python作为一种脚本语言，无需编译，解释执行，在使用python的过程中运用了动态绑定的这一特性，故此总结一下；先看一段代码：dynamic.pyclass People(object):    def test(self):        print "this is a function in class"def test():    print "this is a test funct
对象的自身引用（Self-Reference） 动态绑定（Dynamic Binding）
weixin_30809173的博客
09-12 427
对象的自身引用（Self-Reference） class A { int x; static A &a; public : A():a(*this){} A(int x, A& aa):x(x),a(aa){} }; void main() { A a1; A a2(1, a1); } 类引用自身须是static方式，目的取消类的基类独立性，禁止派生...
C++ - 继承(inheritance) 和 动态绑定(dynamic binding) 简介
weixin_34024034的博客
11-12 279
继承(inheritance) 和 动态绑定(dynamic binding) 简介 本文地址: http://blog.youkuaiyun.com/caroline_wendy/article/details/15646601 继承(inheritance)和动态绑定(dynamic binding) 是面向对象的重要组成部分, 即继承(inheritance)和多态...
python 动态绑定属性
彦文的专栏
08-22 767
hasattr 判断是否拥有属性 setattr 设置 属性值 self.i=xx 这种方式 会变成class.i=xx 增加了个i的属性 而不是i值的属性 class Event(Base): name = "" id="" def __init__(self,dict): for i in dict.keys(): if h...
(Python编程)扩展模块的细节
金庆的专栏
01-29 5155
Programming Python, 3rd Edition 翻译最新版本见：http://wiki.woodpecker.org.cn/moin/PP3eD22.5. Extension Module Details22.5. 扩展模块的细节Now that Ive shown you the somewhat longer story, lets fill in the rest. Th
python 延迟绑定（late binding）
张帅的博客
07-15 1936
#!/usr/bin/env python3 # -*- coding: utf-8 -*-' a test module '__author__ = 'Zhang Shuai' def operator(): return [lambda n: n * m for m in range(6)]print([o(3) for o in operator()]) # 这是由于闭包函数引用的外部
Python基础-动态绑定属性
柠檬柠檬C的博客
06-13 1846
动态绑定属性绑定属性正常情况下，当我们定义了一个class，创建了一个class的实例后，我们可以给该实例绑定任何属性和方法，这就是动态语言的灵活性。先定义class：class Student(object): pass可以看到这个类是没有自己写一些属性。stu1 = Student(); stu1.name = 'Tom' #动态绑定一个属性#查看这个属性 print(stu1.name
怎么理解支持多态 和运行时动态绑定？
最新发布
07-03
<think>我们正在讨论面向对象编程中的多态和运行时动态绑定。根据引用内容，多态分为运行时多态和编译时多态。运行时多态通过虚函数（或类似机制）实现，而编译时多态通过函数重载实现。动态绑定发生在运行时，根据对象的实际类型决定调用哪个方法；静态绑定则在编译时确定。引用[1]和[2]解释了多态的两种类型：运行时多态（动态多态）和编译时多态（静态多态）。动态多态通过覆盖虚函数实现，在运行时根据对象实际类型决定调用哪个方法。静态多态通过重载实现，在编译时根据参数类型、数量等确定调用哪个方法。引用[3]和[4]给出了具体的代码示例，展示了运行时多态（动态绑定）的工作方式：当基类指针或引用指向派生类对象时，调用虚函数会执行派生类中的重写版本。现在，我将详细解释运行时多态和动态绑定：1.**多态（Polymorphism）**：在面向对象编程中，多态是指同一个操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。多态分为两种：- **编译时多态（静态绑定）**：通过函数重载和运算符重载实现，在编译阶段确定具体调用哪个函数。- **运行时多态（动态绑定）**：通过继承和虚函数（或类似机制）实现，在程序运行时根据对象的实际类型确定调用哪个函数。2. **运行时多态（动态多态）**：其核心在于使用基类的指针或引用指向派生类对象，并通过该指针或引用调用虚函数。在运行时，系统会根据对象的实际类型（而不是指针或引用的类型）来调用相应的函数。这需要满足两个条件：-基类中声明虚函数（在C++中使用`virtual`关键字，在Java中所有非静态方法默认是虚函数）。-派生类重写（override）该虚函数。3.**动态绑定（Dynamic Binding）**：也称为晚期绑定（Late Binding），是指在程序运行期间（而非编译期间）根据对象的实际类型来确定调用哪个函数。动态绑定是实现运行时多态的基础。4. **示例分析**（引用[4]中的Java代码，但原理与C++相同）：```javaclass Animal1 {publicString name;public intage;publicAnimal1(String name, intage){this.name= name;this.age= age;}public voideat(){System.out.println(this.name +"正在吃东西");}}classDog1extends Animal1 {publicDog1(String name, intage){super(name, age);}public voideat(){//重写父类的eat方法System.out.println(this.name +"吃狗粮");}}class Cat1 extendsAnimal1{public Cat1(Stringname,int age) {super(name,age);}publicvoid eat() {//重写父类的eat方法System.out.println(this.name+ "吃猫粮");}}publicclass demot {publicstatic voidmain(String[] args) {Animal1 animal= newDog1("小黄",2);//父类引用指向子类对象animal.eat();//输出：小黄吃狗粮}}```在这个例子中：-我们创建了一个`Animal1`类型的引用`animal`，但它指向的是`Dog1`类的对象。-当调用`eat()`方法时，由于在Java中非静态方法默认是虚函数（相当于C++中的`virtual`），所以会动态绑定到`Dog1`类的`eat()`方法，输出“小黄吃狗粮”。5. **动态绑定的实现机制**（以C++为例）：-当类中有虚函数时，编译器会为该类生成一个虚函数表（vtable），表中存放虚函数的地址。-每个对象在创建时，会包含一个指向虚函数表的指针（vptr）。-当通过基类指针或引用调用虚函数时，程序会通过对象的vptr找到虚函数表，再根据函数在表中的位置找到实际要调用的函数地址。这一过程在运行时完成。6.**动态绑定的优点**：-提高代码的灵活性和可扩展性：可以在不修改现有代码的情况下，通过派生类扩展功能。-实现接口重用：基类定义接口，派生类实现具体功能。7. **动态绑定的缺点**：-运行时开销：每次调用虚函数都需要通过虚函数表查找，比直接调用函数稍慢。-对象占用空间增加：每个对象需要存储一个虚函数表指针。8. **与静态绑定的对比**：|特性|静态绑定|动态绑定||--------------|------------------------------|------------------------------||绑定时间|编译时|运行时||实现机制|函数重载、模板|虚函数||性能|高效（无额外开销）|有运行时开销||灵活性|较低|高||适用场景|编译时确定类型的方法调用|运行时确定类型的方法调用|总结：运行时多态（动态绑定）是面向对象编程的核心特性之一，它允许程序在运行时根据对象的实际类型来调用相应的方法，提高了代码的灵活性和可扩展性。实现运行时多态的关键是使用虚函数（或类似机制）和继承。 §§相关问题§§1.在C++中，虚函数表（vtable）的具体结构是怎样的？ 2.动态绑定在多重继承中如何工作？3.除了虚函数，还有哪些机制可以实现运行时多态？ 4.动态绑定在Java和C++中的实现有何异同？</think>### 面向对象编程中的多态与运行时动态绑定详解 #### 1. **多态的核心概念** 多态（Polymorphism）是面向对象三大特性之一，指**同一操作作用于不同对象时产生不同行为**。分为两类： - **编译时多态（静态绑定）** 通过函数重载实现，编译器根据**参数类型和数量**在编译阶段确定调用哪个方法。 ```java // 函数重载示例 void print(int x) { ... } // 版本1 void print(String s) { ... } // 版本2 ``` 调用 `print(5)` 时编译器直接绑定版本1 [^1][^2]。 - **运行时多态（动态绑定）** 通过继承和虚函数实现，**运行时**根据对象的**实际类型**决定调用哪个方法。 ```java Animal animal = new Dog(); // 父类引用指向子类对象 animal.eat(); // 实际调用Dog.eat() ``` 输出结果："小黄吃狗粮"（见引用[4]）[^3][^4]。 #### 2. **运行时动态绑定机制** 动态绑定是运行时多态的实现基础，包含三个核心要素： 1. **继承关系** 子类继承父类（如 `Dog extends Animal`） 2. **虚函数（或等效机制）** 父类方法声明为 `virtual`（C++）或默认虚函数（Java） 3. **向上转型** 父类引用指向子类对象（`Animal animal = new Dog()`） **执行过程**： ```mermaid graph TD A[调用animal.eat] --> B{检查对象实际类型} B -->|实际是Dog| C[调用Dog.eat] B -->|实际是Cat| D[调用Cat.eat] ``` - 当调用 `animal.eat()` 时，JVM/C++运行时会： 1. 查找 `animal` 引用的**实际对象类型**（非声明类型） 2. 根据实际类型（如 `Dog`）调用其重写的方法 [^3][^4] #### 3. **关键特性对比 | **特性** | **静态绑定（编译时多态）** | **动态绑定（运行时多态）** | |----------------|----------------------------------|----------------------------------| | **绑定时机** | 编译阶段 | 运行阶段 | | **决定因素** | 参数类型/数量 | 对象实际类型 | | **实现方式** | 函数重载 | 虚函数+继承 | | **性能** | 高效（直接调用） | 有开销（需运行时查表） | | **灵活性** | 低（行为在编译时固定） | 高（行为可运行时扩展） | #### 4. **设计意义与价值 1. **接口统一性** ```java void makeSound(Animal animal) { animal.speak(); // 统一接口，支持所有Animal子类 } ``` 调用 `makeSound(new Dog())` 和 `makeSound(new Cat())` 产生不同行为 [^3]。 2. **可扩展性** 新增子类（如 `Bird`）无需修改现有代码，符合开闭原则。 3. **降低耦合** 调用方只需关注父类接口，无需知道具体子类实现。 #### 5. **动态绑定实现原理（以Java为例） - **虚方法表（vtable）** 每个类维护一个虚方法表，存储可重写方法的实际地址。 - **对象头中的类型指针** 对象内存布局包含指向类信息的指针，运行时通过该指针查找虚方法表。 - **调用过程伪代码**： ```java // 运行时解析调用 Method method = object.getClass().getMethod("eat"); method.invoke(object); // 动态调用实际对象的方法 ``` > **关键总结**：运行时多态通过**延迟绑定**将方法调用与实现分离，使程序能根据上下文自适应调整行为，这是设计模式（如策略模式、工厂模式）的基础[^1]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值