Surcharge de fonction VS Override en C++

1. Utiliser la surcharge de fonction pour définir plusieurs fonctions avec différentes listes de paramètres en C++
2. Utiliser la substitution de fonction pour redéfinir les membres hérités dans la classe dérivée en C++

Cet article présentera les différences entre la surcharge de fonctions et la substitution de fonctions en C++.

Utiliser la surcharge de fonction pour définir plusieurs fonctions avec différentes listes de paramètres en C++

La surcharge de fonction est la caractéristique du langage C++ pour pouvoir avoir plusieurs fonctions avec le même nom, qui ont des paramètres différents et sont situées dans une même portée. En règle générale, les fonctions surchargées effectuent des opérations très similaires, et il est tout simplement intuitif de définir un nom de fonction unique pour elles et d’exposer l’interface avec plusieurs jeux de paramètres. Dans ce cas, nous avons défini une classe nommée Planet avec trois fonctions nommées printNumAcu. Toutes ces fonctions ont des paramètres différents, et elles sont différenciées au moment de la compilation. Notez que les fonctions surchargées doivent avoir des types de paramètres différents ou un nombre différent de paramètres.

#include <iostream>

using std::cin;
using std::cout;
using std::endl;
using std::string;

class Planet {
 private:
  int num{};

 public:
  explicit Planet(int i) : num(i) {}

  void printNumAcu() const { cout << num * num << endl; }

  void printNumAcu(int x) const { cout << num * num * x << endl; }

  void printNumAcu(int x, int y) const { cout << num * num * x * y << endl; }
};

int main() {
  Planet m1(3);

  m1.printNumAcu();
  m1.printNumAcu(3);
  m1.printNumAcu(3, 3);

  return EXIT_SUCCESS;
}

Production:

9
27
81

Utiliser la substitution de fonction pour redéfinir les membres hérités dans la classe dérivée en C++

La substitution de fonction est la fonctionnalité associée aux classes dérivées et à leur héritage. Habituellement, les classes dérivées héritent de tous les membres de la classe de base et certaines sont redéfinies dans la classe dérivée pour implémenter une routine personnalisée. Notez, cependant, que la classe de base doit spécifier les fonctions membres qui sont censées être remplacées. Ces fonctions membres sont appelées fonctions virtuelles et incluent également le mot-clé virtual dans une définition. Il existe également un concept de fonction virtuelle pure, qui est un type de fonction virtuelle qui n’a pas besoin d’être défini. Les classes qui incluent ou héritent (sans surcharger) d’une fonction virtuelle pure sont appelées classes de base abstraites, qui ne devraient généralement pas être utilisées pour créer des objets, mais plutôt dériver d’autres classes.

#include <iostream>

using std::cin;
using std::cout;
using std::endl;
using std::string;

class Planet {
 protected:
  int num{};

 public:
  explicit Planet(int i) : num(i) {}

  virtual void printName() = 0;
};

class Mars : public Planet {
 public:
  explicit Mars(int i) : Planet(i) {}

  void printName() override { cout << "Name's Mars " << num << endl; }
};

class Earth : public Mars {
 public:
  explicit Earth(int i) : Mars(i) {}

  void printName() override { cout << "Name's Earth " << num << endl; }
};

int main() {
  Earth e1(3);

  e1.printName();
  Mars m1 = e1;
  m1.printName();

  return EXIT_SUCCESS;
}

Production:

Name's Earth 3
Name's Mars 3