Listes d’initialisation des constructeurs

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

Vous avez vu la syntaxe des deux-points dans des leçons précédentes, comme Player(std::string n, int h) : name(n), health(h) {}. C'est ce qu'on appelle une liste d'initialisation des membres, et c'est la manière privilégiée d'initialiser les membres en C++.

La liste d'initialisation apparaît après la liste des paramètres du constructeur, en commençant par deux-points. Chaque membre est initialisé directement avec sa valeur, les éléments étant séparés par des virgules :

class Rectangle {
    int width;
    int height;
    const int id;
    int& reference;
public:
    Rectangle(int w, int h, int i, int& r) 
        : width(w), height(h), id(i), reference(r) {
        // Corps du constructeur (peut être vide)
    }
};

Pourquoi utiliser des listes d’initialisation plutôt qu’une affectation dans le corps du constructeur ? Avec une affectation, les membres sont d’abord construits par défaut, puis de nouvelles valeurs leur sont affectées. Avec les listes d’initialisation, les membres sont construits directement avec les valeurs correctes — c’est plus efficace et parfois obligatoire.

Certains membres doivent être initialisés à l’aide de la liste :

Les membres const - ne peuvent pas être affectés après la construction

Membres de référence - doivent être liés lors de l’initialisation

Membres sans constructeurs par défaut

class Player {
    const int maxHealth;    // Doit utiliser la liste d'initialisation
    std::string name;
public:
    // Ceci fonctionne
    Player(int max, std::string n) : maxHealth(max), name(n) {}
    
    // Ceci ne compilerait PAS :
    // Player(int max) { maxHealth = max; }  // Erreur !
};

Les membres sont initialisés dans l’ordre où ils sont déclarés dans la classe, et non dans l’ordre de la liste d’initialisation. Écris toujours ta liste d’initialisation dans l’ordre des déclarations afin d’éviter toute confusion.

Défi

Facile

Construisons un système de configuration pour un moteur de jeu qui montre quand et pourquoi les listes d'initialisation des membres sont essentielles. Vous allez créer une classe GameConfig avec des membres qui doivent être initialisés à l'aide de la syntaxe des listes d'initialisation.

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

GameConfig.h : définissez une classe GameConfig qui stocke les paramètres du jeu. Votre classe doit posséder :
- Un const std::string gameName : le titre du jeu, qui ne peut pas changer après sa création
- Un const int maxPlayers : le nombre maximal de joueurs, fixé lors de la construction
- Un int& difficultyRef : une référence vers un paramètre de difficulté externe
- Un int screenWidth et un int screenHeight : des membres ordinaires pour les paramètres d'affichage
- Un constructeur qui prend tous les paramètres nécessaires et initialise chaque membre à l'aide de la liste d'initialisation. La liste d'initialisation doit suivre l'ordre dans lequel les membres sont déclarés dans la classe
- Une méthode display() qui affiche la configuration dans ce format :
```
Game: <gameName>
Max Players: <maxPlayers>
Difficulty: <difficultyRef value>
Resolution: <screenWidth>x<screenHeight>
```
main.cpp : lisez les valeurs de configuration depuis l'entrée et créez un objet GameConfig. Vous devrez :
- Lire le nom du jeu (chaîne), le nombre maximal de joueurs (entier), la difficulté (entier), la largeur (entier) et la hauteur (entier) depuis l'entrée : chacun sur une ligne distincte
- Créer une variable locale de type int pour la difficulté à laquelle la configuration fera référence
- Créer un objet GameConfig à l'aide du constructeur utilisant la liste d'initialisation
- Appeler display() pour afficher la configuration initiale
- Modifier directement la variable de difficulté (la multiplier par 2)
- Afficher "After difficulty change:"
- Appeler à nouveau display() pour montrer que la référence reflète la valeur mise à jour

Ce défi met en évidence l'importance des listes d'initialisation : vos membres const et votre membre de référence ne peuvent pas être affectés dans le corps du constructeur. Ils doivent être initialisés dans la liste. Le membre de référence montre également comment les modifications apportées à la variable d'origine sont reflétées par l'intermédiaire de l'objet de configuration.

Incluez votre fichier d'en-tête dans main.cpp à l'aide de #include "GameConfig.h".

Essayez vous-même

#include <iostream>
#include <string>
#include "GameConfig.h"

using namespace std;

int main() {
    // Lire les valeurs d'entrée
    string gameName;
    getline(cin, gameName);
    
    int maxPlayers;
    cin >> maxPlayers;
    
    int difficulty;
    cin >> difficulty;
    
    int width;
    cin >> width;
    
    int height;
    cin >> height;
    
    // TODO: Créer un objet GameConfig en utilisant le constructeur avec liste d'initialisation
    // Le constructeur doit recevoir : gameName, maxPlayers, difficulty (par référence), width, height
    
    // TODO: Appeler display() pour afficher la configuration initiale
    
    // TODO: Modifier la variable difficulty directement (la multiplier par 2)
    
    // TODO: Print "After difficulty change:"
    
    // TODO: Appeler display() à nouveau pour afficher la configuration mise à jour
    
    return 0;
}