Getters e Setters

Parte da seção Programação Orientada a Objetos do Journey de C da Coddy. Lição 19 de 61.

Com ponteiros opacos, os membros da struct ficam ocultos do código externo. Mas, se o código externo não pode acessar os dados diretamente, como podemos lê-los ou modificá-los? A resposta são as funções getter e setter: interfaces públicas que fornecem acesso controlado aos dados privados.

Um getter retorna o valor de um membro oculto:

// counter.h
int counter_get_value(const Counter *c);

// counter.c
int counter_get_value(const Counter *c) {
    return c->value;
}

Um setter modifica um membro oculto:

// counter.h
void counter_set_value(Counter *c, int new_value);

// counter.c
void counter_set_value(Counter *c, int new_value) {
    c->value = new_value;
}

Observe a convenção de nomenclatura: prefixe as funções com o nome do tipo (counter_) para evitar conflitos e tornar a API clara. Os getters usam ponteiros const, pois não modificam o objeto.

Agora, o código externo pode interagir com os dados ocultos com segurança:

// main.c
Counter *c = create_counter(10);
printf("%d\n", counter_get_value(c));  // 10
counter_set_value(c, 25);
printf("%d\n", counter_get_value(c));  // 25

Este pattern dá a você controle total sobre como os dados são acessados: uma base sobre a qual construiremos na próxima lição, quando adicionarmos lógica de validação aos setters.

Desafio

Fácil

Vamos criar um módulo Score que usa o padrão de ponteiro opaco com funções getter e setter. Você criará um rastreador de pontuação oculto, no qual o código externo só poderá interagir com os dados por meio da interface pública que você fornecer.

Você criará três arquivos:

score.h: Sua interface pública. Declare um tipo Score opaco usando uma declaração antecipada (sem corpo da struct!). Declare estas funções:
- create_score: recebe um inteiro com os pontos iniciais e retorna um ponteiro para Score
- free_score: recebe um ponteiro para Score e libera a memória
- score_get_points: um getter que recebe um const Score * e retorna os pontos atuais
- score_set_points: um setter que recebe um Score * e um inteiro, atualizando o valor dos pontos
Use proteções de inclusão com o símbolo SCORE_H.
score.c: Defina a struct Score real com um único membro oculto: int points. Implemente as quatro funções. Seu getter deve retornar o valor oculto, e seu setter deve atualizá-lo. Lembre-se de que getters usam ponteiros const, pois não modificam o objeto.
main.c: Demonstre seu módulo criando uma pontuação, lendo seu valor, modificando-o por meio do setter e lendo-o novamente.

Você receberá duas entradas: os pontos iniciais (um inteiro) e o novo valor dos pontos (um inteiro) a ser definido.

Em seu arquivo principal, crie um Score com os pontos iniciais, imprima o valor atual usando o getter, atualize-o usando o setter com o novo valor, imprima o valor atualizado, depois libere a pontuação e imprima uma confirmação.

Imprima a saída neste formato:

Initial: {points}
Updated: {points}
Freed

Por exemplo, com as entradas 100 e 250, a saída seria:

Initial: 100
Updated: 250
Freed

Observe como main.c não pode acessar points diretamente. Ele deve passar pelas funções getter e setter. Isso é encapsulamento em ação: você controla exatamente como os dados ocultos podem ser lidos e modificados.

Experimente você mesmo

#include <stdio.h>
#include "score.h"

int main() {
    int initial_points, new_points;
    scanf("%d", &initial_points);
    scanf("%d", &new_points);
    
    // TODO: Crie um Score com initial_points
    
    // TODO: Imprima o valor inicial usando o getter
    // Formato: "Initial: {points}"
    
    // TODO: Atualize o score usando o setter com new_points
    
    // TODO: Imprima o valor atualizado usando o getter
    // Formato: "Updated: {points}"
    
    // TODO: Libere o score e imprima "Freed"
    
    return 0;
}