Menu
CoddyTech

Utiliser sizeof() pour l'allocation

Fait partie de la section Logique & Flux du Journey C de Coddy. Leçon 33 sur 63.

Bien que malloc() vous permette d’allouer de la mémoire dynamiquement, une bonne pratique importante rend votre code plus portable et plus facile à maintenir : utiliser l’opérateur sizeof() pour déterminer combien d’octets allouer.

L’opérateur sizeof() renvoie le nombre d’octets nécessaires pour stocker un type de données particulier sur ton système. Au lieu de coder en dur les tailles en octets, tu peux laisser sizeof() calculer automatiquement la quantité correcte :

// Au lieu de deviner les tailles en octets :
int *ptr = (int*)malloc(4);  // Suppose que int occupe 4 octets

// Utilisez sizeof() pour assurer la portabilité :
int *ptr = (int*)malloc(sizeof(int));  // Toujours correct

Cette approche devient particulièrement utile lors de l’allocation de tableaux. Pour allouer de l’espace pour plusieurs éléments, multipliez le nombre d’éléments par la taille de chaque élément :

// Allouer de l'espace pour 10 entiers
int *arr = (int*)malloc(10 * sizeof(int));

// Allouer de l'espace pour 5 nombres de type double
double *values = (double*)malloc(5 * sizeof(double));

Utiliser sizeof() permet à votre code de fonctionner correctement sur différents systèmes, où les types de données peuvent avoir des tailles différentes, et indique clairement votre intention d’allouer de l’espace pour un nombre précis d’éléments d’un type particulier.

challenge icon

Défi

Facile

Écrivez un programme C qui montre comment utiliser correctement sizeof() avec malloc() pour l’allocation dynamique de mémoire. Votre programme doit :

  1. Lire un entier n auprès de l’utilisateur, représentant le nombre d’éléments à allouer
  2. Utiliser malloc() avec sizeof() pour allouer dynamiquement de la mémoire pour un tableau de n valeurs de type double
  3. Convertir le pointeur void renvoyé en pointeur vers double
  4. Lire n valeurs de type double auprès de l’utilisateur et les stocker dans le tableau alloué
  5. Calculer la mémoire totale allouée en octets et l’afficher au format : Memory allocated: [bytes] bytes
  6. Calculer et afficher la moyenne de toutes les valeurs avec exactement 2 décimales au format : Average: [value]
  7. Trouver et afficher la valeur la plus élevée avec exactement 2 décimales au format : Largest: [value]

N’oubliez pas d’inclure l’en-tête <stdlib.h> pour utiliser malloc(). Votre programme doit montrer comment sizeof() garantit une allocation correcte de la mémoire, quelles que soient les tailles des types de données sur le système.

Par exemple, si l’entrée est :

3
2.5 7.8 4.1

Votre sortie doit être :

Memory allocated: 24 bytes
Average: 4.80
Largest: 7.80

Ce défi renforce l’importance d’utiliser sizeof() pour rendre votre allocation dynamique de mémoire portable et facile à maintenir, en calculant automatiquement le nombre exact d’octets nécessaires pour tout type de données sur n’importe quel système.

Essayez vous-même

#include <stdio.h>
#include <stdlib.h>

int main() {
    // Lisez le nombre d’éléments
    int n;
    scanf("%d", &n);
    
    // TODO: Écrivez votre code ci-dessous
    // 1. Allouez de la mémoire pour n valeurs de type double à l’aide de malloc() et sizeof()
    // 2. Convertissez le pointeur renvoyé en double*
    // 3. Lisez n valeurs de type double et stockez-les dans le tableau alloué
    // 4. Calculez et affichez la quantité de mémoire allouée en octets
    // 5. Calculez et affichez la moyenne avec 2 décimales
    // 6. Trouvez et affichez la plus grande valeur avec 2 décimales
    
    return 0;
}
quiz iconTestez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logique & Flux

Entraînez-vous par vous-même : Compilateur C en ligne