Informationsverbergung

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy. Lektion 36 von 104.

Informationsverbergung geht über die bloße Verwendung von Zugriffsbezeichnern hinaus. Es handelt sich um ein Designprinzip, bei dem du nicht nur Daten, sondern auch die Implementierungsdetails darüber verbirgst, wie deine Klasse intern funktioniert.

Das Ziel besteht darin, nur das offenzulegen, was Benutzer deiner Klasse wissen müssen, während alles andere verborgen bleibt. Dadurch kannst du die interne Implementierung ändern, ohne den Code zu beeinflussen, der deine Klasse verwendet:

class Temperature {
    double kelvin;    // Interne Darstellung - verstecktes Detail
    
public:
    void setCelsius(double c) {
        kelvin = c + 273.15;    // Konvertierung vor dem Benutzer verborgen
    }
    
    double getCelsius() const {
        return kelvin - 273.15;
    }
    
    double getFahrenheit() const {
        return (kelvin - 273.15) * 9.0/5.0 + 32;
    }
};

Benutzer dieser Klasse wissen nicht (und müssen auch nicht wissen), dass die Temperatur intern in Kelvin gespeichert wird. Wenn du dich später entscheidest, sie stattdessen in Celsius zu speichern, änderst du nur die private Implementierung – die öffentliche Schnittstelle bleibt unverändert.

Diese Trennung zwischen Schnittstelle und Implementierung bietet mehrere Vorteile: Sie reduziert die Komplexität für die Benutzer Ihrer Klasse, verhindert den versehentlichen Missbrauch interner Daten und erleichtert die Wartung Ihres Codes. Wenn die internen Details verborgen sind, können Sie optimieren oder umstrukturieren, ohne bestehenden Code zu beschädigen, der von Ihrer Klasse abhängt.

Aufgabe

Einfach

Erstellen wir eine Distance-Klasse, die das Verbergen von Informationen demonstriert, indem sie Entfernungen intern in Zentimetern speichert und gleichzeitig eine übersichtliche Schnittstelle für die Arbeit mit verschiedenen Einheiten bereitstellt. Benutzer deiner Klasse müssen nicht wissen (oder sich darum kümmern), wie die Entfernung intern gespeichert wird: Sie arbeiten einfach mit der Einheit, die für sie praktisch ist.

Du erstellst zwei Dateien, um deinen Code zu organisieren:

Distance.h: Definiere eine Distance-Klasse, die ihre interne Darstellung verbirgt und gleichzeitig eine flexible öffentliche Schnittstelle bereitstellt. Speichere die Entfernung intern in Zentimetern (als double). Dies ist dein verborgenes Implementierungsdetail. Deine öffentliche Schnittstelle sollte Benutzern Folgendes ermöglichen:
- Die Entfernung mit setMeters(double m), setCentimeters(double cm) oder setKilometers(double km) festzulegen
- Die Entfernung mit getMeters(), getCentimeters() oder getKilometers() abzurufen: Alle Methoden sollten const-Methoden sein
- Zwei Entfernungen mit add(const Distance& other) zu addieren, wobei ein neues Distance-Objekt zurückgegeben wird
Füge einen Standardkonstruktor ein, der die Entfernung auf null initialisiert. Die Umrechnungslogik sollte innerhalb deiner Methoden verborgen sein: Benutzer rufen einfach setKilometers(5) und getMeters() auf, ohne sich um das interne Speicherformat kümmern zu müssen.
main.cpp: Zeige, dass Benutzer mit deiner Klasse arbeiten können, ohne die interne Darstellung zu kennen. Lies zwei Entfernungswerte aus der Eingabe ein: den ersten in Metern, den zweiten in Kilometern. Anschließend:
- Erstelle ein Distance-Objekt und lege es mithilfe des Meterwerts fest
- Gib "In meters: <value> m" aus
- Gib "In centimeters: <value> cm" aus
- Gib "In kilometers: <value> km" aus
- Erstelle ein zweites Distance-Objekt und lege es mithilfe des Kilometerwerts fest
- Addiere die beiden Entfernungen und speichere das Ergebnis
- Gib "Combined in meters: <value> m" aus

Der Vorteil des Verbergens von Informationen besteht darin, dass du die interne Speicherung später von Zentimetern auf Millimeter (oder etwas anderes) umstellen könntest, ohne die Art und Weise zu ändern, wie Benutzer mit deiner Klasse interagieren. Die öffentliche Schnittstelle bleibt stabil, selbst wenn sich die Implementierung ändert.

Formatiere alle Ausgabewerte mit zwei Nachkommastellen, indem du std::fixed und std::setprecision(2) aus <iomanip> verwendest. Wandle Eingabezeichenfolgen mit std::stod() in Gleitkommazahlen um.

Umrechnungsreferenz: 1 Meter = 100 Zentimeter, 1 Kilometer = 1000 Meter.

Probier es selbst

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

using namespace std;

int main() {
    // Eingabewerte lesen
    string metersInput, kmInput;
    cin >> metersInput;  // Erster Wert in Metern
    cin >> kmInput;      // Second value in kilometers
    
    // Strings mit std::stod() in Doubles umwandeln
    double metersValue = stod(metersInput);
    double kmValue = stod(kmInput);
    
    // Ausgabeformatierung festlegen
    cout << fixed << setprecision(2);
    
    // TODO: Erstelle das erste Distance-Objekt und setze es mit dem Meterwert
    
    // TODO: Gib "In meters: <value> m" aus
    
    // TODO: Print "In centimeters: <value> cm"
    
    // TODO: Print "In kilometers: <value> km"
    
    // TODO: Erstelle das zweite Distance-Objekt und setze es mit dem Kilometerwert
    
    // TODO: Addiere die beiden Distanzen mit der add()-Methode
    
    // TODO: Print "Combined in meters: <value> m"
    
    return 0;
}