函数调用绑定（Function Call Binding）指的是将一个函数调用与相应的函数定义（实现）关联起来的过程。

1. 函数绑定

对于 C++ 程序而言，将函数查找、关联的过程放在编译期完成，在运行时，避免这部分工作，将会提升程序运行时的性能。所以，C++ 中大部分函数的绑定工作都是在编译期完成。

在编译期进行函数绑定，也叫做函数的静态绑定、早绑定、编译期绑定。

#include <iostream>
using namespace std;


// 普通函数
void do_logic() {}

// 重载函数
void func(int) {}
void func(double) {}
void func(int, int) {}

// 成员函数
struct MyClass
{
    void do_sth() {}
};

struct OtherClass
{
    void do_sth() {}
};


void test()
{
    // 全局就一个 do_logic 函数，编译期确定
    do_logic();

    // 通过参数确定函数调用，编译期确定
    func(100);

    // 根据对象类型、指针类型确定函数调用，编译期确定
    MyClass mc;
    mc.do_sth();

    MyClass* pmc = new MyClass;
    pmc->do_sth();

    delete pmc;
}


int main()
{
    test();
    return 0;
}

对于大部分场景下，A 类型指针或者引用指向 A 类型对象，调用的也是 A 类型对应的函数实现。但是，在多态场景下，会出现 A 类型指针或者引用指向 B 类型的场景，此时就出现了与我们预期不相符的情况。

#include <iostream>
using namespace std;


struct Animal
{
	void Speak() { cout << "Animal::Speak" << endl; }
};


struct Dog : public Animal
{
	void Speak() { cout << "Dog::Speak" << endl; }
};


struct Cat : public Animal
{
	void Speak() { cout << "Cat::Speak" << endl; }
};


void test()
{
	Animal* animal = nullptr;

	animal = new Dog;
	animal->Speak();

	animal = new Cat;
	animal->Speak();
}


int main()
{
	test();
	return 0;
}

程序执行结果：

Animal::Speak
Animal::Speak

由于 C++ 编译器默认进行静态绑定，无法根据对象指针实际指向的对象类型来进行函数调用，这就不符合我们的预期。所以，我们需要将函数的绑定由编译阶段延迟到运行阶段，从而实现根据实际对象类型来选择函数调用。这就是动态绑定，也称作晚绑定、运行时绑定。

C++ 中，通过将成员函数声明为 virtual 虚函数来实现动态绑定。即：当类中包含任何虚函数时：

1. 编译阶段：当编译器看到类中的虚函数，就不再简单根据对象类型来进行函数绑定
2. 运行阶段：会根据实际的对象类型来进行函数的确定，然后调用执行

#include <iostream>
using namespace std;


struct Animal
{
	virtual void Speak() { cout << "Animal::Speak" << endl; }
};


struct Dog : public Animal
{
	virtual void Speak() { cout << "Dog::Speak" << endl; }
};


struct Cat : public Animal
{
	virtual void Speak() { cout << "Cat::Speak" << endl; }
};


void test()
{
	Animal* animal = nullptr;

	animal = new Dog;
	animal->Speak();

	animal = new Cat;
	animal->Speak();
}


int main()
{
	test();
	return 0;
}

程序的执行结果：

Dog::Speak
Cat::Speak

3. 虚函数表

函数的动态绑定是基于虚函数表实现的。当类的内部包含虚函数时，编译器会在对象的第一个数据成员位置安插一个 vfptr 指针（构造函数中初始化），指向一个包含所有虚函数地址的数组。

当子类没有重写父类的虚函数时，在子类的虚函数表中保存父类虚函数的地址。但是，当子类重写父类的虚函数时，就会在虚函数表中发生覆盖行为。当调用对应函数时，会通过虚函数指针找到虚函数表，并找到对应函数地址调用执行。

接下来，通过一段代码来理解上面的内容：

cl /d1 reportSingleClassLayout类名 xxx.cpp

#if 1
#include <iostream>
#include <functional>
using namespace std;


struct Animal
{
	virtual void Speak() { cout << "Animal::Speak" << endl; }
};

