C++的静态绑定和动态绑定、虚函数表的理解

news/2024/7/26 11:19:25/文章来源:https://blog.csdn.net/KK_2018/article/details/137271866

C++的静态绑定和动态绑定、虚函数表的理解

概念

在C++中，静态绑定（Static Binding）和动态绑定（Dynamic Binding）是两种不同的函数调用机制，主要涉及到如何根据对象的类型来选择执行哪个函数的决定过程。这两种机制在多态性的实现中扮演着关键角色。动态绑定是面向对象编程中实现多态性的关键机制，允许代码在更高的抽象层次上运行，提高了代码的复用性和扩展性。而静态绑定则因其高效性，在不需要多态性的情况下，依然是一个很好的选择。
下面我将通过代码来详细说明这个内容。

静态绑定
静态绑定，也称为早期绑定，指的是函数调用在编译时期就已经确定了。在这种情况下，调用哪个函数是根据指针或引用的静态类型（即编码时指定的类型，而不是运行时的实际类型）来决定的。静态绑定适用于非虚函数（non-virtual functions）。

优点：效率高，因为函数调用的决策在编译时就已经完成了，不需要在运行时进行查找。
缺点：缺乏灵活性，不能根据对象的实际类型来调用对应的函数，不利于实现多态性。

动态绑定

动态绑定，也称为晚期绑定，是指函数调用在运行时确定。这通常是通过虚函数（virtual functions）机制来实现的。当一个函数在基类中被声明为虚函数后，派生类可以重写（Override）这个函数，创建自己的实现。如果通过基类的指针或引用调用这个函数，那么实际调用的版本将根据对象的实际类型（运行时的类型）来确定。

优点：提供了灵活性，允许多态性的实现。可以根据对象的实际类型调用相应的函数，即使是在基类的指针或引用上调用。
缺点：效率相对较低，因为需要在运行时进行类型检查和函数查找。

注意点

什么是绑定

"绑定"指的是函数调用与函数实现之间的关联，在C++中，这种绑定可以是静态的（编译时决定）或动态的（运行时决定）。

静态绑定发生在一个函数调用与一个函数实现之间。这里，函数的调用是基于调用对象的静态类型（即声明时的类型）来决定的。也就是说，编译器在编译时就决定了会调用哪个函数；
动态绑定发生在一个虚函数调用与多个可能的函数实现之间。在这种情况下，函数的调用是基于调用对象的实际类型（即运行时对象的类型）来决定的。也就是说，运行时系统（而不是编译器）在运行时决定了会调用哪个函数。

静态绑定和动态绑定如何判断

不加virtual：静态绑定

当一个成员函数没有被声明为virtual时，其绑定方式是静态的。这意味着函数调用会在编译时解析，基于对象的静态类型（即代码中声明的类型）。这种方式适用于大多数普通函数调用，它能提供更高的执行效率，因为调用的函数在编译时就已经确定，无需在运行时进行额外的查找。

如果你调用一个非虚函数，C++编译器会根据调用该函数的对象的类型（更准确地说，是指针或引用的类型）来确定应该调用哪个函数。

静态绑定适用于当你不需要多态性，即在编译时就能确定调用哪个函数的场景。

加virtual：动态绑定

当在一个类的成员函数前加上virtual关键字时，你是在告诉编译器：“请在运行时决定调用哪个函数”。这允许所谓的“后期绑定”或“动态绑定”，意味着如果有任何派生类重写了该虚函数，那么通过基类指针或引用调用该函数时，将调用对象实际类型的函数实现，而不是其静态类型的函数实现。（下面会介绍其中的原理——虚函数表）
动态绑定是实现多态性的关键，特别是当你想通过基类的接口来调用派生类的实现时。

关键点

一旦在基类中声明了一个函数为virtual，所有派生类中的同名函数都自动成为虚函数，即使在派生类中没有显式地使用virtual关键字。

构造函数不能是虚函数。静态成员函数也不能是虚函数，因为静态成员函数不依赖于类的任何特定实例。

代码举例

#include <iostream>class A
{
public:A();A(int a):m_a(a){};void printValue(){std::cout<<"A: "<<m_a<<std::endl;}private:int m_a;
};class B:public A
{
public:B(int a,int b):A(a),m_b(b){};void printValue(){std::cout<<"B: "<<m_b<<std::endl;}
private:int m_b;
};int main()
{A* objA=nullptr;B* objB=new B(10,20);objA=objB;objA->printValue(); // 输出A: 10return 0;
}

上面这段代码中，objA是指向A类型的指针，也就是它的静态类型是A*，虽然在下面有领objA指向了objB，但是printValue函数在A类中没有被声明为virtual，因此调用该函数的时候使用的静态绑定，也就是编译器会根据调用该函数的对象的静态类型（即A*）来决定调用A的printValue函数，而不是运行时实际指向的对象类型（B）调用B的printValue函数。

因此，最终调用的是A的printValue函数。

如何解决呢？定义为虚函数即可

#include <iostream>
class A
{
public:A();A(int a):m_a(a){};virtual void printValue(){std::cout<<"A: "<<m_a<<std::endl;}private:int m_a;
};class B:public A
{
public:B(int a,int b):A(a),m_b(b){};void printValue() override{std::cout<<"B: "<<m_b<<std::endl;}
private:int m_b;
};int main()
{A* objA=nullptr;B* objB=new B(10,20);objA=objB;objA->printValue(); // 输出B: 20return 0;
}

这段代码中，我将printValue函数定义为了虚函数，因此编译器会在运行时决定调用哪个printValue。由于运行的时候objA实际指向的对象类型是B，因此便会调用B的printValue函数。

原理就是下面的虚函数表！

虚函数表

首先要明确 “虚函数表” 的概念：每一个具有虚函数的类都有一个自己的虚函数表，这个表是编译器生成的“数组”，里面保存的是指向类中虚函数的指针（地址）；派生类的虚函数表和基类的虚函数表都是单独存在的，并且内容默认与基类一样，但是当发生如下两种情况的时候，派生类的虚函数表会变化：

当派生类重写了基类的虚函数时；
当派生类中新增了虚函数时。
因此，上面的代码中，类A的虚函数表是这样的

由于在类B中重写了虚函数，因此类B的虚函数表是这样的
在这里插入图片描述

不管是基类还是派生类，每个类的对象的成员都会有一个指向自家虚函数表的指针，也就是虚指针，虚指针通常是对象内存布局的第一个成员（为了确保不管类的成员如何变化，虚指针的位置不变），一个对象调用虚函数的时候，首先会访问它的虚指针，然后根据虚指针指向的位置找到虚函数表，然后在虚函数表中找到要调用的函数的入口地址，然后根据此地址去调用对应的函数实现。
所以，对于类A，加上虚指针的图就是这样的（类B的图把其中的A和a换成B、b即可）。
在这里插入图片描述
因此，上面的代码执行时，过程是这样的
发现有virtual关键字，为动态绑定——运行的时候发现objA指向的对象是objB——访问objB的虚指针找到虚函数表——在虚函数表中找到printValue函数的入口地址——跳转到入口地址执行printValue函数