C++ function rewriting: covering parent class defects and optimizing code structure

Function rewriting allows subclasses to override parent class functions, thereby solving parent class defects and optimizing code structure. The specific steps are as follows: the subclass rewrites the function with the same name and signature of the parent class and provides its own implementation. Subclasses can correct design flaws or errors in the parent class. Rewriting functions can improve the maintainability and readability of your code.

C function rewriting: covering the defects of the parent class and optimizing the code structure

Function rewritingallowed A subclass reimplements a function with the same name and signature in the parent class. This provides the following benefits:

• Covering parent class defects: A subclass can correct design flaws or errors in the parent class.
• Optimize code structure: Rewriting functions can improve the maintainability and readability of the code.

Syntax

The syntax for overriding parent class functions in subclasses is as follows:

returnType ChildClass::functionName(argumentList) {
  // 重写后的函数体
}

Among them:

• returnType: Override the return type of the function.
• ChildClass: Derived class name.
• functionName: The name of the function to be rewritten.
• argumentList: Rewrite the parameter list of the function.

Practical case: Geometry base class

Consider a geometry base class that defines a area virtual function to calculate the shape Area:

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

We create derived classes Square and Circle, for square and circle respectively:

class Square : public Shape {
public:
  Square(double sideLength) : sideLength(sideLength) {}
  double area() const override { return sideLength * sideLength; }
private:
  double sideLength;
};

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

override the parent class Defect

ShapeThe area function of the base class is abstract because it has no concrete implementation. Subclasses must provide their own implementation. However, for a circle like Circle, the area function of the parent class is wrong because it does not consider pi.

By overriding the area function of the Circle class, we can override the parent class defect and provide correct area calculation:

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

Optimize code structure

Consider another Vector class with the following method:

class Vector {
public:
  void add(int x) { value += x; }
  void subtract(int x) { value -= x; }
};

We can do this by overriding the addition operator , Redesign this code to make it more readable and maintainable:

class Vector {
public:
  Vector& operator+=(int x) { value += x; return *this; }
  Vector& operator-=(int x) { value -= x; return *this; }

private:
  int value;
};

Rewriting operators allows us to use a simpler and clearer syntax to operate on vectors:

Vector v;
v += 10;  // 相当于 v.add(10)
v -= 5;   // 相当于 v.subtract(5)

Conclusion

Function rewriting is a powerful mechanism in C that allows subclasses to cover parent class defects and optimize code structure. By carefully considering the design and implementation of overridden functions, we can improve the robustness, readability, and maintainability of our programs.

The above is the detailed content of C++ function rewriting: covering parent class defects and optimizing code structure. For more information, please follow other related articles on the PHP Chinese website!