Getters e Setters

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 28 de 104.

Quando os membros da classe são privados, o código externo não pode acessá-los diretamente. Getters e setters são métodos públicos que fornecem acesso controlado a esses membros privados — os getters recuperam valores, enquanto os setters os modificam.

class Temperature {
    double celsius;    // Privado - não pode ser acessado diretamente
    
public:
    // Getter - retorna o valor
    double getCelsius() const {
        return celsius;
    }
    
    // Setter - modifica o valor com validação
    void setCelsius(double value) {
        if (value >= -273.15) {    // Verificação do zero absoluto
            celsius = value;
        }
    }
};

O verdadeiro poder dos setters é a validação.

Em vez de permitir que qualquer valor seja atribuído, você pode impor regras. No exemplo acima, temperaturas abaixo do zero absoluto são rejeitadas. Sem um setter, qualquer pessoa poderia atribuir dados inválidos diretamente.

Os getters também podem transformar dados antes de retorná-los:

class Temperature {
    double celsius;
public:
    double getCelsius() const { return celsius; }
    
    // Getter computado - não armazena fahrenheit, calcula-o
    double getFahrenheit() const {
        return celsius * 9.0 / 5.0 + 32.0;
    }
    
    void setCelsius(double value) { celsius = value; }
};

Observe a palavra-chave const nos getters — isso indica que eles não modificam o objeto. Setters não podem ser const, pois seu propósito é alterar os valores dos membros. Esse padrão de usar getters e setters é fundamental para o encapsulamento, dando a você controle total sobre como os dados da sua classe são acessados e modificados.

Desafio

Fácil

Vamos criar um sistema de perfil de jogador que demonstre como getters e setters fornecem acesso controlado a dados privados, incluindo validação e propriedades calculadas.

Você criará dois arquivos para organizar seu código:

Player.h: Defina uma classe Player que gerencie o perfil de um personagem de jogo com acesso protegido aos dados. Sua classe deve ter:
- Membros privados: name (string), level (int) e experience (int)
- Um construtor que receba um nome e inicialize level como 1 e experience como 0
- Um getter getName() que retorne o nome do jogador
- Um getter getLevel() que retorne o nível atual
- Um getter getExperience() que retorne os pontos de experiência atuais
- Um setter setName() que aceite apenas nomes com pelo menos 3 caracteres; se o nome for inválido, mantenha o nome atual inalterado
- Um setter addExperience(int points) que aceite apenas valores positivos. Quando a experiência atingir ou ultrapassar 100, o jogador subirá de nível: incremente o nível em 1 e subtraia 100 da experiência. Isso pode acontecer várias vezes se experiência suficiente for adicionada.
- Um getter calculado getExperienceToNextLevel() que retorne quantos pontos de experiência ainda são necessários para alcançar o próximo nível (sempre 100 - current experience)
Marque todos os getters como const, pois eles não modificam o objeto.
main.cpp: Demonstre seus getters e setters em ação. Leia um nome de jogador e pontos de experiência para adicionar a partir da entrada (cada um em uma linha separada) e, em seguida:
- Crie um Player com o nome informado
- Imprima "Player: <name>, Level: <level>, XP: <experience>"
- Adicione os pontos de experiência informados usando addExperience()
- Imprima a mesma linha de status novamente para mostrar o estado atualizado
- Imprima "XP to next level: <amount>"
- Tente alterar o nome para "Al" (a validação deve falhar)
- Imprima "Name after invalid change: <name>"
- Altere o nome para "Champion" (a alteração deve ser bem-sucedida)
- Imprima "Name after valid change: <name>"

A entrada de experiência será fornecida como uma string que você precisará converter para um inteiro. Inclua seu arquivo de cabeçalho em main.cpp usando #include "Player.h".

Experimente você mesmo

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

using namespace std;

int main() {
    // Ler o nome do jogador
    string playerName;
    getline(cin, playerName);

    // Ler os pontos de experiência a adicionar (como string, converter para int)
    string expString;
    getline(cin, expString);
    int expToAdd = stoi(expString);

    // TODO: Criar um Player com o nome de entrada

    // TODO: Imprimir o status inicial: "Player: <name>, Level: <level>, XP: <experience>"

    // TODO: Adicionar os pontos de experiência de entrada usando addExperience()

    // TODO: Imprimir a linha de status atualizada

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

    // TODO: Tentar alterar o nome para "Al" (deve falhar na validação)

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

    // TODO: Alterar o nome para "Champion" (deve ter sucesso)

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

    return 0;
}