深度解码C++虚函数：原理、作用与最佳实践

Lion Long

已于 2024-06-22 23:56:43 修改

阅读量621

点赞数 2

分类专栏： C/C++技术干货文章标签： c++ 开发语言 C++11 linux 后端 c++20 stl

于 2023-06-17 23:17:48 首次发布

本文链接：https://blog.csdn.net/Long_xu/article/details/131265902

版权

C/C++技术干货专栏收录该内容

108 篇文章 38 订阅

订阅专栏

一、引言

在编程世界中，C++以其强大的功能和性能而闻名，而虚函数则是构成其面向对象特性的关键元素之一。虚函数赋予了C++程序动态性与灵活性，使得在不修改源代码的情况下，可以生成适应不同运行情况的代码。它在多态性、抽象类与接口的实现、动态绑定等方面发挥着至关重要的作用，使得程序设计者能够构建出更为复杂、可扩展和易于维护的软件系统。本文旨在全面剖析虚函数的原理、用法及重要性，带你从基础理解到高级应用，掌握如何在C++编程中高效利用虚函数，构建出具有高度灵活性和扩展性的代码结构。通过深入探讨虚函数的定义、作用、实现机制以及常见问题与解决方案，本文将帮助读者建立起对虚函数深入且全面的认知，从而在实际开发中灵活运用这一强大工具，为构建高质量的软件项目奠定坚实的基础。
在这里插入图片描述

1.1、什么是虚函数？

虚函数是在父类中定义的一种特殊类型的函数，允许子类重写该函数以适应其自身需求。虚函数的调用取决于对象的实际类型，而不是指针或引用类型。通过将函数声明为虚函数，可以使继承层次结构中的每个子类都能够使用其自己的实现，从而提高代码的可扩展性和灵活性。在C++中，使用关键字"virtual"来定义虚函数。

class Animal {
public:
    virtual void makeSound() {
        cout << "The animal makes a sound.\n";
    }
};

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

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

Animal类有一个虚函数makeSound()，它被Cat和Dog类继承并覆盖了该函数以实现不同的行为。当使用Animal指针或引用调用makeSound()函数时，会根据运行时对象的类型来动态地决定调用哪个子类的函数，从而实现多态性。

1.2、为什么需要虚函数？

虚函数可以让子类对象在运行时动态地继承和修改父类的成员函数，使得代码更加灵活、可重用，并且可以实现多态性和抽象类等高级特性。

通过虚函数，可以实现多态性（Polymorphism），即同一个函数名可以在不同的子类中表现出不同的行为，这样可以提高代码的可重用性和灵活性。
避免静态绑定，在使用父类指针或引用调用子类对象的成员函数时，如果没有使用虚函数，则会进行静态绑定（Static Binding），即只能调用父类的成员函数，无法调用子类特有的成员函数。
虚函数的调用是动态绑定（Dynamic Binding）的，即在运行时根据指针或引用所指向的对象类型来选择调用哪个函数，从而实现动态多态性。
抽象类是一种不能直接实例化的类，只能被其他类继承并实现其虚函数。通过定义纯虚函数（Pure Virtual Function），可以使得一个类成为抽象类，强制其子类必须实现该函数。

二、实现原理

在 C++ 中，虚函数的实现原理基于两个关键概念：虚函数表和虚函数指针。

虚函数表：每个包含虚函数的类都会生成一个虚函数表（Virtual Table），其中存储着该类中所有虚函数的地址。虚函数表是一个由指针构成的数组，每个指针指向一个虚函数的实现代码。
虚函数指针：在对象的内存布局中，编译器会添加一个额外的指针，称为虚函数指针或虚表指针（Virtual Table Pointer，简称 VTable 指针）。这个指针指向该对象对应的虚函数表，从而让程序能够动态地调用正确的虚函数。

当一个基类指针或引用调用虚函数时，编译器会使用虚表指针来查找该对象对应的虚函数表，并根据函数在虚函数表中的位置来调用正确的虚函数。

2.1、虚函数表的概念与作用

虚函数表是一种用于实现多态的机制，在 C++ 中，当一个类中包含虚函数时，编译器会自动为该类生成一个虚函数表。这个表由包含虚函数的类的指针所指向，其中每个条目都存储着对应虚函数的地址。当使用一个对象调用其虚函数时，编译器通过该对象的虚函数表找到对应的虚函数地址，并进行调用。

在这里插入图片描述

