C++ virtual functions and dynamic dispatch: understanding the mechanism of runtime method calling

Virtual functions allow derived classes to override base class methods, and dynamic dispatch determines which function to call at runtime based on the object type. Specific steps include: declaring virtual functions through virtual, allowing derived classes to override them. Override virtual functions in derived classes to provide specific implementations. Call a virtual function using a pointer or reference to an object, and the compiler will find and execute the correct function in the virtual function table based on the object type at runtime.

C Virtual functions and dynamic dispatch: Understanding the mechanism of runtime method calling

Introduction

Virtual functions are a powerful feature in C that allow overriding base class methods in derived classes. This article will delve into the mechanisms of virtual functions and dynamic dispatch, and demonstrate them through practical cases.

Virtual functions

Virtual functions are declared by adding the virtual keyword before the function declaration. This indicates that the function can be overridden in derived classes. When a virtual function on an object is called, the actual function called is determined based on the object type when the program is running.

Dynamic dispatch

Dynamic dispatch is a mechanism using virtual functions that allows the function to be called to be determined at runtime. When a virtual function of an object is called, the compiler looks for the function in the virtual function table of the class to which the object belongs and executes the found function.

Practical Case

The following is a practical case demonstrating virtual functions and dynamic dispatch:

#include <iostream>

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

class Rectangle : public Shape {
public:
    Rectangle(double width, double height) : _width(width), _height(height) {}
    double area() override { return _width * _height; }

private:
    double _width;
    double _height;
};

class Circle : public Shape {
public:
    Circle(double radius) : _radius(radius) {}
    double area() override { return 3.14 * _radius * _radius; }

private:
    double _radius;
};

int main() {
    Shape* shapes[] = { new Rectangle(2, 3), new Circle(4) };
    for (Shape* shape : shapes) {
        std::cout << shape->area() << std::endl; // 动态调派
    }
    return 0;
}

In this example, Shape is an abstract base class with a pure virtual function area(). Rectangle and Circle are derived classes that implement the area() function and provide different implementations. In the main function, we create an array of Shape pointers. Although these pointers point to different types, we can call the area() function uniformly through this array, and the compiler will execute the correct function in the appropriate derived class based on the runtime type.

Conclusion

Virtual functions and dynamic dispatch are powerful mechanisms in C that allow flexible method invocation and runtime polymorphism. Understanding these mechanisms is critical to writing robust and scalable code.

The above is the detailed content of C++ virtual functions and dynamic dispatch: understanding the mechanism of runtime method calling. For more information, please follow other related articles on the PHP Chinese website!