Réécriture de fonctions C++ : couverture des défauts de la classe parent et optimisation de la structure du code

La réécriture des fonctions permet aux sous-classes de remplacer les fonctions de la classe parent, résolvant ainsi les défauts de la classe parent et optimisant la structure du code. Les étapes spécifiques sont les suivantes : la sous-classe réécrit la fonction avec le même nom et la même signature que la classe parent et fournit sa propre implémentation. Les sous-classes peuvent corriger des défauts de conception ou des erreurs dans la classe parent. Les fonctions de réécriture peuvent améliorer la maintenabilité et la lisibilité de votre code.

Réécriture de fonctions C++ : couvre les défauts de la classe parent et optimise la structure du code

Réécriture de fonctionsPermet aux sous-classes de réimplémenter des fonctions avec le même nom et la même signature dans la classe parent. Cela offre les avantages suivants :

• Couverture des défauts de la classe parent : Les sous-classes peuvent corriger les défauts de conception ou les erreurs dans la classe parent.
• Optimiser la structure du code : Les fonctions de réécriture peuvent améliorer la maintenabilité et la lisibilité du code.

Syntaxe

La syntaxe pour remplacer une fonction de classe parent dans une sous-classe est la suivante :

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

Parmi eux :

• returnType : Le type de retour de la fonction remplacée. returnType：重写函数的返回类型。
• ChildClass：派生类名称。
• functionName：要重写的函数名称。
• argumentList：重写函数的参数列表。

实战案例：几何形状基类

考虑一个几何形状基类，它定义一个area虚拟函数来计算形状的面积：

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

我们创建派生类Square和Circle，分别为正方形和圆形：

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;
};

覆盖父类缺陷

Shape基类的area函数是抽象的，因为它没有具体实现。子类必须提供自己的实现。但是，对于像Circle这样的圆形，父类的area函数是错误的，因为它不考虑圆周率π。

通过重写Circle类的area函数，我们可以覆盖父类缺陷并提供正确的面积计算：

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

优化代码结构

考虑另一个具有以下方法的Vector类：

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

我们可以通过重写加法运算符,

ChildClass : Nom de la classe dérivée.

functionName : Le nom de la fonction à réécrire.

argumentList : Réécrivez la liste des paramètres de la fonction.

Cas pratique : Classe de base de forme géométrique 🎜🎜🎜Considérons une classe de base de forme géométrique qui définit une fonction virtuelle aire pour calculer l'aire de la forme : 🎜

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

private:
  int value;
};

🎜Nous créons un dérivé classe Carré et Cercle, respectivement carré et cercle : 🎜

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

🎜🎜remplace les défauts de la classe parent🎜🎜🎜Forme la zone est abstraite car elle n’a pas d’implémentation concrète. Les sous-classes doivent fournir leur propre implémentation. Cependant, pour les cercles comme <code>Circle, la fonction area de la classe parent est erronée car elle ne prend pas en compte pi. 🎜🎜En remplaçant la fonction area de la classe Circle, nous pouvons remplacer les défauts de la classe parent et fournir un calcul de surface correct : 🎜rrreee🎜🎜Optimiser la structure du code🎜🎜🎜 Considérons une autre classe A Vector avec les méthodes suivantes : 🎜rrreee🎜Nous pouvons repenser ce code en remplaçant les opérateurs d'addition , pour améliorer la lisibilité et la maintenabilité du code. Caractéristiques : 🎜 rrreee🎜L'opérateur de substitution nous permet d'opérer des vecteurs avec une syntaxe plus simple et plus claire : 🎜rrreee🎜🎜Conclusion🎜🎜🎜La substitution de fonctions est un mécanisme puissant en C++ qui permet aux sous-classes de remplacer les défauts des classes parentes et d'optimiser la structure du code. En examinant attentivement la conception et la mise en œuvre des fonctions remplacées, nous pouvons améliorer la robustesse, la lisibilité et la maintenabilité de nos programmes. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!