虚函数表的作用在于实现了多态，即通过基类指针或引用调用派生类的虚函数，实现了不同对象的不同行为。因此，虚函数表使得程序可以更加灵活地处理不同类型的对象，并支持代码的扩展和修改。同时，由于虚函数表的存在，C++ 中的虚函数调用比起其他语言（如 Java）中的成本要高，因为需要额外的内存空间存储虚函数表及其指针。

2.2、虚函数指针的意义

虚函数指针的意义在于实现多态。多态是指同一种操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。通过使用虚函数和虚函数指针，可以在运行时确定调用哪个子类中的虚函数，从而实现了动态绑定，使得程序具有更好的灵活性和扩展性。
此外，虚函数指针也是实现多级继承的关键，在多级继承中，每个子类都需要维护自己的虚函数表及其对应的虚函数指针。
在这里插入图片描述

2.3.、虚函数的调用过程

在编译期间，编译器会根据函数调用的类型和对象的类型确定要调用的函数。
2.在运行期间，程序会根据对象的实际类型来决定调用哪个函数。这个过程叫做动态绑定或者后期绑定。
程序通过虚函数表（vtable）来实现动态绑定。每个含有虚函数的类都有自己的虚函数表，存储了指向实际函数地址的指针。在对象被创建时，它的指针会指向所属类的虚函数表。
当调用虚函数时，在对象中存储的指针会被解引用，获取到虚函数表的地址。然后根据函数调用的类型，从虚函数表中获取相应的函数地址。
最后，程序跳转到函数地址处执行实际的代码。由于是动态绑定，所以调用的函数是根据对象实际类型来决定的。

三、虚函数的使用

3.1、声明虚函数的语法

在C++中，声明虚函数的语法为在函数声明前加上关键字virtual。例如：

class Base {
public:
    virtual void foo();
};

3.2、虚函数的重写与覆盖

在 C++ 中，派生类可以重写 (override) 它继承的虚函数，这被称为函数的覆盖 (overriding)。当然，子类也可以选择不重写基类的虚函数，那么它将默认继承基类的实现，这就是虚函数的重载 (overloading)。
虚函数的重写了解起来比较简单，子类定义与父类相同名称和参数列表的虚函数，此时会自动调用子类中定义的方法，而不会调用父类的同名虚函数。例如：

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

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

int main() {
    Derived obj;
    Base* ptr = &obj;
    ptr->foo(); // 输出：Derived::foo()
    return 0;
}

需要注意的是，在子类中重写虚函数时，其访问权限不能更严格（即不能由 public 变为 private 或 protected），否则编译器会报错。
虚函数的覆盖实际上是通过指定 override 关键字显式声明来实现的。例如：

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

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

int main() {
    Derived obj;
    Base* ptr = &obj;
    ptr->foo(); // 输出：Derived::foo()
    return 0;
}

在派生类中使用 override 关键字声明重写基类中的虚函数，这样即使子类中错误地定义了一个同名但不同参数列表的函数，编译器也会报错。

需要注意的是，在使用 override 关键字时，子类中必须存在与父类虚函数完全匹配的函数签名，否则编译器无法确定是否真正覆盖了该虚函数。如果子类中没有与父类完全匹配的虚函数，则需要在子类中重新声明另一个虚函数来覆盖基类虚函数。

3.3、纯虚函数与抽象类

纯虚函数和抽象类是C++中面向对象编程中的两种重要概念。
纯虚函数是指在基类中定义的没有实现的虚函数。使用纯虚函数可以使该函数只有函数原型，而没有具体的实现。注：这里的“=0”表示该函数为纯虚函数。
语法：

virtual void func() = 0;

纯虚函数的作用是让子类必须实现该函数，并且不能直接创建该类对象（即该类为抽象类）。
抽象类是包含纯虚函数的类，它们不能被实例化，只能被继承。抽象类只能用作其他类的基类。如果一个类继承了抽象类，则必须实现所有的纯虚函数，否则该类也会成为抽象类。
示例代码：

class Shape{
public:
    // 纯虚函数
    virtual double getArea() = 0;
};

// 继承自抽象类Shape
class Rectangle: public Shape {
public:
    double width;
    double height;
    double getArea() {return width * height;}
};

// 继承自抽象类Shape
class Circle: public Shape {
public:
    double radius;
    double getArea() {return 3.14*radius*radius;}
};

