Standardkonstruktor

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy — Lektion 18 von 104.

Ein Standardkonstruktor ist ein Konstruktor, der ohne Argumente aufgerufen werden kann. Er initialisiert ein Objekt, wenn keine Initialwerte angegeben werden. Jede Klasse benötigt eine Möglichkeit, Objekte in einem gültigen Standardzustand zu erstellen.

Wenn Sie keinen Konstruktor definieren, generiert der Compiler einen impliziten Standardkonstruktor, der für primitive Typen nichts tut und Standardkonstruktoren für Member-Objekte aufruft.

class Player {
    int health;
    int score;
public:
    Player() {           // Standardkonstruktor
        health = 100;
        score = 0;
    }
};

Player p1;               // Ruft den Standardkonstruktor auf
Player p2{};             // Ruft ebenfalls den Standardkonstruktor auf

Sobald Sie einen Konstruktor definieren (wie einen parametrisierten), generiert der Compiler keinen Standardkonstruktor mehr. Sie müssen explizit einen definieren, wenn Sie ihn weiterhin benötigen.

class Enemy {
    int damage;
public:
    Enemy(int d) : damage(d) {}  // Nur parametrisierter Konstruktor
};

Enemy e1(10);    // Funktioniert
Enemy e2;        // Fehler! Kein Standardkonstruktor

In modernem C++ können Sie den vom Compiler generierten Standardkonstruktor explizit mit = default anfordern:

class Item {
    int id;
public:
    Item() = default;           // Compiler generiert Standardkonstruktor
    Item(int i) : id(i) {}
};

Standardkonstruktoren sind essenziell für das Erstellen von Arrays von Objekten und für Klassen, die in Containern wie std::vector verwendet werden, welche möglicherweise Elemente ohne Argumente konstruieren müssen.

Aufgabe

Einfach

Lassen Sie uns ein einfaches Zählersystem bauen, das demonstriert, wie Standardkonstruktoren Objekte in einen gültigen Anfangszustand initialisieren.

Sie werden zwei Dateien erstellen, um Ihren Code zu organisieren:

Counter.h: Definieren Sie eine Counter-Klasse, die einen Zählwert verfolgt. Ihre Klasse sollte Folgendes haben:
- Ein privates count-Attribut (Integer)
- Ein privates name-Attribut (String), um den Zähler zu identifizieren
- Einen Standardkonstruktor, der count mit 0 und name mit "Unnamed" initialisiert und dann "Counter created: <name>" ausgibt
- Eine increment()-Methode, die den Zähler um 1 erhöht
- Eine getCount()-Methode, die den aktuellen Zählwert zurückgibt
- Eine getName()-Methode, die den Namen des Zählers zurückgibt
main.cpp: Demonstrieren Sie, dass Standardkonstruktoren funktionieren, wenn Objekte auf verschiedene Arten erstellt werden. Lesen Sie eine Zahl aus der Eingabe ein, die angibt, wie oft der Zähler erhöht werden soll, und dann:
- Erstellen Sie einen Counter mittels direkter Initialisierung: Counter c1;
- Erstellen Sie einen weiteren Counter mittels Klammer-Initialisierung: Counter c2{};
- Erhöhen Sie c1 so oft, wie durch die Eingabe angegeben
- Geben Sie "<name>: <count>" für c1 aus
- Geben Sie "<name>: <count>" für c2 aus

Beide Zähler sollten dank Ihres Standardkonstruktors bei 0 beginnen, aber nur c1 wird erhöht. Dies zeigt, wie Standardkonstruktoren sicherstellen, dass jedes Objekt in einem vorhersehbaren, gültigen Zustand beginnt, unabhängig davon, wie es erstellt wurde.

Binden Sie Ihre Header-Datei in main.cpp mit #include "Counter.h" ein.

Spickzettel

Ein Standardkonstruktor (default constructor) ist ein Konstruktor, der ohne Argumente aufgerufen werden kann. Er initialisiert ein Objekt, wenn keine Initialwerte angegeben werden.

class Player {
    int health;
    int score;
public:
    Player() {           // Standardkonstruktor
        health = 100;
        score = 0;
    }
};

Player p1;               // Ruft den Standardkonstruktor auf
Player p2{};             // Ruft ebenfalls den Standardkonstruktor auf

Wenn Sie keinen Konstruktor definieren, generiert der Compiler einen impliziten Standardkonstruktor. Sobald Sie jedoch einen Konstruktor definieren (z. B. einen parametrisierten), generiert der Compiler keinen Standardkonstruktor mehr automatisch.

class Enemy {
    int damage;
public:
    Enemy(int d) : damage(d) {}  // Nur parametrisierter Konstruktor
};

Enemy e1(10);    // Funktioniert
Enemy e2;        // Fehler! Kein Standardkonstruktor

Sie können den vom Compiler generierten Standardkonstruktor explizit mit = default anfordern:

class Item {
    int id;
public:
    Item() = default;           // Compiler generiert Standardkonstruktor
    Item(int i) : id(i) {}
};

Standardkonstruktoren sind essenziell für das Erstellen von Arrays von Objekten und für Klassen, die in Containern wie std::vector verwendet werden.

Probier es selbst

#include <iostream>
#include "Counter.h"

using namespace std;

int main() {
    // Lies die Anzahl der Inkrementierungen ein
    int n;
    cin >> n;

    // TODO: Erstelle einen Counter mittels direkter Initialisierung: Counter c1;

    // TODO: Erstelle einen weiteren Counter mittels Brace-Initialisierung: Counter c2{};

    // TODO: Inkrementiere c1 so oft, wie durch n angegeben

    // TODO: Gib "<name>: <count>" für c1 aus

    // TODO: Gib "<name>: <count>" für c2 aus

    return 0;
}