Accesseurs et mutateurs

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

Lorsque les membres d’une classe sont privés, le code externe ne peut pas y accéder directement. Les accesseurs en lecture et les accesseurs en écriture sont des méthodes publiques qui fournissent un accès contrôlé à ces membres privés : les accesseurs en lecture récupèrent les valeurs, tandis que les accesseurs en écriture les modifient.

class Temperature {
    double celsius;    // Privé - ne peut pas être accédé directement
    
public:
    // Getter - retourne la valeur
    double getCelsius() const {
        return celsius;
    }
    
    // Setter - modifie la valeur avec validation
    void setCelsius(double value) {
        if (value >= -273.15) {    // Vérification du zéro absolu
            celsius = value;
        }
    }
};

La véritable puissance des setters réside dans la validation.

Plutôt que d’autoriser l’affectation de n’importe quelle valeur, vous pouvez imposer des règles. Dans l’exemple ci-dessus, les températures inférieures au zéro absolu sont rejetées. Sans setter, n’importe qui pourrait affecter directement des données invalides.

Les Getter peuvent également transformer les données avant de les renvoyer :

class Temperature {
    double celsius;
public:
    double getCelsius() const { return celsius; }
    
    // Getter calculé - ne stocke pas fahrenheit, le calcule
    double getFahrenheit() const {
        return celsius * 9.0 / 5.0 + 32.0;
    }
    
    void setCelsius(double value) { celsius = value; }
};

Remarquez le mot-clé const sur les getters : cela indique qu’ils ne modifient pas l’objet. Les setters ne peuvent pas être const, puisque leur rôle est de modifier les valeurs des membres. Ce modèle d’utilisation des getters et des setters est fondamental pour l’encapsulation, car il vous donne un contrôle total sur la manière dont les données de votre classe sont consultées et modifiées.

Défi

Facile

Construisons un système de profil de joueur qui montre comment les getters et les setters fournissent un accès contrôlé aux données privées, notamment avec la validation et les propriétés calculées.

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

Player.h : Définissez une classe Player qui gère le profil d’un personnage de jeu avec un accès protégé aux données. Votre classe doit comporter :
- Membres privés : name (chaîne), level (entier) et experience (entier)
- Un constructeur qui prend un nom et initialise level à 1 et experience à 0
- Un getter getName() qui renvoie le nom du joueur
- Un getter getLevel() qui renvoie le niveau actuel
- Un getter getExperience() qui renvoie les points d’expérience actuels
- Un setter setName() qui n’accepte que les noms comportant au moins 3 caractères ; s’il est invalide, conservez le nom actuel inchangé
- Un setter addExperience(int points) qui n’accepte que les valeurs positives. Lorsque l’expérience atteint ou dépasse 100, le joueur monte de niveau : incrémentez le niveau de 1 et soustrayez 100 de l’expérience. Cela peut se produire plusieurs fois si suffisamment d’expérience est ajoutée.
- Un getter calculé getExperienceToNextLevel() qui renvoie le nombre de points d’expérience supplémentaires nécessaires pour atteindre le niveau suivant (toujours 100 - current experience)
Marquez tous les getters avec const, puisqu’ils ne modifient pas l’objet.
main.cpp : Montrez les getters et les setters en action. Lisez un nom de joueur et les points d’expérience à ajouter depuis l’entrée (chacun sur une ligne distincte), puis :
- Créez un Player avec le nom saisi
- Affichez "Player: <name>, Level: <level>, XP: <experience>"
- Ajoutez les points d’expérience saisis à l’aide de addExperience()
- Affichez à nouveau la même ligne d’état pour montrer l’état mis à jour
- Affichez "XP to next level: <amount>"
- Essayez de remplacer le nom par "Al" (la validation devrait échouer)
- Affichez "Name after invalid change: <name>"
- Remplacez le nom par "Champion" (la modification devrait réussir)
- Affichez "Name after valid change: <name>"

La valeur d’expérience saisie sera fournie sous forme de chaîne que vous devrez convertir en entier. Incluez votre fichier d’en-tête dans main.cpp à l’aide de #include "Player.h".

Essayez vous-même

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

using namespace std;

int main() {
    // Lire le nom du joueur
    string playerName;
    getline(cin, playerName);

    // Lire les points d'expérience à ajouter (en tant que chaîne, convertir en int)
    string expString;
    getline(cin, expString);
    int expToAdd = stoi(expString);

    // TODO: Créer un Player avec le nom saisi

    // TODO: Afficher le statut initial : "Player: <name>, Level: <level>, XP: <experience>"

    // TODO: Ajouter les points d'expérience saisis en utilisant addExperience()

    // TODO: Afficher la ligne de statut mise à jour

    // TODO: Print "XP to next level: <amount>"

    // TODO: Essayer de changer le nom en "Al" (devrait échouer à la validation)

    // TODO: Print "Name after invalid change: <name>"

    // TODO: Changer le nom en "Champion" (devrait réussir)

    // TODO: Print "Name after valid change: <name>"

    return 0;
}