struct Dog : public Animal {};
struct Cat : public Animal
{
	virtual void Speak() { cout << "Cat::Speak" << endl; }
	virtual void Ohter() { cout << "Cat::Ohter" << endl; }
};


void test()
{
	Animal* animal = nullptr;

	// 根据对象的实际类型选择合适的函数实现
	animal = new Animal;
	cout << sizeof(*animal) << endl;  // 8
	animal->Speak();

	animal = new Dog;
	animal->Speak();

	animal = new Cat;
	animal->Speak();
}


int main()
{
	test();
	return 0;
}

#endif

// Animal 类
class Animal    size(4):
        +---
 0      | {vfptr}
        +---

Animal::$vftable@:
        | &Animal_meta
        |  0
 0      | &Animal::Speak


// Dog 类
class Dog       size(4):
        +---
 0      | +--- (base class Animal)
 0      | | {vfptr}
        | +---
        +---

Dog::$vftable@:
        | &Dog_meta
        |  0
 0      | &Animal::Speak


// Cat 类
class Cat       size(4):
        +---
 0      | +--- (base class Animal)
 0      | | {vfptr}
        | +---
        +---

Cat::$vftable@:
        | &Cat_meta
        |  0
 0      | &Cat::Speak
 1      | &Cat::Ohter

注意：下面几个关于虚函数的点也需要大家了解：

1. 虚函数表生成与共享：
   • 编译器为每个包含虚函数的类生成一张虚函数表（vtable）。该类型的所有对象共享同一个虚函数表。这个表包含了该类及其基类中所有虚函数的地址。
2. 虚函数表的初始化与销毁：
   • 虚函数表的初始化和销毁由编译器负责。在对象的构造过程中，编译器会确保对象的虚函数指针指向正确的虚函数表。
3. 多重继承和虚函数表
   • 在多重继承的情况下，可能会有多个虚函数表。每个基类都有自己的虚函数表，并且子类对象可能包含多个虚函数指针，以确保每个基类的虚函数都能正确调用。

#if 1
#include <iostream>
#include <functional>
using namespace std;


struct Animal
{
	virtual void Speak() { cout << "Animal::Speak" << endl; }
};

struct Dog : public Animal {};
struct Cat : public Animal
{
	virtual void Speak() { cout << "Cat::Speak" << endl; }
	virtual void Ohter() { cout << "Cat::Ohter" << endl; }
};


void test()
{
	Animal* animal = nullptr;

	// 1. 每个类都会对应一个虚函数表，所有该类的对象共享虚函数表
	// 获得虚函数表地址
	animal = new Animal;
	void** vfptr = *(void***)animal;
	cout << "Animal 虚函数表地址:\t" << vfptr << endl;

	animal = new Dog;
	vfptr = *(void***)animal;
	cout << "Dog 虚函数表地址:\t" << vfptr << endl;

	animal = new Cat;
	vfptr = *(void***)animal;
	cout << "Cat 虚函数表地址:\t" << vfptr << endl;

	Cat* other = new Cat;
	vfptr = *(void***)other;
	cout << "Cat 虚函数表地址:\t" << vfptr << endl;


	// 2. 调用虚函数表中的函数
	// 2.1 获得虚函数表地址
	vfptr = *(void***)animal;
	
	// 2.2 获得虚函数地址
	void(*p_func)() = reinterpret_cast<void(*)()>(vfptr[1]);

	// 2.3 执行虚函数
	p_func();
}


struct Base1
{
	virtual void Vfunc1() { cout << "Base1::Vfunc1" << endl; }
};

struct Base2
{
	virtual void Vfunc2() { cout << "Base2::Vfunc2" << endl; }
};

struct Derived : public Base1, public Base2 {};


int main()
{
	test();
	return 0;
}

#endif

类 Derived 的对象结构：

class Derived   size(8):
        +---
 0      | +--- (base class Base1)
 0      | | {vfptr}
        | +---
 4      | +--- (base class Base2)
 4      | | {vfptr}
        | +---
        +---

Derived::$vftable@Base1@:
        | &Derived_meta
        |  0
 0      | &Base1::Vfunc1

Derived::$vftable@Base2@:
        | -4
 0      | &Base2::Vfunc2