以上代码中， Shape为抽象类，其中包含纯虚函数getArea()，Rectangle和Circle均继承自Shape，并且实现了getArea()函数的具体内容。

3.4、动态绑定和静态绑定

动态绑定和静态绑定是面向对象编程中的两个概念，用于描述方法调用时确定所调用方法的过程。

静态绑定是指在编译时就确定要调用哪个方法，也称为早期绑定。这种绑定方式通常出现在使用类或接口定义对象时，编译器根据对象的类型来决定具体要调用哪个方法。
示例：

class Shape {
public:
    void draw() { cout << "Drawing a shape." << endl; }
};

class Circle : public Shape {
public:
    void draw() { cout << "Drawing a circle." << endl; }
};

int main() {
    Shape* shapeObj = new Circle();
    shapeObj->draw(); // 编译时期确定方法调用，输出 "Drawing a shape."
}

上述代码中，调用shapeObj->draw()时，由于Shape类中的draw()方法不是虚函数，编译器会在编译时期就确定具体调用的函数实现，因此输出结果为"Drawing a shape.“而不是"Drawing a circle.”。
动态绑定则是在程序运行时才能确定要调用哪个方法，也称为晚期绑定。这种绑定方式通常出现在使用子类对象调用父类方法时，程序会根据实际的对象类型来决定具体要调用哪个方法。
示例：

class Shape {
public:
    virtual void draw() { cout << "Drawing a shape." << endl; }
};

class Circle : public Shape {
public:
    void draw() { cout << "Drawing a circle." << endl; }
};

int main() {
    Shape* shapeObj = new Circle();
    shapeObj->draw(); // 运行时期确定方法调用，输出 "Drawing a circle."
}

上述代码中，Shape类中的draw()方法被声明为虚函数，因此在运行时期会根据对象类型确定具体调用的函数实现，因此输出结果为"Drawing a circle."。
动态绑定可以实现多态性，使得程序更加灵活和可扩展。但是由于需要在运行时确定方法的调用，会带来一定的性能损失。因此在编写高效的程序时需要考虑绑定方式的选择。

四、虚函数与多态的关系

虚函数是实现多态的关键。在基类中声明一个虚函数，当子类重写该函数时，调用该函数将根据对象类型动态确定。这样做可以实现运行时多态，即在程序运行期间根据对象类型动态确定哪个函数应该被调用。这使得代码更加灵活和可扩展，并且减少了大量的条件判断语句。因此，虚函数和多态密不可分。

4.1、多态的定义

多态是一种面向对象编程概念，指同一个行为（方法）在不同的对象上有不同的实现方式。其定义可以简单地理解为“同名多形”，即同一个方法名可以被不同的类实现，并且表现出不同的行为。多态使得程序具有更高的灵活性和可扩展性，因为它使得代码与具体对象的实现细节分离开来，从而可以方便地添加新的类或修改旧的类的实现方式，同时也使得代码更易于维护。

在这里插入图片描述

4.2、静态多态和动态多态

静态多态（也称为编译时多态）是指在编译时就能够确定函数或方法的调用对象，即函数或方法的重载。在静态多态中，函数或方法的重载是通过参数类型、参数数量或返回值类型来区分的。
例如，以下两个方法就是静态多态：

int add(int a, int b){
    return a + b;
}

double add(double a, double b){
    return a + b;
}

当调用add()方法时，编译器会根据传递给方法的参数类型来决定使用哪个重载版本。
动态多态（也称为运行时多态）是指在程序运行时才能确定函数或方法的调用对象，即虚函数或抽象类。在动态多态中，函数或方法的重载是通过继承和多态来实现的。
例如，以下代码就是动态多态：

class Animal{
    public:
        virtual void makeSound()=0;
}

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

class Cat :public Animal{
    public:
        void makeSound(){
             std::cout<<"喵喵喵"<<std::endl;
        }
}
int main()
{

    Animal animal = new Dog();
    animal.makeSound(); // 输出"汪汪汪"

    animal = new Cat();
    animal.makeSound(); // 输出"喵喵喵"
}

4.3、虚函数在多态中的应用

虚函数在多态中的应用十分重要。多态指的是同一种类型的对象，在不同的情况下可以表现出不同的行为。C++通过使用虚函数来实现多态性。

