Inizializzazione sullo stack

Fa parte della sezione Programmazione orientata agli oggetti del percorso C di Coddy. Lezione 14 di 61.

Non tutti gli oggetti devono risiedere nell'heap. Quando una struct è piccola e ha una vita breve, allocarla nello stack è più semplice e veloce: niente malloc, niente free, nessun rischio di perdite di memoria.

Invece di restituire un puntatore, una funzione factory può restituire la struct per valore. L’intera struct viene copiata al chiamante:

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

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

Il chiamante riceve una copia completamente inizializzata:

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

Nessun puntatore, nessuna pulizia necessaria. Quando origin e cursor escono dall'ambito, vengono distrutti automaticamente.

Questo approccio funziona meglio per le struct piccole senza membri allocati dinamicamente. Per gli oggetti più grandi o quelli che contengono puntatori alla memoria heap, il modello del costruttore con malloc resta la scelta migliore.

Sfida

Facile

Creiamo un modulo Temperature che genera letture di temperatura nello stack usando una funzione factory. A differenza dei costruttori basati sull'heap delle lezioni precedenti, questo approccio restituisce la struct per valore: niente malloc, niente free, solo un'allocazione semplice ed efficiente nello stack.

Creerai tre file:

temperature.h: dichiara una struct Temperature con due membri: double celsius e char scale (per memorizzare 'C' per Celsius). Dichiara anche due funzioni:
- create_temperature: accetta un valore double e restituisce una struct Temperature per valore (non un puntatore!)
- temperature_to_fahrenheit: accetta un const Temperature * e restituisce la temperatura equivalente in Fahrenheit come double
Usa le guardie di inclusione con il simbolo TEMPERATURE_H.
temperature.c: implementa entrambe le funzioni. La funzione factory deve creare una variabile locale Temperature, inizializzarne i campi (impostare scale a 'C') e restituirla. La formula di conversione è: fahrenheit = celsius * 9.0 / 5.0 + 32.0
main.c: usa la funzione factory per creare una lettura della temperatura e mostrare i valori in Celsius e Fahrenheit.

Riceverai un input: la temperatura in Celsius (come double).

Nel file principale, usa create_temperature per creare una struct Temperature con il valore fornito. Poi stampa il valore originale in Celsius e il suo equivalente in Fahrenheit.

Stampa l'output in questo formato:

Celsius: {celsius}
Fahrenheit: {fahrenheit}

Usa %.2f per entrambi i valori, per visualizzare due cifre decimali.

Ad esempio, con un input di 25.0, l'output sarebbe:

Celsius: 25.00
Fahrenheit: 77.00

Nota quanto è semplice questo approccio. Ottieni una struct completamente inizializzata senza preoccuparti della gestione della memoria. Quando la variabile Temperature esce dall'ambito, viene ripulita automaticamente.

Provalo tu

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

int main() {
    double celsius_input;
    scanf("%lf", &celsius_input);
    
    // TODO: Usa create_temperature para crear una struct Temperature
    
    // TODO: Imprime el valor en grados Celsius con el formato %.2f
    
    // TODO: Usa temperature_to_fahrenheit para convertir e imprimir el valor en grados Fahrenheit
    
    return 0;
}