Initialisation sur la pile

Fait partie de la section Programmation Orientée Objet du Journey C de Coddy. Leçon 14 sur 61.

Tous les objets n’ont pas besoin de vivre sur le tas. Lorsqu’une structure est petite et a une durée de vie courte, l’allouer sur la pile est plus simple et plus rapide : pas de malloc, pas de free, aucun risque de fuites mémoire.

Au lieu de renvoyer un pointeur, une fonction factory peut renvoyer la structure par valeur. La structure entière est copiée vers l’appelant :

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

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

L’appelant reçoit une copie entièrement initialisée :

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

Pas de pointeurs, aucun nettoyage requis. Lorsque origin et cursor sortent de leur portée, ils sont automatiquement détruits.

Cette approche fonctionne le mieux pour les petites structures sans membres alloués dynamiquement. Pour les objets plus volumineux ou ceux contenant des pointeurs vers la mémoire du tas, le modèle de constructeur avec malloc reste le meilleur choix.

Défi

Facile

Construisons un module Temperature qui crée des relevés de température sur la pile à l'aide d'une fonction fabrique. Contrairement aux constructeurs basés sur le tas des leçons précédentes, cette approche renvoie la structure par valeur : pas de malloc, pas de free, simplement une allocation sur la pile efficace.

Vous allez créer trois fichiers :

temperature.h : déclarer une structure Temperature avec deux membres : double celsius et char scale (pour stocker 'C' pour Celsius). Déclarer également deux fonctions :
- create_temperature : prend une valeur double et renvoie une structure Temperature par valeur (et non un pointeur !)
- temperature_to_fahrenheit : prend un const Temperature * et renvoie la température équivalente en Fahrenheit sous forme de double
Utiliser des gardes d'inclusion avec le symbole TEMPERATURE_H.
temperature.c : implémenter les deux fonctions. Votre fonction fabrique doit créer une variable locale Temperature, initialiser ses champs (définir scale sur 'C') et la renvoyer. La formule de conversion est : fahrenheit = celsius * 9.0 / 5.0 + 32.0
main.c : utiliser votre fonction fabrique pour créer un relevé de température et afficher les valeurs en Celsius et en Fahrenheit.

Vous recevrez une entrée : la température en Celsius (sous forme de double).

Dans votre fichier principal, utilisez create_temperature pour créer une structure Temperature avec la valeur donnée. Affichez ensuite la valeur Celsius d'origine et son équivalent en Fahrenheit.

Affichez la sortie dans ce format :

Celsius: {celsius}
Fahrenheit: {fahrenheit}

Utilisez %.2f pour les deux valeurs afin d'afficher deux décimales.

Par exemple, avec une entrée de 25.0, la sortie serait :

Celsius: 25.00
Fahrenheit: 77.00

Remarquez à quel point cette approche est simple. Vous obtenez une structure entièrement initialisée sans avoir à vous soucier de la gestion de la mémoire. Lorsque votre variable Temperature sort de sa portée, elle est automatiquement nettoyée.

Essayez vous-même

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

int main() {
    double celsius_input;
    scanf("%lf", &celsius_input);
    
    // TODO: Utilisez create_temperature pour créer une structure Temperature
    
    // TODO: Affichez la valeur en Celsius en utilisant le format %.2f
    
    // TODO: Utilisez temperature_to_fahrenheit pour convertir et afficher la valeur en Fahrenheit
    
    return 0;
}