虚函数是指在基类中被声明为虚函数并在派生类中重新定义的函数。当基类指针指向派生类对象时，通过该指针调用虚函数时，会根据指向的实际对象类型进行动态绑定，从而执行相应的派生类函数。
例如，有一个基类Animal和两个派生类Cat和Dog，它们都有一个名为sound()的虚函数。当使用基类指针指向Cat或Dog对象时，通过该指针调用sound()函数时会自动执行相应的派生类函数，从而实现了多态性。
虚函数的应用使得程序具有更好的灵活性和可扩展性，并且简化了代码的编写和维护。

五、常见问题与解答

5.1、虚析构函数的必要性

C++虚析构函数的必要性在于，当一个类拥有子类并且该类中包含有动态分配的内存资源时，需要通过虚析构函数来释放这些内存资源。如果不使用虚析构函数，当子类实例被删除时，只会调用基类的析构函数，而不会调用子类的析构函数，从而导致子类中动态分配的内存资源无法正确释放，可能会导致内存泄漏或者程序崩溃。因此，在使用继承和动态内存分配时，为了保证程序的正确性和健壮性，需要使用虚析构函数来释放内存资源。

5.2、虚函数的性能影响

虚函数的调用需要通过指针或引用进行间接调用，这会增加一定的开销。同时，由于虚函数需要在运行时进行动态绑定，所以会稍微降低程序的执行效率。
不过这种影响通常非常小，并且现代的编译器和硬件已经能够有效地优化虚函数的调用，让它在实践中不会成为性能瓶颈。因此，在设计面向对象的程序时，应该优先考虑代码的可读性、可维护性和可扩展性，而将虚函数带来的性能影响作为次要的因素来考虑。

5.3、多重继承中的虚函数

在多重继承中，如果一个类同时继承了多个基类，而这些基类中都有同名的虚函数，那么子类必须对这些虚函数进行重写并实现。此时，需要使用作用域限定符来指明重写的是哪个基类的虚函数。
例如：

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

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

class Derived : public Base1, public Base2 {
public:
    virtual void func() { Base1::func(); Base2::func(); }
};

例子中，派生类Derived同时继承了Base1和Base2，这两个基类中都有名为func的虚函数。在Derived中，我们通过使用作用域限定符Base1::和Base2::，分别调用了两个基类中的虚函数。

六、总结

6.1、虚函数的优缺点

虚函数的优点：

实现多态性：通过虚函数，可以在不知道对象具体类型的情况下，调用特定对象的方法。
代码灵活性：虚函数允许子类覆盖父类的方法，并且不需要改变基类的代码。
代码可维护性：虚函数使得代码易于维护和扩展，因为子类可以通过重载虚函数来实现自己的行为。

虚函数的缺点：

额外的开销：虚函数需要额外的开销来支持运行时的动态绑定和查找虚表。这可能会影响程序的性能。
可能会引起混淆：由于虚函数的存在，同名的函数可能会被不同的类定义。如果没有正确的使用虚函数，可能会导致混淆和错误的结果。
不适合于小型应用：虚函数对于小型应用来说可能过于复杂和冗余。在这种情况下，使用虚函数可能会导致更多的开销而不是提高效率。

6.2、如何合理地使用虚函数

虚函数应用于继承层次结构中的多态性，即通过基类指针或引用调用派生类对象的成员函数。
可以将虚函数作为接口定义，让不同的派生类实现自己的版本，以满足各自的需求。
避免在构造函数和析构函数中调用虚函数，因为此时对象还未完全构造或已经被销毁。
虚函数的声明应该在公共部分（例如基类），而不是在私有部分（例如派生类）中声明。
将虚函数的实现定义为inline可以提高程序的执行效率。
在使用纯虚函数时，需要给出其具体实现。可以在派生类中实现，也可以在基类中实现。
避免过度使用虚函数，因为虚函数会增加程序的开销。在没有必要的情况下，可以使用普通成员函数代替虚函数。

Lion Long

关注

2
点赞
踩
14

收藏

觉得还不错? 一键收藏
打赏
0
评论
深度解码C++虚函数：原理、作用与最佳实践

虚函数是在父类中定义的一种特殊类型的函数，允许子类重写该函数以适应其自身需求。虚函数的调用取决于对象的实际类型，而不是指针或引用类型。通过将函数声明为虚函数，可以使继承层次结构中的每个子类都能够使用其自己的实现，从而提高代码的可扩展性和灵活性。在C++中，使用关键字"virtual"来定义虚函数。} };} };Animal类有一个虚函数makeSound()，它被Cat和Dog类继承并覆盖了该函数以实现不同的行为。
复制链接

扫一扫