Constructeur surchargé en C++

Cet article explique comment implémenter des constructeurs surchargés en C++.

Principes de base des constructeurs et surcharge des constructeurs en C++

Le constructeur est une fonction membre spéciale de la classe C++ chargée d’initialiser les objets de la classe. Les constructeurs n’ont pas de noms spéciaux et ne peuvent pas être appelés directement, mais chaque fois qu’une classe donnée est créée, un constructeur correspondant est généralement invoqué. Cependant, nous déclarons des constructeurs avec le même nom que la classe elle-même. Puisque C++ fournit un moyen de définir plusieurs fonctions avec le même nom dans une portée donnée, nous pouvons également définir plusieurs constructeurs pour une seule classe.

Notez que les règles de surcharge de fonction s’appliquent de la même manière aux constructeurs surchargés, car ils doivent différer dans le nombre de paramètres ou de types qu’ils acceptent. C++ désigne différents types de constructeurs, qui ont souvent des cas d’utilisation spécifiques, mais nous n’entrerons pas dans ces détails dans cet article en raison de sa portée massive.

Dans l’exemple de code suivant, la classe Student est définie, comprenant deux données membres private de type string. Ces membres sont censés être initialisés lors de la création d’une nouvelle instance de la classe Student, mais supposons que seul le membre name soit obligatoire. Par conséquent, nous avons besoin de différentes méthodes pour construire l’objet de cette classe, dont l’une n’initialise que le membre name.

Ainsi, nous définissons le premier constructeur qui ne prend qu’un seul paramètre string et imprime le message correspondant à la console. Cette dernière étape ne sert qu’à identifier facilement le comportement des constructeurs. De plus, nous définissons également un deuxième constructeur qui accepte deux paramètres string et initialise les deux membres de données - name et last_name.

#include <iostream>

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

class Student {
 private:
  string name;
  string last_name;

 public:
  explicit Student(string n) : name(std::move(n)) {
    cout << "Constructor 1 is called" << endl;
  };
  Student(string &n, string &ln) : name(n), last_name(ln) {
    cout << "Constructor 2 is called" << endl;
  };

  string getName() { return name; }

  string getLastName() { return last_name; }
};

int main() {
  string n1("James");
  string n2("Kale");

  Student s1(n1, n2);
  cout << s1.getName() << endl;
  cout << s1.getLastName() << endl;
  cout << "------------------" << endl;

  Student s2(n1);
  cout << s2.getName() << endl;
  cout << s2.getLastName() << endl;
  cout << "------------------" << endl;

  return EXIT_SUCCESS;
}

Production:

Constructor 2 is called
James
Kale
------------------
Constructor 1 is called
James

------------------

Notez que lorsque nous créons l’objet s1 dans le programme main, le deuxième constructeur est invoqué puisque nous avons fourni deux arguments, et lorsque s2 est initialisé, le premier constructeur est appelé. Dans ce cas, nous avions deux constructeurs avec un nombre différent de paramètres, mais en général, nous pouvons définir deux constructeurs avec le même nombre de paramètres qui diffèrent par les types qu’ils acceptent.