Inicialização na Stack

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

Nem todo objeto precisa ficar no heap. Quando uma struct é pequena e tem uma vida útil curta, alocá-la na pilha é mais simples e rápido: sem malloc, sem free, sem risco de vazamentos de memória.

Em vez de retornar um ponteiro, uma função de fábrica pode retornar a estrutura por valor. A estrutura inteira é copiada para o chamador:

typedef struct {
    int x;
    int y;
} Point;

Point create_point(int x, int y) {
    Point p;
    p.x = x;
    p.y = y;
    return p;
}

O chamador recebe uma cópia totalmente inicializada:

Point origin = create_point(0, 0);
Point cursor = create_point(100, 50);
printf("Cursor: (%d, %d)\n", cursor.x, cursor.y);

Sem ponteiros, nenhuma limpeza é necessária. Quando origin e cursor saem do escopo, eles são destruídos automaticamente.

Essa abordagem funciona melhor para structs pequenos sem membros alocados dinamicamente. Para objetos maiores ou que contenham ponteiros para a memória do heap, o padrão de construtor com malloc continua sendo a melhor escolha.

Desafio

Fácil

Vamos criar um módulo Temperature que cria leituras de temperatura na pilha usando uma função fábrica. Diferentemente dos construtores baseados em heap das lições anteriores, essa abordagem retorna a struct por valor: sem malloc, sem free, apenas uma alocação simples e eficiente na pilha.

Você criará três arquivos:

temperature.h: Declare uma struct Temperature com dois membros: double celsius e char scale (para armazenar 'C' para Celsius). Declare também duas funções:
- create_temperature: recebe um valor double e retorna uma struct Temperature por valor (não um ponteiro!)
- temperature_to_fahrenheit: recebe um const Temperature * e retorna a temperatura equivalente em Fahrenheit como um double
Use guardas de inclusão com o símbolo TEMPERATURE_H.
temperature.c: Implemente ambas as funções. Sua função fábrica deve criar uma variável local Temperature, inicializar seus campos (definir scale como 'C') e retorná-la. A fórmula de conversão é: fahrenheit = celsius * 9.0 / 5.0 + 32.0
main.c: Use sua função fábrica para criar uma leitura de temperatura e exibir os valores em Celsius e Fahrenheit.

Você receberá uma entrada: a temperatura em Celsius (como um double).

Em seu arquivo principal, use create_temperature para criar uma struct Temperature com o valor fornecido. Em seguida, imprima o valor original em Celsius e seu equivalente em Fahrenheit.

Imprima a saída neste formato:

Celsius: {celsius}
Fahrenheit: {fahrenheit}

Use %.2f para ambos os valores, a fim de exibir duas casas decimais.

Por exemplo, com uma entrada de 25.0, a saída seria:

Celsius: 25.00
Fahrenheit: 77.00

Observe como essa abordagem é simples. Você recebe uma struct totalmente inicializada sem preocupações com gerenciamento de memória. Quando sua variável Temperature sai do escopo, ela é limpa automaticamente.

Experimente você mesmo

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

int main() {
    double celsius_input;
    scanf("%lf", &celsius_input);
    
    // TODO: Use create_temperature para criar uma struct Temperature
    
    // TODO: Imprima o valor em Celsius usando o formato %.2f
    
    // TODO: Use temperature_to_fahrenheit para converter e imprimir o valor em Fahrenheit
    
    return 0;
}