Constructeur par défaut

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

Un constructeur par défaut est un constructeur qui peut être appelé sans aucun argument. Il initialise un objet lorsqu'aucune valeur initiale n'est fournie. Chaque classe a besoin d'un moyen de créer des objets dans un état par défaut valide.

Si vous ne définissez aucun constructeur, le compilateur génère un constructeur par défaut implicite qui ne fait rien pour les types primitifs et appelle les constructeurs par défaut pour les objets membres.

class Player {
    int health;
    int score;
public:
    Player() {           // Constructeur par défaut
        health = 100;
        score = 0;
    }
};

Player p1;               // Appelle le constructeur par défaut
Player p2{};             // Appelle également le constructeur par défaut

Une fois que vous définissez un constructeur (comme un constructeur paramétré), le compilateur ne génère plus de constructeur par défaut. Vous devez en définir un explicitement si vous en avez toujours besoin.

class Enemy {
    int damage;
public:
    Enemy(int d) : damage(d) {}  // Constructeur paramétré uniquement
};

Enemy e1(10);    // Fonctionne
Enemy e2;        // Erreur ! Pas de constructeur par défaut

En C++ moderne, vous pouvez demander explicitement le constructeur par défaut généré par le compilateur en utilisant = default :

class Item {
    int id;
public:
    Item() = default;           // Le compilateur génère le constructeur par défaut
    Item(int i) : id(i) {}
};

Les constructeurs par défaut sont essentiels pour créer des tableaux d'objets et pour les classes utilisées dans des conteneurs comme std::vector, qui peuvent avoir besoin de construire des éléments sans arguments.

Défi

Facile

Construisons un système de compteur simple qui démontre comment les constructeurs par défaut initialisent les objets dans un état de départ valide.

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

Counter.h : Définissez une classe Counter qui suit une valeur de comptage. Votre classe doit avoir :
- Un attribut privé count (entier)
- Un attribut privé name (chaîne de caractères) pour identifier le compteur
- Un constructeur par défaut qui initialise count à 0 et name à "Unnamed", puis affiche "Counter created: <name>"
- Une méthode increment() qui augmente le compteur de 1
- Une méthode getCount() qui retourne le compte actuel
- Une méthode getName() qui retourne le nom du compteur
main.cpp : Démontrez que les constructeurs par défaut fonctionnent lors de la création d'objets de différentes manières. Lisez un nombre à partir de l'entrée indiquant combien de fois incrémenter le compteur, puis :
- Créez un Counter en utilisant l'initialisation directe : Counter c1;
- Créez un autre Counter en utilisant l'initialisation par accolades : Counter c2{};
- Incrémentez c1 le nombre de fois spécifié par l'entrée
- Affichez "<name>: <count>" pour c1
- Affichez "<name>: <count>" pour c2

Les deux compteurs doivent commencer à 0 grâce à votre constructeur par défaut, mais seul c1 sera incrémenté. Cela montre comment les constructeurs par défaut garantissent que chaque objet commence dans un état prévisible et valide, quelle que soit la manière dont il est créé.

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

Aide-mémoire

Un constructeur par défaut est un constructeur qui peut être appelé sans aucun argument. Il initialise un objet lorsque aucune valeur initiale n'est fournie.

class Player {
    int health;
    int score;
public:
    Player() {           // Default constructor
        health = 100;
        score = 0;
    }
};

Player p1;               // Calls default constructor
Player p2{};             // Also calls default constructor

Si vous ne définissez aucun constructeur, le compilateur génère un constructeur par défaut implicite. Cependant, dès que vous définissez un constructeur (comme un constructeur paramétré), le compilateur ne génère plus automatiquement de constructeur par défaut.

class Enemy {
    int damage;
public:
    Enemy(int d) : damage(d) {}  // Parameterized constructor only
};

Enemy e1(10);    // Works
Enemy e2;        // Error! No default constructor

Vous pouvez explicitement demander le constructeur par défaut généré par le compilateur en utilisant = default :

class Item {
    int id;
public:
    Item() = default;           // Compiler generates default constructor
    Item(int i) : id(i) {}
};

Les constructeurs par défaut sont essentiels pour créer des tableaux d'objets et pour les classes utilisées dans des conteneurs comme std::vector.

Essayez vous-même

#include <iostream>
#include "Counter.h"

using namespace std;

int main() {
    // Lire le nombre de fois à incrémenter
    int n;
    cin >> n;

    // TODO: Créer un Counter en utilisant l'initialisation directe : Counter c1;

    // TODO: Créer un autre Counter en utilisant l'initialisation par accolades : Counter c2{};

    // TODO: Incrémenter c1 le nombre de fois spécifié par n

    // TODO: Afficher "<name>: <count>" pour c1

    // TODO: Afficher "<name>: <count>" pour c2

    return 0;
}