[C++]虚函数用法-编程知识

讲虚函数之前先讲讲面向对象的三大特性：封装、继承、多态。

1、封装

封装是指将数据（属性）和操作数据的方法（函数）封装在一个单元中，这个单元就是类。封装的主要目的是隐藏类的内部实现细节，只暴露必要的接口给外部使用者。

优点：

信息隐藏：封装可以将类的内部细节隐藏起来，不暴露给外部，提高了安全性和防止误用。
简化接口：封装通过提供清晰的接口简化了类的使用，使用者只需关注如何使用接口而不需要了解内部实现。
提高可维护性：内部实现的修改不会影响外部使用者，从而提高了代码的可维护性。

示例：

#include <iostream>
#include <string>class Student {
private:std::string name;int age;public:// 构造函数Student(const std::string& n, int a) : name(n), age(a) {}// 获取姓名std::string getName() const {return name;}// 设置年龄void setAge(int a) {if (a >= 0) {age = a;}}// 显示学生信息void displayInfo() const {std::cout << "Name: " << name << ", Age: " << age << std::endl;}
};int main() {Student student("Alice", 20);// 使用公有接口获取和设置信息student.setAge(21);std::cout << "Student Name: " << student.getName() << std::endl;student.displayInfo();return 0;
}

2、继承

继承允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和方法。通过继承，子类可以获得父类的特征，并可以添加新的特征或修改继承的特征。

优点：

代码重用：继承允许在不重复编写代码的情况下扩展和修改现有类，提高了代码的重用性。
层次结构：继承可以创建类的层次结构，使得代码更有组织性和可扩展性。
多态性支持：继承是多态性的基础，通过基类指针或引用调用派生类的方法实现多态行为。

示例：

#include <iostream>
#include <string>// 基类
class Animal {
protected:std::string name;public:Animal(const std::string& n) : name(n) {}void eat() {std::cout << name << " is eating." << std::endl;}
};// 派生类
class Dog : public Animal {
public:Dog(const std::string& n) : Animal(n) {}void bark() {std::cout << name << " is barking." << std::endl;}
};int main() {Dog myDog("Buddy");myDog.eat();  // 继承自基类myDog.bark(); // 派生类自己的方法return 0;
}

3、多态

多态性是指同一个操作可以作用于不同类型的对象，并且可以根据对象的类型执行不同的行为。多态性通过虚函数和函数重载实现。

编译时多态性（静态多态性）：通过函数重载实现，编译器在编译时根据函数参数的类型和数量来选择调用合适的函数。这种多态性是在编译时解析的。
运行时多态性（动态多态性）：通过虚函数和继承实现，允许在运行时根据对象的实际类型来调用适当的函数。这种多态性是在运行时解析的。

优点：

灵活性：多态性允许在不同的情境下以通用的方式处理不同类型的对象，提高了代码的灵活性。
可扩展性：可以轻松地添加新的派生类而不影响现有的代码，增加了系统的可扩展性。
简化接口：多态性简化了代码的接口，允许使用者按统一的方式与不同类型的对象交互。

示例：

