Ocultamiento de información

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 36 de 104.

El ocultamiento de información va más allá de simplemente usar especificadores de acceso. Es un principio de diseño en el que ocultas no solo los datos, sino también los detalles de implementación sobre cómo funciona tu clase internamente.

El objetivo es exponer únicamente lo que los usuarios de tu clase necesitan saber, mientras mantienes todo lo demás oculto. Esto te permite cambiar la implementación interna sin afectar al código que utiliza tu clase:

class Temperature {
    double kelvin;    // Representación interna - detalle oculto
    
public:
    void setCelsius(double c) {
        kelvin = c + 273.15;    // Conversión oculta para el usuario
    }
    
    double getCelsius() const {
        return kelvin - 273.15;
    }
    
    double getFahrenheit() const {
        return (kelvin - 273.15) * 9.0/5.0 + 32;
    }
};

Los usuarios de esta clase no saben (ni necesitan saber) que la temperatura se almacena internamente en Kelvin. Si más adelante decides almacenarla en Celsius en su lugar, solo cambias la implementación privada; la interfaz pública permanece sin cambios.

Esta separación entre la interfaz y la implementación ofrece varios beneficios: reduce la complejidad para los usuarios de tu clase, evita el uso accidental indebido de los datos internos y facilita el mantenimiento de tu código. Cuando los detalles internos están ocultos, puedes optimizar o refactorizar libremente sin romper el código existente que depende de tu clase.

Desafío

Fácil

Construyamos una clase Distance que demuestre la ocultación de información almacenando internamente las distancias en centímetros, mientras proporciona una interfaz clara para trabajar con diferentes unidades. Los usuarios de tu clase no necesitarán saber (ni preocuparse por) cómo se almacena internamente la distancia: simplemente trabajarán con la unidad que les resulte conveniente.

Crearás dos archivos para organizar tu código:

Distance.h: Define una clase Distance que oculte su representación interna y, al mismo tiempo, exponga una interfaz pública flexible. Internamente, almacena la distancia en centímetros (como un double). Este es tu detalle de implementación oculto. Tu interfaz pública debe permitir a los usuarios:
- Establecer la distancia usando setMeters(double m), setCentimeters(double cm) o setKilometers(double km)
- Obtener la distancia usando getMeters(), getCentimeters() o getKilometers(): todos deben ser métodos const
- Sumar dos distancias con add(const Distance& other), que devuelve un nuevo objeto Distance
Incluye un constructor predeterminado que inicialice la distancia en cero. La lógica de conversión debe estar oculta dentro de tus métodos: los usuarios solo llaman a setKilometers(5) y getMeters() sin preocuparse por el formato de almacenamiento interno.
main.cpp: Demuestra que los usuarios pueden trabajar con tu clase sin conocer la representación interna. Lee dos valores de distancia de la entrada: el primero en metros y el segundo en kilómetros. Después:
- Crea un objeto Distance y establécelo usando el valor en metros
- Imprime "In meters: <value> m"
- Imprime "In centimeters: <value> cm"
- Imprime "In kilometers: <value> km"
- Crea un segundo objeto Distance y establécelo usando el valor en kilómetros
- Suma las dos distancias y almacena el resultado
- Imprime "Combined in meters: <value> m"

La ventaja de la ocultación de información es que más adelante podrías cambiar el almacenamiento interno de centímetros a milímetros (o a cualquier otra unidad) sin cambiar la forma en que los usuarios interactúan con tu clase. La interfaz pública permanece estable incluso si cambia la implementación.

Formatea todos los valores de salida con dos decimales usando std::fixed y std::setprecision(2) de <iomanip>. Convierte las cadenas de entrada a valores double usando std::stod().

Referencia de conversión: 1 metro = 100 centímetros, 1 kilómetro = 1000 metros.

Pruébalo tú mismo

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

using namespace std;

int main() {
    // Leer valores de entrada
    string metersInput, kmInput;
    cin >> metersInput;  // Primer valor en metros
    cin >> kmInput;      // Second value in kilometers
    
    // Convertir cadenas a doubles usando std::stod()
    double metersValue = stod(metersInput);
    double kmValue = stod(kmInput);
    
    // Establecer el formato de salida
    cout << fixed << setprecision(2);
    
    // TODO: Crear el primer objeto Distance y configurarlo usando el valor en metros
    
    // TODO: Imprimir "In meters: <value> m"
    
    // TODO: Print "In centimeters: <value> cm"
    
    // TODO: Print "In kilometers: <value> km"
    
    // TODO: Crear el segundo objeto Distance y configurarlo usando el valor en kilómetros
    
    // TODO: Sumar las dos distancias usando el método add()
    
    // TODO: Print "Combined in meters: <value> m"
    
    return 0;
}