C++虚函数表的结构与查找机制：实现动态多态性与内存布局

C++ 虚函数表的结构与查找机制：实现动态多态性与内存布局

大家好，今天我们深入探讨C++中一个至关重要的概念：虚函数表（Virtual Function Table，简称vtable）。虚函数表是C++实现动态多态性的核心机制，它决定了如何在运行时确定调用哪个函数，并直接影响对象的内存布局。理解虚函数表对于编写高效、可扩展的C++代码至关重要。

1. 动态多态性的必要性

在理解虚函数表之前，我们先回顾一下C++中的多态性。多态性允许我们使用基类的指针或引用来操作派生类的对象。C++中的多态性分为两种：静态多态性（编译时多态性）和动态多态性（运行时多态性）。

静态多态性主要通过函数重载和模板实现。编译时，编译器就能确定调用哪个函数。例如：

#include <iostream>

void print(int x) {
  std::cout << "Integer: " << x << std::endl;
}

void print(double x) {
  std::cout << "Double: " << x << std::endl;
}

int main() {
  print(5);    // 调用 print(int)
  print(3.14); // 调用 print(double)
  return 0;
}

这里，编译器根据参数类型在编译时就决定了调用哪个 print 函数。

然而，静态多态性在某些情况下显得力不从心。考虑以下场景：

#include <iostream>

class Animal {
public:
  void makeSound() {
    std::cout << "Generic animal sound" << std::endl;
  }
};

class Dog : public Animal {
public:
  void makeSound() {
    std::cout << "Woof!" << std::endl;
  }
};

class Cat : public Animal {
public:
  void makeSound() {
    std::cout << "Meow!" << std::endl;
  }
};

int main() {
  Animal* animal1 = new Animal();
  Animal* animal2 = new Dog();
  Animal* animal3 = new Cat();

  animal1->makeSound(); // Generic animal sound
  animal2->makeSound(); // Generic animal sound (期望 Woof!)
  animal3->makeSound(); // Generic animal sound (期望 Meow!)

  delete animal1;
  delete animal2;
  delete animal3;

  return 0;
}

在这个例子中，我们创建了 Animal 类的指针，并分别指向 Animal、Dog 和 Cat 类的对象。尽管 Dog 和 Cat 类都重写了 makeSound() 方法，但通过 Animal 指针调用时，始终调用的是 Animal 类的 makeSound() 方法。这是因为编译器在编译时根据指针类型（Animal*）决定了调用哪个函数。

为了解决这个问题，我们需要动态多态性。动态多态性允许在运行时根据对象的实际类型来确定调用哪个函数。这正是虚函数的作用。

2. 虚函数的引入

要实现动态多态性，我们需要将基类的 makeSound() 函数声明为虚函数。

#include <iostream>

class Animal {
public:
  virtual void makeSound() {
    std::cout << "Generic animal sound" << std::endl;
  }
};

class Dog : public Animal {
public:
  void makeSound() override { // 使用 override 关键字 (C++11)
    std::cout << "Woof!" << std::endl;
  }
};

class Cat : public Animal {
public:
  void makeSound() override { // 使用 override 关键字 (C++11)
    std::cout << "Meow!" << std::endl;
  }
};

int main() {
  Animal* animal1 = new Animal();
  Animal* animal2 = new Dog();
  Animal* animal3 = new Cat();

  animal1->makeSound(); // Generic animal sound
  animal2->makeSound(); // Woof!
  animal3->makeSound(); // Meow!

  delete animal1;
  delete animal2;
  delete animal3;

  return 0;
}

现在，当通过 Animal 指针调用 makeSound() 方法时，程序会在运行时根据对象的实际类型来调用相应的函数。animal2 指向 Dog 对象，因此调用 Dog::makeSound()，animal3 指向 Cat 对象，因此调用 Cat::makeSound()。

override 关键字(C++11引入)是一个良好的编程习惯。它显式地表明一个成员函数重写了基类的虚函数。如果函数签名与基类中的虚函数不匹配，编译器会报错，从而帮助我们避免潜在的错误。

3. 虚函数表的结构

那么，虚函数是如何实现动态绑定的呢？答案就是虚函数表。

当一个类声明了虚函数时，编译器会为该类及其派生类创建一个虚函数表。虚函数表是一个函数指针数组，其中存储了该类及其派生类中所有虚函数的地址。每个包含虚函数的类的对象，都会包含一个指向其虚函数表的指针，通常称为 vptr。

以下是一个更具体的例子：

#include <iostream>

