Métodos Auxiliares

Parte da seção Object Oriented Programming do Journey de C da Coddy — lição 10 de 61.

Até agora, vimos funções que modificam dados de struct (como player_take_damage) e funções que simplesmente os exibem. Mas há outra categoria importante: funções que computam valores derivados a partir de membros da struct sem alterar nada.

Considere uma struct Rectangle que armazena largura e altura. A área não é armazenada — ela é calculada sob demanda:

typedef struct {
    double width;
    double height;
} Rectangle;

double rectangle_area(const Rectangle *self) {
    return self->width * self->height;
}

double rectangle_perimeter(const Rectangle *self) {
    return 2 * (self->width + self->height);
}

Estes são métodos auxiliares—eles pegam os dados existentes da struct e produzem um novo valor. Observe que eles usam ponteiros const, já que eles apenas leem, nunca escrevem. O resultado computado é retornado em vez de ser armazenado na struct.

Rectangle box = {5.0, 3.0};
printf("Area: %.1f\n", rectangle_area(&box));       // 15.0
printf("Perimeter: %.1f\n", rectangle_perimeter(&box)); // 16.0

Este padrão mantém suas structs enxutas—armazene apenas os dados essenciais e calcule todo o resto quando necessário. Ele também garante que os valores derivados estejam sempre consistentes com o estado atual.

Desafio

Fácil

Vamos construir um módulo Circle que calcula valores derivados de dados armazenados. Você praticará a escrita de métodos auxiliares — funções que computam resultados a partir de membros de uma struct sem modificá-los.

Você criará três arquivos:

circle.h: Declare uma struct Circle com um único membro double radius. Também declare dois métodos auxiliares:
- circle_area — recebe um ponteiro const para Circle e retorna a área
- circle_circumference — recebe um ponteiro const para Circle e retorna a circunferência
Use include guards com o símbolo CIRCLE_H.
circle.c: Implemente ambos os métodos auxiliares. Para os cálculos, use 3.14159 como o valor de pi. A fórmula da área é pi * radius * radius, e a fórmula da circunferência é 2 * pi * radius. Ambas as funções devem apenas ler o raio — nunca modificá-lo.
main.c: Crie um Circle e use os métodos auxiliares para computar e exibir suas propriedades.

Você receberá uma entrada: o radius do círculo (como um double).

No seu arquivo principal, inicialize um Circle com o raio fornecido, então use seus métodos auxiliares para calcular e imprimir a área e a circunferência.

Imprima os resultados neste formato:

Area: {area}
Circumference: {circumference}

Use %.2f para ambos os valores para exibir duas casas decimais.

Por exemplo, com um raio de 5.0, a saída seria:

Area: 78.54
Circumference: 31.42

Folha de consulta

As funções podem calcular valores derivados de membros de uma struct sem modificar a struct. Estes são chamados de métodos auxiliares (helper methods).

Os métodos auxiliares usam ponteiros const, pois eles apenas leem dados, nunca escrevem:

typedef struct {
    double width;
    double height;
} Rectangle;

double rectangle_area(const Rectangle *self) {
    return self->width * self->height;
}

double rectangle_perimeter(const Rectangle *self) {
    return 2 * (self->width + self->height);
}

Usando métodos auxiliares:

Rectangle box = {5.0, 3.0};
printf("Area: %.1f\n", rectangle_area(&box));       // 15.0
printf("Perimeter: %.1f\n", rectangle_perimeter(&box)); // 16.0

Este padrão mantém as structs enxutas, armazenando apenas dados essenciais e calculando valores derivados sob demanda, garantindo a consistência com o estado atual.

Experimente você mesmo

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

int main() {
    double radius;
    scanf("%lf", &radius);
    
    // TODO: Crie uma struct Circle com o radius fornecido
    
    // TODO: Use os métodos auxiliares circle_area e circle_circumference
    // para calcular e imprimir os resultados
    
    // Formato de impressão:
    // printf("Area: %.2f\n", ...);
    // printf("Circumference: %.2f\n", ...);
    
    return 0;
}