Überladener Konstruktor in C++

In diesem Artikel wird erläutert, wie Sie überladene Konstruktoren in C++ implementieren.

Konstruktor-Grundlagen und Konstruktor-Überladung in C++

Ein Konstruktor ist eine spezielle Memberfunktion in der C++-Klasse, die die Aufgabe hat, die Objekte der Klasse zu initialisieren. Konstruktoren haben keine speziellen Namen und können nicht direkt aufgerufen werden, aber jedes Mal, wenn eine bestimmte Klasse erstellt wird, wird normalerweise ein entsprechender Konstruktor aufgerufen. Allerdings deklarieren wir Konstruktoren mit demselben Namen wie die Klasse selbst. Da C++ eine Möglichkeit bietet, mehrere Funktionen mit demselben Namen in einem bestimmten Bereich zu definieren, können wir auch mehrere Konstruktoren für eine einzelne Klasse definieren.

Beachten Sie, dass die Regeln zum Überladen von Funktionen ähnlich für die überladenen Konstruktoren gelten, da sie sich in der Anzahl der akzeptierten Parameter oder Typen unterscheiden müssen. C++ bezeichnet verschiedene Arten von Konstruktoren, die oft spezifische Anwendungsfälle haben, aber wir werden diese Details in diesem Artikel wegen ihres enormen Umfangs nicht vertiefen.

Im folgenden Beispielcode wird die Klasse Student definiert, die zwei private Datenmember vom Typ string enthält. Diese Member sollen beim Erstellen einer neuen Instanz der Klasse Student initialisiert werden, aber nehmen wir an, dass nur das Member name obligatorisch ist. Folglich benötigen wir verschiedene Methoden, um das Objekt dieser Klasse zu konstruieren, von denen eine nur das Member name initialisiert.

Somit definieren wir den ersten Konstruktor, der nur einen string-Parameter nimmt und die entsprechende Meldung an die Konsole ausgibt. Der letztere Schritt wird nur verwendet, um das Verhalten von Konstruktoren leicht zu identifizieren. Darüber hinaus definieren wir auch einen zweiten Konstruktor, der zwei string-Parameter akzeptiert und beide Datenelemente initialisiert – name und 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;
}

Ausgabe:

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

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

Beachten Sie, dass beim Erstellen des Objekts s1 im Programm main der zweite Konstruktor aufgerufen wird, da wir zwei Argumente angegeben haben, und wenn s2 initialisiert wird, wird der erste Konstruktor aufgerufen. In diesem Fall hatten wir zwei Konstruktoren mit einer unterschiedlichen Anzahl von Parametern, aber im Allgemeinen können wir zwei Konstruktoren mit der gleichen Anzahl von Parametern definieren, die sich in den Typen unterscheiden, die sie akzeptieren.