Detailed explanation of C++ function rewriting: the secret of overriding parent class functions

C's function overriding allows subclasses to override parent class functions and provide their own specific implementation. The subclass needs to declare a function with the same name and parameter type as the parent class, and mark it with the override keyword. Overriding functions can be used to extend the functionality of a parent class, provide a specific implementation for a subclass, or provide a concrete implementation of an abstract function.

Detailed explanation of C function rewriting: the secret of overriding parent class functions

Overview

Function rewriting is a powerful feature in C object-oriented programming, which allows subclasses to redefine functions in parent classes. Through overriding, a subclass can override the implementation of the parent class and provide its own specific functionality.

Syntax

To rewrite a function, the subclass needs to declare a function with the same name and parameter type as the parent class:

class Child : public Parent {
public:
    ReturnType overrideName(ParameterList) override;
};

Where:

• override keyword indicates that the function overrides the function in the parent class.
• overrideName is the name of the override function.
• ParameterList is the parameter list of the overridden function.
• ReturnType is the return type of the overridden function (can be different from the parent class function).

Practical case

Consider a shape base classShape, which contains a function that calculates the areagetArea(). Subclasses Rectangle and Circle inherit Shape respectively, and need to provide their own area calculation method:

class Shape {
public:
    virtual double getArea() = 0;
};

class Rectangle : public Shape {
public:
    Rectangle(double width, double height) : m_width(width), m_height(height) {}
    
    double getArea() override {
        return m_width * m_height;
    }
private:
    double m_width;
    double m_height;
};

class Circle : public Shape {
public:
    Circle(double radius) : m_radius(radius) {}
    
    double getArea() override {
        return M_PI * m_radius * m_radius;
    }
private:
    double m_radius;
};

int main() {
    Shape* shapes[] = {new Rectangle(5, 10), new Circle(3)};
    
    for (Shape* shape : shapes) {
        cout << "Area: " << shape->getArea() << endl;
    }
    
    return 0;
}

Output

Area: 50
Area: 28.2743

In this example, Rectangle and Circle override the getArea() function in Shape, providing Calculate their respective areas. When the parent class pointer points to the child class object, the overridden function will be called.

Usage Scenarios

Function rewriting is usually used in the following scenarios:

• When the parent class function needs to be extended or modified.
• When you need to provide specific functionality for different subclasses.
• When it is necessary to provide a concrete implementation of an abstract function (pure virtual function) in the base class.

Notes

• The overridden function must have the same signature (name, parameter type, return type) as the parent class function.
• For virtual functions, subclass overridden functions can have different access modifiers (for example, a protected parent class function can be rewritten as a public subclass function).
• A subclass can only override non-static functions in the parent class.
• Overriding functions are usually marked with the override keyword, but this is not required.

The above is the detailed content of Detailed explanation of C++ function rewriting: the secret of overriding parent class functions. For more information, please follow other related articles on the PHP Chinese website!