Detailed explanation of C++ virtual functions: solving the mystery of polymorphic mechanism

C Virtual functions are the key to achieving polymorphism, which allow derived classes to override the behavior of parent classes: declared as virtual functions and appearing in derived classes. When called, the compiler dynamically resolves the correct function version based on the object type. Pure virtual functions force derived classes to provide their own implementation to achieve polymorphism. Derived classes override the virtual functions of the base class to implement different behaviors.

C Detailed explanation of virtual functions: solving the mystery of polymorphic mechanism

Introduction
Polymorphism Property is a cornerstone in object-oriented programming, allowing objects with the same parent class to be handled in different ways. Polymorphism in C is mainly achieved through virtual functions. This article will delve into virtual functions and demystify the polymorphic mechanism.

The essence of virtual functions
A virtual function is a special type of member function that is declared as a virtual function and appears in an object of a derived class. When a virtual function is called, the compiler dynamically resolves the correct function version at runtime based on the object's actual type. This feature allows derived classes to override the behavior of the parent class, thereby achieving polymorphism.

Syntax
The declaration syntax of a virtual function is as follows:

virtual 返回值类型 函数名(参数列表);

For example:

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

Pure virtual function
Pure virtual function is a special virtual function that has no function body and must be implemented in a derived class. It forces derived classes to provide their own implementation, thus enforcing polymorphism.

Case
To show virtual functions in action, let us consider a shape abstract class Shape and its two derived classes Circle and Rectangle:

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

class Circle : public Shape {
public:
    Circle(double radius) : _radius(radius) {}
    double面积() const override { return M_PI * _radius * _radius; }
private:
    double _radius;
};

class Rectangle : public Shape {
public:
    Rectangle(double width, double height) : _width(width), _height(height) {}
    double面积() const override { return _width * _height; }
private:
    double _width, _height;
};

int main() {
    Shape* circle = new Circle(5.0);
    Shape* rectangle = new Rectangle(10.0, 5.0);

    // 父类指针指向不同的派生类对象，但调用正确的面积函数版本
    double areaCircle = circle->面积();
    double areaRectangle = rectangle->面积();

    std::cout << "圆的面积：" << areaCircle << std::endl;
    std::cout << "矩形的面积：" << areaRectangle << std::endl;

    return 0;
}

In this example, the Shape class declares a pure virtual function Area(). Derived classes Circle and Rectangle respectively cover this function and implement their respective area calculations. In the main function, the derived class object is accessed through the parent class pointer and the area() function is called, but the correct version of the function is executed based on the actual type of the object.

The above is the detailed content of Detailed explanation of C++ virtual functions: solving the mystery of polymorphic mechanism. For more information, please follow other related articles on the PHP Chinese website!