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

Erstelle ein einfaches Zählersystem, das demonstriert, wie Standardkonstruktoren Objekte in einem gültigen Ausgangszustand initialisieren.

Du erstellst zwei Dateien, um deinen Code zu organisieren:

Counter.h: Definiere eine Counter-Klasse, die einen Zählerwert verfolgt. Deine Klasse sollte Folgendes enthalten:
- Ein privates count-Attribut (Ganzzahl)
- Ein privates name-Attribut (Zeichenkette), um den Zähler zu identifizieren
- Einen Standardkonstruktor, der count auf 0 und name auf "Unnamed" initialisiert und anschließend "Counter created: <name>" ausgibt
- Eine increment()-Methode, die den Zähler um 1 erhöht
- Eine getCount()-Methode, die den aktuellen Zählerstand zurückgibt
- Eine getName()-Methode, die den Namen des Zählers zurückgibt
main.cpp: Zeige, dass Standardkonstruktoren funktionieren, wenn Objekte auf unterschiedliche Arten erstellt werden. Lies eine Zahl aus der Eingabe ein, die angibt, wie oft der Zähler erhöht werden soll, und:
- Erstelle einen Counter mittels direkter Initialisierung: Counter c1;
- Erstelle einen weiteren Counter mittels Initialisierung mit geschweiften Klammern: Counter c2{};
- Erhöhe c1 so oft, wie durch die Eingabe angegeben
- Gib für c1 "<name>: <count>" aus
- Gib für c2 "<name>: <count>" aus

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

Binde deine Header-Datei in main.cpp mit #include "Counter.h" ein.

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