class Base {
public:
  virtual void func1() { std::cout << "Base::func1()" << std::endl; }
  virtual void func2() { std::cout << "Base::func2()" << std::endl; }
  void func3() { std::cout << "Base::func3()" << std::endl; }
};

class Derived : public Base {
public:
  void func1() override { std::cout << "Derived::func1()" << std::endl; } // 覆盖Base::func1
  virtual void func4() { std::cout << "Derived::func4()" << std::endl; }
};

在这个例子中，Base 类和 Derived 类都有虚函数。编译器会为这两个类创建虚函数表。

• Base 类的虚函数表：

  • func1() 的地址
  • func2() 的地址

• Derived 类的虚函数表：

  • func1() 的地址 (指向 Derived::func1())
  • func2() 的地址 (指向 Base::func2(), 因为 Derived 没有覆盖 func2)
  • func4() 的地址 (指向 Derived::func4())

注意以下几点：

1. 继承关系： 派生类会继承基类的虚函数表。如果派生类重写了基类的虚函数，虚函数表中对应的函数指针会被更新为指向派生类的函数。如果派生类定义了新的虚函数，新的函数指针会被添加到派生类的虚函数表中。
2. 非虚函数： 非虚函数不会出现在虚函数表中。
3. vptr： 每个包含虚函数的类的对象，都会包含一个 vptr，指向该类的虚函数表。vptr 通常是对象内存布局中的第一个成员变量。

为了更清晰地展示虚函数表的结构，我们可以用表格来表示：

类	虚函数表内容
Base	&Base::func1, &Base::func2
Derived	&Derived::func1, &Base::func2, &Derived::func4

4. 虚函数表的内存布局

了解了虚函数表的结构，我们再来看看它在内存中的布局。

假设我们有以下代码：

#include <iostream>

class Base {
public:
  virtual void func1() { std::cout << "Base::func1()" << std::endl; }
  virtual void func2() { std::cout << "Base::func2()" << std::endl; }
  int data1;
};

class Derived : public Base {
public:
  void func1() override { std::cout << "Derived::func1()" << std::endl; }
  int data2;
};

int main() {
  Base* basePtr = new Base();
  Derived* derivedPtr = new Derived();

  std::cout << "Size of Base: " << sizeof(Base) << std::endl;
  std::cout << "Size of Derived: " << sizeof(Derived) << std::endl;

  delete basePtr;
  delete derivedPtr;
  return 0;
}

在32位系统上，sizeof(Base) 通常是 8 字节（4 字节 vptr + 4 字节 data1），sizeof(Derived) 通常是 12 字节（4 字节 vptr + 4 字节 data1 + 4 字节 data2）。 在64位系统上，指针大小为8字节，所以 sizeof(Base)通常是 16 字节（8 字节 vptr + 8 字节 data1）， sizeof(Derived) 通常是 24 字节（8 字节 vptr + 8 字节 data1 + 8 字节 data2）。

以下是 Base 和 Derived 对象内存布局的简化示意图（以64位系统为例）：

Base 对象：

+-----------------+
| vptr (8 bytes)  |  --> 指向 Base 的虚函数表
+-----------------+
| data1  (8 bytes) |
+-----------------+

Derived 对象：

+-----------------+
| vptr (8 bytes)  |  --> 指向 Derived 的虚函数表
+-----------------+
| data1  (8 bytes) | (继承自 Base)
+-----------------+
| data2  (8 bytes) |
+-----------------+

关键点：

• 每个对象都有一个 vptr，指向其类的虚函数表。
• vptr 通常位于对象的起始位置。
• 派生类对象包含基类的成员变量，以及自身的成员变量。

5. 虚函数的查找机制

当我们通过基类指针或引用调用虚函数时，编译器会生成代码来执行以下步骤：

1. 获取对象的 vptr： 通过对象的地址，找到对象的 vptr。
2. 获取虚函数表的地址： vptr 指向虚函数表，所以我们得到了虚函数表的地址。
3. 查找虚函数地址： 根据虚函数在虚函数表中的偏移量，找到虚函数的地址。例如，如果要调用 func1()，就找到虚函数表中第一个函数指针的地址。如果是func2()，就找到第二个函数指针的地址，以此类推。
4. 调用虚函数： 通过虚函数地址，调用虚函数。

这个过程是在运行时完成的，因此可以实现动态绑定。

让我们用一个例子来说明：

#include <iostream>

class Base {
public:
  virtual void func1() { std::cout << "Base::func1()" << std::endl; }
  virtual void func2() { std::cout << "Base::func2()" << std::endl; }
};

