动态绑定现象

动态调度Dynamic dispatch

在计算机科学中，动态调度（Dynamic dispatch）是指运行时选择哪一个多态操作的实现（方法或函数）来调用的过程。动态调度通常被应用于面向对象编程（OOP）的语言和系统，并被认为是一个主要特点。

面向对象的系统把一个问题看作是一系列通过名字引用来制定操作的相互影响的物体。多态性是指一些可互换的物体虽有相同名字但却在行为上不同的现象。例如，一个文件对象和一个数据库对象都有一个储存记录的方法来记录需要存储的的个人记录，但是二者的实现却不同。一个程序可以有对文件或数据库的访问。当一个程序调用对象的存储记录时，有一些东西需要来决定采取哪种行为。如果有人认为OOP仅仅指给对象发送信息，那么在这个例子中程序仅仅把一条存储记录信息发送给了一个未知类型的对象，而把如何将这条信息发送给正确对象交给运行支持系统来处理。这个对象来决定它执行哪些行为。

与动态调度成对比的是静态调度，在静态调度中，对一个多态操作的实现是在编译时间就选择好的。动态调度的目的在于支持那些当在编译时间内无法决定一个多态操作的合适的实现因为这个决定取决于这个操作的一个或多个实际参数的运行类型的情形。

动态调度和动态绑定不同。在选择操作的上下文中，绑定把名称和操作相关联，而调度则在确定名称所引用的操作之后选择操作的实现。通过使用动态调度，名称可以在编译时被绑定到多态操纵中，但是直到运行时才执行该实现。虽然动态分派不暗示后期绑定，但后期绑定意味着动态分派，因为绑定决定了什么可以调度。

C ++编译器通常使用称为虚拟表（vtable）的数据结构来实现动态调度，该表定义给定类（C ++本身没有vtable的概念）的消息到方法映射。 然后，该类型的实例将存储指向此表的指针作为其实例数据的一部分。 当使用多重继承时，这是复杂的因为C ++不支持后期绑定，C ++对象中的虚拟表不能在运行时修改，这将调度目标的潜在集限制为在编译时选择的有限集。

类型重载不会在C ++中产生动态分派，因为语言将消息参数的类型视为正式消息名称的一部分。 这意味着程序员看到的消息名不是用于绑定的正式名称。

C ++使用早期绑定，并提供动态和静态调度。 调度的默认形式是静态的。 为了获得动态分派，程序员必须将一个方法声明为virtual。

帮助理解

• 对象的静态类型：对象在声明时采用的类型。是在编译期确定的。
• 对象的动态类型：目前所指对象的类型。是在运行期决定的。对象的动态类型可以更改，但是静态类型无法更改。
• 静态绑定：绑定的是对象的静态类型，某特性（比如函数）依赖于对象的静态类型，发生在编译期。
• 动态绑定：绑定的是对象的动态类型，某特性（比如函数）依赖于对象的动态类型，发生在运行期。

class B{ }
class C : public B{  }
class D : public B{  }
   D* pD = new D();
  //pD的静态类型是它声明的类型D*，动态类型也是D*
   B* pB = pD;
   //pB的静态类型是它声明的类型B*，动态类型是pB所指向的对象pD的类型D*
   C* pC = new C();
  pB = pC;
  //pB的动态类型是可以更改的，现在它的动态类型是C*

class B
{
    void DoSomething();
    virtual void vfun();
}
class C : public B
{
    void DoSomething();
    //这个子类重新定义了父类的no-virtual函数，
    //这是一个不好的设计，会导致名称遮掩；这里只是为了说明动态绑定和静态绑定才这样使用。
    virtual void vfun();
}
class D : public B
{
    void DoSomething();
    virtual void vfun();
}
D* pD = new D();
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()。

只有虚函数才使用的是动态绑定，其他的全部是静态绑定。

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

// 遇坑则记。

#include <iostream>
using namespace std;
class goods {
public :
	goods() { NO = 100; p = 20.1; }
	string isbn()const;
	virtual double price()const { return 1; };
	void print() {
		cout << price();
	}
	string NO;
	double p;
};
string goods::isbn()const {
	return NO;
}

class food : public goods {
public:
	food() = default;
	double price()const override{ return 2; }
	void print() {
		cout << price();
	}
};

int main()
{
	food f;
   goods*p;
	p = &f;
	p->print();

   return 0;


}

运行结果：2
那么为什么会输出2这个结果呢？
主函数中，p - > print(); 调用的是goods类中的print方法，而print方法中的price()则发生了动态绑定，实际调用了food类中的price()，所以输出结果为2。

将goods类稍作修改：

class goods {
public :
	goods() { NO = 100; p = 20.1; }
	string isbn()const;
	virtual double price()const { return 1; };
	void print() {
		cout << goods::price();
		//加入域作用符加以限定
	}
	string NO;
	double p;
};

输出结果为1。