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 de uma 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 - getters recuperam valores, 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 de zero absoluto
            celsius = value;
        }
    }
};

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

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

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

class Temperature {
    double celsius;
public:
    double getCelsius() const { return celsius; }
    
    // Computed getter - doesn't store fahrenheit, calculates it
    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, já que seu propósito é alterar os valores dos membros. Este padrão de uso de getters e setters é fundamental para o encapsulamento, oferecendo controle total sobre como os dados da sua classe são acessados e modificados.

Desafio

Fácil

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

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

Player.h: Defina uma classe Player que gerencia o perfil de um personagem de jogo com acesso a dados protegidos. Sua classe deve ter:
- Membros privados: name (string), level (int), e experience (int)
- Um construtor que recebe um nome e inicializa level como 1 e experience como 0
- Um getter getName() que retorna o nome do jogador
- Um getter getLevel() que retorna o nível atual
- Um getter getExperience() que retorna os pontos de experiência atuais
- Um setter setName() que aceita apenas nomes com pelo menos 3 caracteres — se for inválido, mantenha o nome atual inalterado
- Um setter addExperience(int points) que aceita apenas valores positivos. Quando a experiência atinge ou excede 100, o jogador sobe 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 computado getExperienceToNextLevel() que retorna quantos pontos de experiência a mais são necessários para atingir 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 da entrada (cada um em uma linha separada), então:
- Crie um Player com o nome de entrada
- Imprima "Player: <name>, Level: <level>, XP: <experience>"
- Adicione os pontos de experiência de entrada 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" (deve falhar na validação)
- Imprima "Name after invalid change: <name>"
- Altere o nome para "Champion" (deve ter sucesso)
- 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 no main.cpp usando #include "Player.h".

Folha de consulta

Getters e setters são métodos públicos que fornecem acesso controlado a membros privados de uma classe.

Padrão básico de getter e setter:

class Temperature {
    double celsius;    // Membro privado
    
public:
    // Getter - retorna o valor (marcado como const)
    double getCelsius() const {
        return celsius;
    }
    
    // Setter - modifica o valor
    void setCelsius(double value) {
        celsius = value;
    }
};

Setters com validação:

void setCelsius(double value) {
    if (value >= -273.15) {    // Valida antes de definir
        celsius = value;
    }
}

Getters computados:

// Retorna o valor calculado sem armazená-lo
double getFahrenheit() const {
    return celsius * 9.0 / 5.0 + 32.0;
}

Pontos-chave:

Getters devem ser marcados como const, pois não modificam o objeto
Setters não podem ser const, pois alteram os valores dos membros
Setters permitem a validação para evitar dados inválidos
Getters podem transformar ou computar valores antes de retorná-los

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: Imprimir "XP to next level: <amount>"

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

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

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

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

    return 0;
}