Menu
Coddy logo textTech

Utiliser sizeof() pour l'allocation

Fait partie de la section Logic & Flow du Journey C de Coddy — leçon 33 sur 63.

Alors que malloc() vous permet d'allouer de la mémoire de manière dynamique, il existe une pratique exemplaire importante qui rend votre code plus portable et maintenable : utiliser l'opérateur sizeof() pour déterminer le nombre d'octets à allouer.

L'opérateur sizeof() retourne le nombre d'octets requis pour stocker un type de données particulier sur votre système. Au lieu de coder en dur les tailles en octets, vous pouvez laisser sizeof() calculer automatiquement la quantité correcte :

// Au lieu de deviner la taille des octets :
int *ptr = (int*)malloc(4);  // Suppose que int fait 4 octets

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

Cette approche devient particulièrement précieuse 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 doubles
double *values = (double*)malloc(5 * sizeof(double));

L'utilisation de 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 cela communique clairement votre intention d'allouer de l'espace pour un nombre spécifique d'éléments d'un type particulier.

challenge icon

Défi

Facile

Écrivez un programme en C qui démontre l'utilisation correcte de sizeof() avec malloc() pour l'allocation dynamique de mémoire. Votre programme doit :

  1. Lire un entier n 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. Transtyper (cast) le pointeur void retourné en un pointeur double
  4. Lire n valeurs de type double 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 plus grande valeur 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 démontrer comment sizeof() garantit une allocation de mémoire correcte, quels que soient les tailles des types de données du système.

Par exemple, si l'entrée est :

3
2.5 7.8 4.1

Votre sortie devrait être :

Memory allocated: 24 bytes
Average: 4.80
Largest: 7.80

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

Essayez vous-même

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

int main() {
    // Lire le nombre d'éléments
    int n;
    scanf("%d", &n);
    
    // TODO: Écrivez votre code ci-dessous
    // 1. Allouer de la mémoire pour n valeurs de type double en utilisant malloc() et sizeof()
    // 2. Convertir le pointeur retourné en double*
    // 3. Lire n valeurs de type double et les stocker dans le tableau alloué
    // 4. Calculer et afficher la mémoire allouée en octets
    // 5. Calculer et afficher la moyenne avec 2 décimales
    // 6. Trouver et afficher 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 Logic & Flow