In-depth analysis of C++ virtual functions: type erasure and polymorphic implementation

C virtual functions implement polymorphism and separate object type information through type erasure so that the compiler only recognizes public interfaces. The virtual pointer table stores virtual function addresses. When the base class pointer points to a derived class object, the derived class pointer pointing to the derived class virtual pointer table will replace the virtual pointer table pointed to by the base class pointer, thus achieving polymorphism.

In-depth analysis of C virtual functions: type erasure and polymorphic implementation

In object-oriented programming (OOP), polymorphism State is a crucial idea, which allows us to use a set of public interfaces to operate objects of different classes. The C language implements polymorphism through virtual functions, which separate type information from objects and allow us to deal with different object types in a common way.

Type erasure

When the compiler encounters a virtual function, it type-erases it, which means it removes the object's type information . Therefore, when a base class pointer points to a derived class object, the compiler no longer knows the exact type of the object. Instead, it only knows about the object's public interface, which is the base class interface.

Polymorphic implementation

C virtual functions are implemented through a method table called a virtual pointer. Each class has a virtual pointer table (VTABLE), which lists the addresses of all virtual functions of the class. When a base class pointer points to a derived class object, the compiler replaces the original virtual pointer table pointed by the base class pointer with a derived class pointer pointing to a derived class VTABLE.

Practical Case

The following is an example of a C virtual function, which shows the application of type erasure and polymorphism in practice:

#include <iostream>

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

class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a rectangle" << std::endl;
    }
};

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

int main() {
    Shape* shapes[] = {new Rectangle(), new Circle()}; // 类型擦除: 数组中包含不同类型的 Shape 对象

    for (Shape* shape : shapes) {
        shape->draw(); // 多态: 无论对象的实际类型如何，都会调用正确的 draw() 方法
    }

    return 0;
}

In this example, we define a Shape base class and two derived classes Rectangle and Circle. Shape The base class contains a pure virtual function draw(), and the derived class implements this function. In the main() function, we create an array of Shape pointers pointing to the Rectangle and Circle objects. Since the draw() function is a virtual function, when we call draw() through the base class pointer, it will call the draw() method of the derived class , thus achieving polymorphism.

By understanding the type erasure and polymorphic implementation principles of virtual functions, we can have a deeper understanding of the core mechanism of OOP. This allows us to design flexible and extensible programs that can handle a variety of different object types.

The above is the detailed content of In-depth analysis of C++ virtual functions: type erasure and polymorphic implementation. For more information, please follow other related articles on the PHP Chinese website!