Masquage de l’information

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

La dissimulation de l’information va au-delà de la simple utilisation de spécificateurs d’accès. Il s’agit d’un principe de conception selon lequel vous masquez non seulement les données, mais aussi les détails d’implémentation du fonctionnement interne de votre classe.

L’objectif est d’exposer uniquement ce que les utilisateurs de votre classe doivent savoir, tout en gardant tout le reste caché. Cela vous permet de modifier l’implémentation interne sans affecter le code qui utilise votre classe :

class Temperature {
    double kelvin;    // Représentation interne - détail caché
    
public:
    void setCelsius(double c) {
        kelvin = c + 273.15;    // Conversion cachée à l'utilisateur
    }
    
    double getCelsius() const {
        return kelvin - 273.15;
    }
    
    double getFahrenheit() const {
        return (kelvin - 273.15) * 9.0/5.0 + 32;
    }
};

Les utilisateurs de cette classe ne savent pas (et n’ont pas besoin de savoir) que la température est stockée en Kelvin en interne. Si vous décidez plus tard de la stocker plutôt en Celsius, vous ne modifiez que l’implémentation privée : l’interface publique reste inchangée.

Cette séparation entre l’interface et l’implémentation offre plusieurs avantages : elle réduit la complexité pour les utilisateurs de votre classe, empêche la mauvaise utilisation accidentelle des données internes et facilite la maintenance de votre code. Lorsque les détails internes sont masqués, vous pouvez optimiser ou remanier votre code sans risque de casser le code existant qui dépend de votre classe.

Défi

Facile

Construisons une classe Distance qui illustre la dissimulation des informations en stockant les distances en interne en centimètres, tout en fournissant une interface claire pour travailler avec différentes unités. Les utilisateurs de votre classe n'auront pas besoin de savoir (ni de se soucier de) comment la distance est stockée en interne : ils travailleront simplement avec l'unité qui leur convient.

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

Distance.h : définissez une classe Distance qui masque sa représentation interne tout en exposant une interface publique flexible. En interne, stockez la distance en centimètres (sous la forme d'un double). Il s'agit de votre détail d'implémentation caché. Votre interface publique doit permettre aux utilisateurs de :
- Définir la distance à l'aide de setMeters(double m), setCentimeters(double cm) ou setKilometers(double km)
- Obtenir la distance à l'aide de getMeters(), getCentimeters() ou getKilometers() : toutes doivent être des méthodes const
- Additionner deux distances avec add(const Distance& other), qui renvoie un nouvel objet Distance
Incluez un constructeur par défaut qui initialise la distance à zéro. La logique de conversion doit être masquée à l'intérieur de vos méthodes : les utilisateurs appellent simplement setKilometers(5) et getMeters() sans se soucier du format de stockage interne.
main.cpp : démontrez que les utilisateurs peuvent travailler avec votre classe sans connaître sa représentation interne. Lisez deux valeurs de distance depuis l'entrée : la première en mètres, la seconde en kilomètres. Ensuite :
- Créez un objet Distance et définissez-le à l'aide de la valeur en mètres
- Affichez "In meters: <value> m"
- Affichez "In centimeters: <value> cm"
- Affichez "In kilometers: <value> km"
- Créez un deuxième objet Distance et définissez-le à l'aide de la valeur en kilomètres
- Additionnez les deux distances et stockez le résultat
- Affichez "Combined in meters: <value> m"

L'avantage de la dissimulation des informations est que vous pourriez ultérieurement modifier le stockage interne, en passant des centimètres aux millimètres (ou à toute autre unité), sans changer la manière dont les utilisateurs interagissent avec votre classe. L'interface publique reste stable même si l'implémentation change.

Formatez toutes les valeurs affichées avec deux chiffres après la virgule à l'aide de std::fixed et std::setprecision(2) provenant de <iomanip>. Convertissez les chaînes d'entrée en doubles à l'aide de std::stod().

Référence de conversion : 1 mètre = 100 centimètres, 1 kilomètre = 1000 mètres.

Essayez vous-même

#include <iostream>
#include <string>
#include <iomanip>
#include "Distance.h"

using namespace std;

int main() {
    // Lire les valeurs d'entrée
    string metersInput, kmInput;
    cin >> metersInput;  // Première valeur en mètres
    cin >> kmInput;      // Second value in kilometers
    
    // Convertir les chaînes en doubles en utilisant std::stod()
    double metersValue = stod(metersInput);
    double kmValue = stod(kmInput);
    
    // Définir le formatage de la sortie
    cout << fixed << setprecision(2);
    
    // TODO: Créer le premier objet Distance et le définir en utilisant la valeur en mètres
    
    // TODO: Afficher "In meters: <value> m"
    
    // TODO: Print "In centimeters: <value> cm"
    
    // TODO: Print "In kilometers: <value> km"
    
    // TODO: Créer le second objet Distance et le définir en utilisant la valeur en kilomètres
    
    // TODO: Ajouter les deux distances ensemble en utilisant la méthode add()
    
    // TODO: Print "Combined in meters: <value> m"
    
    return 0;
}