#include <iostream>
#include <vector>class Shape {
public:virtual void draw() {std::cout << "Drawing a shape." << std::endl;}
};class Circle : public Shape {
public:void draw() override {std::cout << "Drawing a circle." << std::endl;}
};class Square : public Shape {
public:void draw() override {std::cout << "Drawing a square." << std::endl;}
};int main() {std::vector<Shape*> shapes;shapes.push_back(new Circle());shapes.push_back(new Square());for (Shape* shape : shapes) {shape->draw(); // 多态性：根据对象的实际类型调用适当的方法}// 释放内存for (Shape* shape : shapes) {delete shape;}return 0;
}

讲了这么多，进入今天主题吧，C++实现多态的虚函数。

在C++中，函数继承的方法可以让我们快速开发，为了满足多态和泛型编程，C++允许用户使用虚函数来完成运行时解析，与一般的编译时解析也有着本质区别。

4、虚函数在内存中的分布

对于C++了解的人都应该知道虚函数是通过一个虚函数表来实现的。在这个表中，主要是一个类的虚函数的地址表，这个表解决了继承、覆盖的问题，保证其真实反应实际的函数。这样的话，在有虚函数的类的实例中，这个表被分配在这个实例的内存中。当我们用父类的指针操作其子类的时候，这个虚表就非常重要了，它指明了实际所应该调用的函数。

class A {
public:virtual void v_a(){}virtual ~A(){}int64_t _m_a;
};
int main()
{A* a = new A();return 0;
}

定义一个类A，那么它在内存中分布的情况是什么样的呢？接下来一起看看

首先在主函数的栈帧上有一个 A 类型的指针指向堆里面分配好的对象 A 实例。
对象 A 实例的头部是一个 vtable 指针，紧接着是 A 对象按照声明顺序排列的成员变量。（当我们创建一个对象时，便可以通过实例对象的地址，得到该实例的虚函数表，从而获取其函数指针。）
vtable 指针指向的是代码段中的 A 类型的虚函数表中的第一个虚函数起始地址。
虚函数表的结构其实是有一个头部的，叫做 vtable_prefix ，紧接着是按照声明顺序排列的虚函数。
注意到这里有两个虚析构函数，因为对象有两种构造方式，栈构造和堆构造，所以对应的，对象会有两种析构方式，其中堆上对象的析构和栈上对象的析构不同之处在于，栈内存的析构不需要执行 delete 函数，会自动被回收。
typeinfo 存储着 A 的类基础信息，包括父类与类名称，C++关键字 typeid 返回的就是这个对象。
typeinfo 也是一个类，对于没有父类的 A 来说，当前 tinfo 是 class_type_info 类型的，从虚函数指针指向的vtable 起始位置可以看出。

5、虚函数表实现原理

虚函数表是一个指向虚函数的指针数组，每个带有虚函数的类都有一个对应的虚函数表。

虚函数指针

其本质就是一个指向函数的指针，与普通的函数指针并没有什么大的区别。它指向程序员自己定义的虚函数，当子类调用虚函数的时候，实际上就是通过调用这个虚函数指针从而找到接口。

虚函数指针是一个真实存在的数据类型，在对象实例化的时候，放在这个对象地址的首位，目的就是为了保证运行的快速性。与对象的成员函数不一样的是，虚函数指针对外部是完全不可见的，除非直接访问地址或者是debug模式，否则它是不能被外部调用的。

只有拥有虚函数的类才能拥有虚函数指针，每个虚函数都会对应一个虚函数指针。那么，拥有虚函数的类都会产生额外的开销，并且也会在一定程度上影响程序的运行速度。

虚函数表

当一个类包含虚函数时，编译器会在该类的对象中添加一个指向虚函数表的指针。这个指针通常位于对象的内存布局的开头（虚指针），它们按照一定的顺序组织起来就会构成一个表状结构，叫做虚函数表。虚函数表本身是一个全局的、类特定的数组，其中包含了该类中所有虚函数的地址。

先来定义一个基类：

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

对于基类Base的虚函数表记录的只有自己定义的虚函数。

下来再看看子类：

class Children: public Panent
{
public:virtual void A(){cout<<"Children::f"<<endl;}virtual void B1(){cout<<"Children::B1"<<endl;}virtual void C1(){cout<<"Children::C1"<<endl;}
}

最常见的继承，就是子类对基类的虚函数进行覆盖继承。

此时的虚函数表：

基函数的表项仍然会保留，而得到正确继承的虚函数的指针将会被覆盖，而子类自己的虚函数将跟在表后。

当多继承的时候，表项将会增多，顺序将会体现为继承的顺序，那么子类的虚函数就跟在第一个表项后。

C++中一个类是公用一个虚函数表的，基类有基类的虚函数表，子类有子类的虚函数表，这样极大的节省了内存。

虚表指针

为了指定对象的虚表，对象内部包含一个虚表的指针，来指向自己所使用的虚表。为了让每个包含虚表的类的对象都拥有一个虚表指针，在编译阶段，编译器在类中添加了一个指针 __vptr，用来指向虚表。这样，当类的对象在创建时便拥有了这个指针，且这个指针的值会自动被设置为指向类的虚表，__vptr一般在对象内存分布的最前面。

虚表指针的初始化确实发生在构造函数的调用过程中，但是在执行构造函数体之前，即进入到构造函数的"{“和”}"之前。为了更好的理解这一问题，我们可以把构造函数的调用过程细分为两个阶段，即：