Getters y Setters

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

Cuando los miembros de una clase son privados, el código externo no puede acceder a ellos directamente. Los getters y setters son métodos públicos que proporcionan un acceso controlado a estos miembros privados: los getters recuperan valores y los setters los modifican.

class Temperature {
    double celsius;    // Privado - no se puede acceder directamente
    
public:
    // Getter - devuelve el valor
    double getCelsius() const {
        return celsius;
    }
    
    // Setter - modifica el valor con validación
    void setCelsius(double value) {
        if (value >= -273.15) {    // Comprobación del cero absoluto
            celsius = value;
        }
    }
};

El verdadero poder de los setters es la validación.

En lugar de permitir que se asigne cualquier valor, puedes imponer reglas. En el ejemplo anterior, se rechazan las temperaturas por debajo del cero absoluto. Sin un setter, cualquiera podría asignar datos no válidos directamente.

Los getters también pueden transformar los datos antes de devolverlos:

class Temperature {
    double celsius;
public:
    double getCelsius() const { return celsius; }
    
    // Getter calculado - no almacena fahrenheit, lo calcula
    double getFahrenheit() const {
        return celsius * 9.0 / 5.0 + 32.0;
    }
    
    void setCelsius(double value) { celsius = value; }
};

Observa la palabra clave const en los getters: esto indica que no modifican el objeto. Los setters no pueden ser const, ya que su propósito es cambiar los valores de los miembros. Este patrón de usar getters y setters es fundamental para la encapsulación, ya que te brinda un control total sobre cómo se accede a los datos de tu clase y cómo se modifican.

Desafío

Fácil

Construyamos un sistema de perfil de jugador que demuestre cómo los getters y setters proporcionan acceso controlado a datos privados, incluida la validación y las propiedades calculadas.

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

Player.h: Define una clase Player que gestione el perfil de un personaje del juego con acceso protegido a los datos. Tu clase debe tener:
- Miembros privados: name (string), level (int) y experience (int)
- Un constructor que reciba un nombre e inicialice level en 1 y experience en 0
- Un getter getName() que devuelva el nombre del jugador
- Un getter getLevel() que devuelva el nivel actual
- Un getter getExperience() que devuelva los puntos de experiencia actuales
- Un setter setName() que solo acepte nombres de al menos 3 caracteres; si no es válido, debe mantener el nombre actual sin cambios
- Un setter addExperience(int points) que solo acepte valores positivos. Cuando la experiencia alcance o supere 100, el jugador subirá de nivel: incrementa el nivel en 1 y resta 100 a la experiencia. Esto puede ocurrir varias veces si se añade suficiente experiencia.
- Un getter calculado getExperienceToNextLevel() que devuelva cuántos puntos de experiencia más se necesitan para alcanzar el siguiente nivel (siempre 100 - current experience)
Marca todos los getters como const, ya que no modifican el objeto.
main.cpp: Demuestra tus getters y setters en acción. Lee un nombre de jugador y puntos de experiencia para añadir desde la entrada (cada uno en una línea separada) y, después:
- Crea un Player con el nombre introducido
- Imprime "Player: <name>, Level: <level>, XP: <experience>"
- Añade los puntos de experiencia introducidos usando addExperience()
- Imprime de nuevo la misma línea de estado para mostrar el estado actualizado
- Imprime "XP to next level: <amount>"
- Intenta cambiar el nombre a "Al" (la validación debe fallar)
- Imprime "Name after invalid change: <name>"
- Cambia el nombre a "Champion" (debe funcionar)
- Imprime "Name after valid change: <name>"

La entrada de experiencia se proporcionará como una cadena que tendrás que convertir en un entero. Incluye el archivo de cabecera en main.cpp usando #include "Player.h".

Pruébalo tú mismo

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

using namespace std;

int main() {
    // Leer el nombre del jugador
    string playerName;
    getline(cin, playerName);

    // Leer los puntos de experiencia a añadir (como string, convertir a int)
    string expString;
    getline(cin, expString);
    int expToAdd = stoi(expString);

    // TODO: Crear un Player con el nombre de entrada

    // TODO: Imprimir el estado inicial: "Player: <name>, Level: <level>, XP: <experience>"

    // TODO: Añadir los puntos de experiencia de entrada usando addExperience()

    // TODO: Imprimir la línea de estado actualizada

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

    // TODO: Intentar cambiar el nombre a "Al" (debería fallar la validación)

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

    // TODO: Cambiar el nombre a "Champion" (debería tener éxito)

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

    return 0;
}