Campos privados

Parte de la sección Object Oriented Programming del Journey de Rust de Coddy — lección 10 de 61.

En la lección anterior, hiciste que todo fuera público —el struct, sus campos y sus métodos. Pero la verdadera encapsulación significa controlar cómo se puede acceder a tus datos. En Rust, puedes hacer que un struct sea público mientras mantienes sus campos privados.

Considera una Wallet que nunca debería tener un saldo negativo. Si el campo es público, cualquiera podría establecerlo en cualquier valor:

// wallet.rs
pub struct Wallet {
    balance: f64,  // ¡Sin pub = privado!
}

impl Wallet {
    pub fn new(initial: f64) -> Wallet {
        Wallet { balance: initial }
    }
}

Observa que Wallet es pública, pero balance no tiene la palabra clave pub. Esto significa que el código fuera del módulo puede crear una Wallet usando el constructor, pero no puede leer ni modificar directamente el campo balance:

// main.rs
mod wallet;
use wallet::Wallet;

fn main() {
    let w = Wallet::new(100.0);
    // println!("{}", w.balance);  // ¡Error! el campo es privado
    // w.balance = -50.0;          // ¡Error! no se puede acceder al campo privado
}

Este es el fundamento del encapsulamiento: el struct controla sus propios datos. El código externo debe pasar por los métodos que proporciones, lo que significa que puedes añadir validación, registro o cualquier otra lógica. Los datos permanecen protegidos de estados inválidos.

En las próximas lecciones, aprenderás cómo proporcionar acceso controlado a estos datos privados a través de métodos getter y setter.

Desafío

Fácil

Construyamos un sistema de sensor de temperatura que demuestre el encapsulamiento manteniendo los datos sensibles protegidos dentro de un módulo.

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

sensor.rs: Define una estructura TemperatureSensor con dos campos: location (String) y reading (f64). La estructura debe ser pública para que pueda usarse desde otros archivos, pero mantén ambos campos privados; el código externo no debería poder acceder o modificar directamente los datos del sensor. Agrega un constructor público new que reciba un nombre de ubicación y una lectura de temperatura inicial.
main.rs: Incorpora tu módulo de sensor y crea un TemperatureSensor usando el constructor. Dado que los campos son privados, no podrás imprimirlos directamente; en su lugar, imprime un mensaje de confirmación que muestre que el sensor se creó correctamente.

Este desafío se centra en el concepto central de los campos privados: la estructura es accesible, pero sus datos internos están protegidos. El código externo solo puede interactuar con el sensor a través de los métodos que proporciones (en este caso, solo el constructor).

Tu salida debe seguir este formato exacto:

Sensor created for: {location}

Para acceder a la ubicación para imprimirla, necesitarás que tu función new imprima este mensaje antes de devolver el sensor, ya que el campo en sí es privado.

Por ejemplo, si creas un sensor con la ubicación "Kitchen" y la lectura 22.5, la salida sería:

Sensor created for: Kitchen

Recibirás dos entradas: el nombre de la ubicación y la lectura de temperatura inicial.

Pruébalo tú mismo

mod sensor;

use sensor::TemperatureSensor;

fn main() {
    // Leer entrada
    let mut location = String::new();
    std::io::stdin().read_line(&mut location).expect("Failed to read line");
    let location = location.trim().to_string();
    
    let mut reading_str = String::new();
    std::io::stdin().read_line(&mut reading_str).expect("Failed to read line");
    let reading: f64 = reading_str.trim().parse().expect("Failed to parse reading");
    
    // TODO: Crear un TemperatureSensor usando el constructor
    // La función new se encargará de imprimir el mensaje de confirmación
    
}