Validação em Setters

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

Na lição anterior, criamos setters básicos que simplesmente atribuem valores. Mas isso deixa de lado um benefício importante do encapsulamento: a capacidade de proteger seus dados adicionando lógica de validação.

Considere um Counter que nunca deve ficar negativo. Sem encapsulamento, qualquer pessoa poderia escrever c->value = -50 e corromper o estado. Com um setter, você controla quais valores são permitidos:

// counter.c
void counter_set_value(Counter *c, int new_value) {
    if (new_value < 0) {
        return;  // Rejeita entrada inválida silenciosamente
    }
    c->value = new_value;
}

Agora os valores negativos são simplesmente ignorados.

Você também pode optar por retornar um código de status para indicar sucesso ou falha:

int counter_set_value(Counter *c, int new_value) {
    if (new_value < 0) {
        return 0;  // Falha
    }
    c->value = new_value;
    return 1;  // Sucesso
}

Este padrão permite que o chamador saiba se a operação foi bem-sucedida. O ponto principal é que setters não tratam apenas de atribuição: eles são guardiões que impõem regras sobre como pode ser o estado do seu objeto. Este é o verdadeiro poder do encapsulamento: seu objeto mantém sua própria integridade, independentemente do que um código externo tente fazer.

Desafio

Fácil

Vamos criar um módulo Temperature que protege seus dados usando validação no setter. Você criará um rastreador de temperatura que aceita apenas valores dentro de um intervalo válido, demonstrando como os setters atuam como guardiões do estado do seu objeto.

Você criará três arquivos:

temperature.h: sua interface pública usando o padrão de ponteiro opaco. Declare um tipo Temperature apenas com uma declaração antecipada. Declare estas funções:
- create_temperature: recebe um inteiro referente aos graus iniciais e retorna um ponteiro para Temperature
- free_temperature: libera a memória alocada
- temp_get_degrees: getter que retorna o valor atual da temperatura
- temp_set_degrees: setter que retorna um int (1 para sucesso, 0 para falha)
Use guardas de inclusão com o símbolo TEMPERATURE_H.
temperature.c: defina a struct Temperature real com um membro int degrees oculto. Implemente todas as funções. O ponto principal é o setter. Ele deve aceitar apenas valores entre -50 e 150 (inclusive). Se o valor estiver fora desse intervalo, retorne 0 e mantenha a temperatura inalterada. Se for válido, atualize o valor e retorne 1.
main.c: demonstre a validação tentando definir temperaturas válidas e inválidas, mostrando que os valores inválidos são rejeitados enquanto os válidos são aceitos.

Você receberá três entradas: a temperatura inicial, uma temperatura válida a ser definida (dentro do intervalo) e uma temperatura inválida a ser tentada (fora do intervalo).

Em seu arquivo principal, crie um Temperature com o valor inicial e imprima-o. Em seguida, tente definir a temperatura inválida, já que ela deve ser rejeitada, imprima o resultado e mostre que o valor permanece inalterado. Por fim, defina a temperatura válida, imprima o resultado do sucesso e mostre o valor atualizado. Libere a memória e confirme a limpeza.

Imprima a saída neste formato:

Initial: {degrees}
Set {invalid}: {0 or 1}
After invalid: {degrees}
Set {valid}: {0 or 1}
After valid: {degrees}
Freed

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

Initial: 25
Set 200: 0
After invalid: 25
Set 100: 1
After valid: 100
Freed

Isso demonstra o verdadeiro poder do encapsulamento. Seu setter impõe as regras sobre o que constitui uma temperatura válida, protegendo a integridade do objeto independentemente dos valores que o código externo tentar atribuir.

Experimente você mesmo

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

int main() {
    // Ler entradas
    int initial, valid_temp, invalid_temp;
    scanf("%d", &initial);
    scanf("%d", &valid_temp);
    scanf("%d", &invalid_temp);
    
    // TODO: Crie um Temperature com o valor inicial
    
    // TODO: Imprima a temperatura inicial
    // Formato: "Initial: {degrees}"
    
    // TODO: Tente definir a temperatura inválida
    // Imprima o resultado e mostre que o valor permanece inalterado
    // Formato: "Set {invalid}: {0 or 1}"
    // Format: "After invalid: {degrees}"
    
    // TODO: Defina a temperatura válida
    // Imprima o resultado de sucesso e mostre o valor atualizado
    // Formato: "Set {valid}: {0 or 1}"
    // Formato: "After valid: {degrees}"
    
    // TODO: Libere a memória e imprima "Freed"
    
    return 0;
}