What are the applications of C++ function pointers in virtual methods and virtual tables?

C The function pointer is used in the virtual method to store the pointer to the overridden method implementation of the derived class, and in the virtual table to initialize the virtual table and store the pointer to the virtual method implementation, thereby achieving runtime polymorphism and allowing derivation. The class overrides the virtual method in the base class and calls the correct implementation based on the actual type of the object at runtime.

C function pointer: application of virtual methods and virtual tables

In C, function pointers are used in implementing virtual methods and maintaining Virtual tables play a vital role. This article will delve into these applications and deepen understanding through practical cases.

Virtual method

Virtual method is a member function declared in the base class and overridden by the derived class. When a virtual method is called through a base class pointer, the derived class's implementation is called based on the actual type of the runtime object.

In order to implement virtual methods, the compiler creates a virtual function table (vtable) for each base class, which stores pointers to the implementation of each virtual method. When a virtual method is called, the compiler uses the object's vtable to find and call the correct implementation.

Application of function pointers in virtual methods

Function pointers are used to store pointers to virtual method implementations in vtables. The compiler allocates a vtable entry for each virtual method and populates it with a function pointer pointing to the method's implementation.

For example:

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

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

int main() {
    Base* base = new Derived;
    base->print(); // 输出 "Derived::print"
}

In this example, the compiler creates a vtable with two entries in it. The first entry points to the implementation of the print() method in the base class Base, and the second entry points to the overridden print in the derived class Derived () Implementation of method. When base->print() is executed, the compiler uses the vtable to obtain the appropriate function pointer and calls the corresponding implementation.

Virtual table

A virtual table is a data structure used to store function pointers pointing to virtual method implementations. Each entry in the virtual table corresponds to a virtual method declared in the base class.

Application of function pointers in virtual tables

Function pointers are used to initialize the virtual table and store pointers to virtual method implementations. When the compiler detects that a class contains virtual methods, it generates a vtable for the class. The type of each entry in the virtual table is a function pointer corresponding to the method's return type.

In the previous example, the compiler will generate a virtual table containing two entries for the base class Base:

vtable[Base] = {
    Base::print,
    Derived::print
};

Practical case

Let us further understand the application of function pointers in virtual methods and virtual tables through a real-world example. Let's create a simple shape drawing library:

class Shape {
public:
    virtual void draw() = 0;
};

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

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

int main() {
    vector<Shape*> shapes;
    shapes.push_back(new Circle);
    shapes.push_back(new Square);

    for (auto shape : shapes) {
        shape->draw();
    }
}

In this example, the Shape class is the base class, while the Circle and Square Is a derived class. The draw() method is a virtual method and is overridden by each derived class. The compiler creates a vtable for the Shape class that contains function pointers to each derived class's implementation of the draw() method.

When shape->draw() is called, the compiler uses the object's vtable to obtain the appropriate function pointer and calls the correct implementation. This allows us to draw different types of shapes through a unified Shape interface without the need for explicit conversions.

The above is the detailed content of What are the applications of C++ function pointers in virtual methods and virtual tables?. For more information, please follow other related articles on the PHP Chinese website!