C++ function rewriting: opening a new chapter of flexible inheritance

C function rewriting allows subclasses to override parent class functions, achieving polymorphism and bringing inheritance flexibility. When rewriting a function, the subclass function signature must be exactly the same as the parent class function, identified by the override keyword. Advantages include flexibility, polymorphism, and code reuse. However, please note that signature matching rules and final modifiers cannot be overridden.

C function rewriting: opening a new chapter of flexible inheritance

Preface

Function overriding is a powerful C feature that allows subclasses to override functions in parent classes, thereby achieving polymorphism. This opens up new possibilities for flexible inheritance, allowing subclasses to customize their behavior while retaining the underlying functionality of the parent class.

Syntax

In order to override a function, the subclass needs to declare a new function with the same signature as the parent class function. The new function's return type, parameters, and name must be exactly the same as the parent class function. The following is the syntax for overriding a function:

returntype ClassName::functionName(parameters) {
  // 子类的函数体
}

where returntype is the return type of the function, ClassName is the name of the subclass, functionName is the name of the function to be rewritten, and parameters is the parameter list of the function.

Practical case

Consider such a parent class:

class Shape {
public:
  virtual double area() { return 0.0; }
};

We want to create a subclass Rectangle, which has the same The same area() function of the parent class, but provides its own implementation:

class Rectangle : public Shape {
public:
  double length;
  double width;

  Rectangle(double l, double w) : length(l), width(w) {}

  double area() override {
    return length * width;
  }
};

In the subclass Rectangle, we override area() function and added length and width member variables to store the dimensions of the rectangle. By using the override keyword, we can explicitly indicate that the function is overriding the parent class function.

Advantages

Function overriding provides the following advantages:

• Flexibility: Allows subclass customization Its behavior, while retaining the basic functionality of the parent class.
• Polymorphism: Supports referencing different types of objects through base class pointers and calling the correct overridden functions.
• Code reuse: Common functions in the parent class can be shared by subclasses to avoid duplicate code.

Note

• Function rewriting follows the "signature matching" rule, that is, the return type, parameters and name of the subclass function must be the same as those of the parent class function. The class functions are the same.
• The compiler will issue a warning if a subclass function does not override a parent class function.
• If the parent class function is declared as final, it cannot be overridden in the subclass.

The above is the detailed content of C++ function rewriting: opening a new chapter of flexible inheritance. For more information, please follow other related articles on the PHP Chinese website!