Parametrisierter Konstruktor

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

Ein parametrisierter Konstruktor akzeptiert Argumente, mit denen Sie ein Objekt zum Zeitpunkt der Erstellung mit spezifischen Werten initialisieren können. Anstatt sich auf Standardwerte zu verlassen, können Sie den Anfangszustand jedes Objekts individuell anpassen.

class Player {
    std::string name;
    int health;
    int level;
public:
    Player(std::string n, int h, int lvl) {
        name = n;
        health = h;
        level = lvl;
    }
};

Player hero("Archer", 100, 5);
Player mage("Wizard", 80, 7);

Sie können mehrere parametrisierte Konstruktoren mit unterschiedlichen Parameterlisten definieren. Dies wird als Überladen von Konstruktoren bezeichnet, und der Compiler wählt basierend auf den von Ihnen angegebenen Argumenten den passenden aus.

class Rectangle {
    int width, height;
public:
    Rectangle(int side) {          // Quadrat
        width = height = side;
    }
    
    Rectangle(int w, int h) {      // Rechteck
        width = w;
        height = h;
    }
};

Rectangle square(10);        // Ruft den ersten Konstruktor auf
Rectangle rect(10, 20);      // Ruft den zweiten Konstruktor auf

Parameter können Standardwerte haben, wodurch einige Argumente optional werden. Dies reduziert die Notwendigkeit für mehrere überladene Konstruktoren.

class Enemy {
    std::string type;
    int damage;
public:
    Enemy(std::string t, int d = 10) : type(t), damage(d) {}
};

Enemy goblin("Goblin");       // damage ist standardmäßig 10
Enemy dragon("Dragon", 50);   // damage auf 50 gesetzt

Erinnern Sie sich an die vorherige Lektion: Sobald Sie einen parametrisierten Konstruktor definieren, erzeugt der Compiler keinen Standardkonstruktor mehr automatisch. Wenn Sie beide benötigen, müssen Sie den Standardkonstruktor explizit definieren.

Aufgabe

Einfach

Lassen Sie uns ein Produktinventarsystem erstellen, das zeigt, wie parametrisierte Konstruktoren es Ihnen ermöglichen, Objekte mit spezifischen Anfangswerten zu erstellen, und wie Konstruktor-Überladung Flexibilität bei der Objekterstellung bietet.

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

Product.h: Definieren Sie eine Klasse Product, die Artikel in einem Inventar repräsentiert. Ihre Klasse sollte Folgendes enthalten:
- Private Attribute für name (string), price (double) und quantity (integer)
- Einen Konstruktor, der alle drei Parameter (name, price, quantity) entgegennimmt, um ein Produkt vollständig zu initialisieren
- Einen Konstruktor, der nur name und price entgegennimmt, wobei quantity standardmäßig auf 1 gesetzt wird
- Einen Konstruktor, der nur einen name entgegennimmt, wobei price standardmäßig auf 0.0 und quantity standardmäßig auf 0 gesetzt wird
- Eine Methode display(), die die Produktinformationen im Format "<name>: ": $ (x)"lt;price> (x<quantity>)" ausgibt
- Eine Methode getTotalValue(), die den Preis multipliziert mit der Menge zurückgibt
main.cpp: Demonstrieren Sie alle drei Konstruktoren, indem Sie Eingaben lesen und Produkte auf verschiedene Arten erstellen. Lesen Sie Folgendes aus der Eingabe:
- Erste Zeile: ein Produktname, Preis und Menge (durch Leerzeichen getrennt)
- Zweite Zeile: ein Produktname und Preis (durch Leerzeichen getrennt)
- Dritte Zeile: nur ein Produktname
Erstellen Sie drei Product-Objekte unter Verwendung des jeweils passenden Konstruktors für jede Eingabe, rufen Sie display() für jedes Objekt auf und geben Sie dann den Gesamtwert aller drei Produkte kombiniert im Format "Total inventory value: "Total inventory value: $"lt;value>" aus.

Verwenden Sie für die Preisausgabe eine Dezimalstelle. Wenn Sie beispielsweise ein Produkt "Laptop" mit dem Preis 999.99 und der Menge 5 erstellen, sollte die Anzeige "Laptop: $999.99 (x5)" lauten.

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

Spickzettel

Ein parametrisierter Konstruktor akzeptiert Argumente, um ein Objekt zum Zeitpunkt der Erstellung mit spezifischen Werten zu initialisieren:

class Player {
    std::string name;
    int health;
    int level;
public:
    Player(std::string n, int h, int lvl) {
        name = n;
        health = h;
        level = lvl;
    }
};

Player hero("Archer", 100, 5);

Überladen von Konstruktoren ermöglicht mehrere Konstruktoren mit unterschiedlichen Parameterlisten:

class Rectangle {
    int width, height;
public:
    Rectangle(int side) {          // Quadrat
        width = height = side;
    }
    
    Rectangle(int w, int h) {      // Rechteck
        width = w;
        height = h;
    }
};

Rectangle square(10);        // Ruft den ersten Konstruktor auf
Rectangle rect(10, 20);      // Ruft den zweiten Konstruktor auf

Standardparameterwerte machen Argumente optional:

class Enemy {
    std::string type;
    int damage;
public:
    Enemy(std::string t, int d = 10) : type(t), damage(d) {}
};

Enemy goblin("Goblin");       // damage ist standardmäßig 10
Enemy dragon("Dragon", 50);   // damage wird auf 50 gesetzt

Sobald Sie einen parametrisierten Konstruktor definieren, generiert der Compiler keinen Standardkonstruktor mehr automatisch.

Probier es selbst

#include <iostream>
#include <iomanip>
#include <string>
#include "Product.h"

using namespace std;

int main() {
    // Erstes Produkt einlesen: Name, Preis und Menge
    string name1;
    double price1;
    int quantity1;
    cin >> name1 >> price1 >> quantity1;
    
    // Zweites Produkt einlesen: Name und Preis
    string name2;
    double price2;
    cin >> name2 >> price2;
    
    // Drittes Produkt einlesen: nur Name
    string name3;
    cin >> name3;
    
    // TODO: Drei Product-Objekte mit dem jeweils passenden Konstruktor erstellen
    
    // TODO: display() für jedes Produkt aufrufen
    
    // TODO: Gesamten Inventarwert berechnen und ausgeben
    // Format: "Total inventory value: $<value>"
    // fixed und setprecision(1) für eine Dezimalstelle verwenden
    
    return 0;
}