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, ce qui rend certains arguments optionnels. Cela réduit le besoin d'avoir 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 des articles dans 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 prend uniquement name et price, avec quantity par défaut à 1
- Un constructeur qui prend uniquement un name, avec price par défaut à 0.0 et quantity par défaut à 0
- Une méthode display() qui affiche les informations du produit au format : "<name>: $<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: $<value>"

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

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

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