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 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 compteur. Votre classe doit comporter :
- un attribut count privé (entier)
- un attribut name privé (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 renvoie la valeur actuelle du compteur
- une méthode getName() qui renvoie le nom du compteur
main.cpp : montrez que les constructeurs par défaut fonctionnent lors de la création d'objets de différentes façons. Lisez un nombre saisi indiquant combien de fois incrémenter le compteur, puis :
- créez un Counter à l'aide de l'initialisation directe : Counter c1;
- créez un autre Counter à l'aide de l'initialisation par accolades : Counter c2{};
- incrémentez c1 le nombre de fois indiqué par la saisie
- 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 façon dont il est créé.

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

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