Constructeur paramétré

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy — leçon 19 sur 104.

Un constructeur paramétré accepte des arguments qui vous permettent d'initialiser un objet avec des valeurs spécifiques au moment de sa création. Au lieu de s'appuyer sur des valeurs par défaut, vous pouvez personnaliser l'état initial de chaque objet.

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

Vous pouvez définir plusieurs constructeurs paramétrés avec des listes de paramètres différentes. C'est ce qu'on appelle la surcharge de constructeur, et le compilateur sélectionne celui qui convient en fonction des arguments que vous fournissez.

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

Rectangle square(10);        // Appelle le premier constructeur
Rectangle rect(10, 20);      // Appelle le second constructeur

Les paramètres peuvent avoir des valeurs par défaut, rendant certains arguments optionnels. Cela réduit le besoin de plusieurs constructeurs surchargés.

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

Enemy goblin("Goblin");       // damage vaut 10 par défaut
Enemy dragon("Dragon", 50);   // damage est fixé à 50

Rappelez-vous de la leçon précédente : une fois que vous définissez un constructeur paramétré, le compilateur ne génère plus automatiquement de constructeur par défaut. Si vous avez besoin des deux, vous devez définir explicitement le constructeur par défaut.

Défi

Facile

Construisons un système d'inventaire de produits qui démontre comment les constructeurs paramétrés vous permettent de créer des objets avec des valeurs initiales spécifiques, et comment la surcharge de constructeurs offre de la flexibilité dans la création d'objets.

Vous allez créer deux fichiers pour organiser votre code :

Product.h : Définissez une classe Product qui représente les articles d'un inventaire. Votre classe doit avoir :
- Des attributs privés pour name (string), price (double), et quantity (integer)
- Un constructeur qui prend les trois paramètres (name, price, quantity) pour initialiser complètement un produit
- Un constructeur qui ne prend que le nom et le prix, avec la quantité par défaut à 1
- Un constructeur qui ne prend qu'un nom, avec le prix par défaut à 0.0 et la quantité par défaut à 0
- Une méthode display() qui affiche les informations du produit au format : "<name>: "<name>: $<price> (x<quantity>)"lt;price> (x<quantity>)"
- Une méthode getTotalValue() qui retourne le prix multiplié par la quantité
main.cpp : Démontrez les trois constructeurs en lisant l'entrée et en créant des produits de différentes manières. Lisez les éléments suivants à partir de l'entrée :
- Première ligne : un nom de produit, un prix et une quantité (séparés par des espaces)
- Deuxième ligne : un nom de produit et un prix (séparés par des espaces)
- Troisième ligne : juste un nom de produit
Créez trois objets Product en utilisant le constructeur approprié pour chaque entrée, appelez display() sur chacun d'eux, puis affichez la valeur totale des trois produits combinés au format : "Total inventory value: "Total inventory value: $<value>"lt;value>"

Pour l'affichage du prix, utilisez une précision d'une décimale. Par exemple, si vous créez un produit "Laptop" avec un prix de 999.99 et une quantité de 5, l'affichage doit montrer "Laptop: $999.99 (x5)".

Incluez votre fichier d'en-tête dans main.cpp en utilisant #include "Product.h".

Aide-mémoire

Un constructeur paramétré accepte des arguments pour initialiser un objet avec des valeurs spécifiques au moment de sa création :

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

La surcharge de constructeur permet d'avoir plusieurs constructeurs avec des listes de paramètres différentes :

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

Rectangle square(10);        // Calls first constructor
Rectangle rect(10, 20);      // Calls second constructor

Les valeurs de paramètres par défaut rendent les arguments optionnels :

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

Enemy goblin("Goblin");       // damage defaults to 10
Enemy dragon("Dragon", 50);   // damage set to 50

Une fois que vous définissez un constructeur paramétré, le compilateur ne génère plus automatiquement de constructeur par défaut.

Essayez vous-même

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

using namespace std;

int main() {
    // Lire le premier produit : nom, prix et quantité
    string name1;
    double price1;
    int quantity1;
    cin >> name1 >> price1 >> quantity1;
    
    // Lire le deuxième produit : nom et prix
    string name2;
    double price2;
    cin >> name2 >> price2;
    
    // Lire le troisième produit : juste le nom
    string name3;
    cin >> name3;
    
    // TODO: Créer trois objets Product en utilisant le constructeur approprié pour chacun
    
    // TODO: Appeler display() sur chaque produit
    
    // TODO: Calculer et afficher la valeur totale de l'inventaire
    // Format : "Total inventory value: $<value>"
    // Utiliser fixed et setprecision(1) pour une décimale
    
    return 0;
}