class Derived : public Base {
public:
  void func1() override { std::cout << "Derived::func1()" << std::endl; }
};

int main() {
  Base* basePtr = new Derived(); // 基类指针指向派生类对象
  basePtr->func1();            // 调用 Derived::func1()
  return 0;
}

当执行 basePtr->func1() 时，会发生以下情况：

1. 获取 basePtr 指向的对象的 vptr。由于 basePtr 指向 Derived 对象，所以 vptr 指向 Derived 类的虚函数表。
2. 获取 Derived 类的虚函数表的地址。
3. 查找 func1() 在虚函数表中的偏移量。 func1() 是第一个虚函数，所以偏移量为 0。
4. 从 Derived 类的虚函数表中，找到偏移量为 0 的函数指针，该指针指向 Derived::func1()。
5. 调用 Derived::func1()。

6. 纯虚函数和抽象类

C++还提供了纯虚函数的概念，用于定义抽象类。纯虚函数是在基类中声明但没有定义的虚函数。包含纯虚函数的类称为抽象类。

#include <iostream>

class Shape {
public:
  virtual double area() = 0; // 纯虚函数
  virtual void display() { std::cout << "Shape::display()" << std::endl; }
};

class Circle : public Shape {
public:
  Circle(double radius) : radius_(radius) {}
  double area() override { return 3.14159 * radius_ * radius_; }
private:
  double radius_;
};

// class Square : public Shape { // 如果不override area()函数，则Square也是抽象类。
// public:
//  Square(double side) : side_(side) {}
// private:
//  double side_;
// };

int main() {
  // Shape* shape = new Shape(); // 错误：不能创建抽象类的对象
  Circle* circle = new Circle(5.0);
  std::cout << "Circle area: " << circle->area() << std::endl;

  //Square* square = new Square(4.0); // Error: cannot declare variable 'square' to be of abstract type 'Square'

  delete circle;
  return 0;
}

• 纯虚函数： virtual double area() = 0; 中的 = 0 表示 area() 是一个纯虚函数。
• 抽象类： Shape 类包含纯虚函数，因此是一个抽象类。我们不能创建抽象类的对象。
• 派生类： 派生类必须实现基类中的所有纯虚函数，才能成为非抽象类。 如果派生类没有override基类中的纯虚函数，那么这个派生类本身也是一个抽象类。

纯虚函数在虚函数表中占据一个位置，但该位置通常指向一个特殊的函数，该函数会在尝试调用纯虚函数时抛出一个错误或终止程序。 有些编译器会将该位置设置为NULL。

抽象类和纯虚函数提供了一种定义接口的机制，强制派生类实现特定的功能。

7. 虚继承与虚函数表

虚继承主要用于解决多重继承中的菱形继承问题，以避免出现二义性和重复的基类子对象。虚继承也会影响虚函数表的结构。

考虑以下代码：

#include <iostream>

class A {
public:
  virtual void func() { std::cout << "A::func()" << std::endl; }
};

class B : public virtual A {
public:
  virtual void funcB() { std::cout << "B::funcB()" << std::endl; }
};

class C : public virtual A {
public:
  virtual void funcC() { std::cout << "C::funcC()" << std::endl; }
};

class D : public B, public C {
public:
  void func() override { std::cout << "D::func()" << std::endl; }
};

int main() {
  D* d = new D();
  d->func(); // 调用 D::func()
  return 0;
}

在这个例子中，B 和 C 类都虚继承了 A 类，D 类多重继承了 B 和 C 类。如果没有虚继承，D 类会包含两个 A 类的子对象，导致二义性。虚继承确保 D 类只包含一个 A 类的子对象。

虚继承的实现通常涉及以下机制：

• 虚基类指针 (vbase pointer)： 类似于 vptr，vbase pointer 指向一个虚基类表，该表包含从派生类到虚基类子对象的偏移量。
• 虚基类表 (vbase table)： 存储了派生类到虚基类的偏移量信息。

虚继承使得派生类能够找到共享的虚基类子对象。它增加了对象的复杂性，并可能带来一定的性能开销。

8. 总结：掌握虚函数表，用好多态性

今天我们深入探讨了C++虚函数表的结构与查找机制，以及它们如何实现动态多态性。理解虚函数表对于编写高质量的C++代码至关重要。

虚函数表是C++实现动态多态性的关键机制，通过 vptr 和 vtable，程序能在运行时确定要调用的函数。纯虚函数和抽象类则提供了一种定义接口的强大方式。 虚继承主要用于解决多重继承中的菱形继承问题，但也增加了对象的复杂性。

更多IT精英技术系列讲座，到智猿学院