Le nombre d'octets nécessaires pour stocker un type de données n'est pas fixé dans la norme du langage C. Le même programme aura donc un comportement différent sur des plateformes différentes. La plupart du temps ces différences n'ont pas d'effet visible, mais il arrive qu'elles soient la source d'erreurs.

Lorsque la taille en octets d'une donnée joue un rôle important, il est utile de pouvoir la calculer dans le code en ayant recours à un opérateur dédié : sizeof.

int main(void) {
  int n;
  double x;
  short t[14];
 
  printf("n : %zu octets.\n", sizeof n);
  printf("x : %zu octets.\n", sizeof x);
  printf("t : %zu octets.\n", sizeof t);
  return EXIT_SUCCESS;
}

Il est possible de connaître la taille d'un type de donnée sans forcément passer par une variable ou même une constante. On emploie alors une conversion «à vide» :

int main(void) {
  printf("long double : %zu octets.\n", sizeof(long double));
  return EXIT_SUCCESS;
}

Remarque Cette notation conduit de nombreuses personnes à croire que sizeof est une fonction. C'est la source de fautes graves car l'utilisation de sizeof est susceptible de rencontrer des problèmes de priorités entre opérateurs qu'une fonction n'aurait pas.

Jusqu'ici, notre seule méthode pour réserver de la mémoire a été de déclarer des variables et des tableaux. La mémoire ainsi rendue disponible fait partie d'une zone nommée pile, qui se situe dans la partie «haute» de la mémoire (les grandes adresses).

Cette technique présente deux caractéristiques parfois gênantes :

• la mémoire n'est disponible que jusqu'à la fermeture du bloc contenant la déclaration,
• la quantité de mémoire réservée doit être connue à la compilation.

Il existe une autre zone mémoire où nous pouvons réserver de la mémoire : le tas. Le mécanisme de l'allocation est différent et permet de s'affranchir des limitations énumérées ci-dessus.

int main(void) {
  int* p = NULL;
  p = (int*) malloc(2*sizeof(int));
  if (p) {
    printf("Entrez un entier : ");
    scanf("%d", p);
    printf("Entrez un second entier : ");
    scanf("%d", p + 1);
    printf("Leur somme vaut %d.\n", p[0] + p[1]);
    free(p);
    return EXIT_SUCCESS;
  } else {
    puts("Espace mémoire insuffisant !");
    return EXIT_FAILURE;
  }
}

Dans la bibliothèque standard (stdlib.h), la fonction malloc (contraction de memory allocation) cherche un espace mémoire de la taille en octets fournie en argument. Si un tel espace n'est pas disponible, elle renvoie NULL. Sinon, elle réserve cet espace et renvoie l'adresse de son premier octet.

La fonction free prend en argument l'adresse du premier octet d'un espace mémoire dynamiquement alloué et libère cet espace (pour qu'il puisse être réutilisé).

Remarque Il est très facile d'oublier de libérer la mémoire lorsqu'elle n'est plus utilisée. Peu à peu, la mémoire disponible diminue : on parle de fuite de mémoire. Veillez à acquérir les bons réflexes pour éviter de contribuer à propager cette maladie trop répandue.

Toujours dans la biliothèque standard (stdlib.h), la fonction calloc (contraction de cell allocation) est une variante de malloc qui prend deux arguments : le nombre de valeurs à stocker et la taille en octets d'une de ces valeurs. De plus (et c'est ce qui mérite qu'on en parle), la mémoire ainsi réservée voit chacun de ses bits mis à zéro.

int main(void) {
  double* p = (double*) calloc(5, sizeof(double));
  if (p) {
    int i;
    for(i = 0; i < 5; i++)
      printf("%.2f ", p[i]);
    putchar('\n');
    free(p);
    return EXIT_SUCCESS;
  } else {
    puts("Espace mémoire insuffisant !");
    return EXIT_FAILURE;
  }
}

Plus utile encore, la fonction realloc permet de «redimensionner» une zone mémoire. Elle alloue en fait une nouvelle zone, déplace les données et désalloue l'ancienne zone. Si la zone d'arrivée est plus petite, les données situées à la fin de la zone d'origine sont perdues. Si la zone d'arrivée est plus grande, les données d'origine sont suivies de données non initialisées. Si elle échoue, realloc ne déplace rien et renvoie NULL.

int main(void) {
  char* p = (char*) malloc(6*sizeof(char));
  if (p) {
    char* q = NULL;
    strcpy(p, "Hello");
    puts(p);
    q = (char*) realloc(p, 11*sizeof(char));
    if (q) {
      strcat(q, " Dave");
      puts(q);
      free(q);
      return EXIT_SUCCESS;
    } else {
      free(p);
      puts("Espace mémoire insuffisant !");
      return EXIT_FAILURE;
    }
  } else {
    puts("Espace mémoire insuffisant !");
    return EXIT_FAILURE;
  }
}