Les tableaux

Un tableau est une structure de données qui permet de stocker plusieurs valeurs de même type dans une seule variable. Ces valeurs sont accessibles via un indice (un int) qui permet de spécifier quelle valeur on souhaite utiliser.

Voici un exemple de déclaration et d'utilisation d'un tableau en C :

Dans ce programme, on peut voir la déclaration d'un tableau nommé tableau et contenant 4 valeurs de type int : 1, 2, 3 et 4. On peut aussi y voir l'affichage du premier élément du tableau grâce à l'expression tableau[0] qui est de type int et la modification du troisième élément du tableau avec l'instruction tableau[2] = 6;.

Il est important de savoir qu'il n'existe pas de type array en C. Les tableaux sont en réalité des pointeurs vers les premiers éléments des tableaux. Le type de la variable tableau dans l'exemple précédent est en fait int*. C'est un peu déroutant mais c'est un choix de conception qui date des débuts du langage C dans les années 70 et qui permettait de rendre le compilateur plus simple et le code plus performant car les ressources matérielles étaient limitées à l'époque.

Voici quelques autres exemples d'opérations courantes sur les tableaux en C :

• Déclaration d'un tableau de double de taille 10 non initialisé :

  double tableau[10];
  

• Déclaration d'un tableau de char de taille 5 initialisé avec la même valeur 'b' :

  char tableau[5] = {'b'};  // équivalent à {'b', 'b', 'b', 'b', 'b'}
  

• Déclaration simplifiée d'un tableau de int initialisé avec les valeurs 10, 20, 30 et 40 :

  int tab[] = {10, 20, 30, 40};  // la taille est déduite automatiquement (4 dans ce cas)
  

• Récupération de l'adresse mémoire du deuxième élément d'un tableau de float :

  float* adresse = &tab[1];
  

• Itération sur les éléments d'un tableau de float de taille n pour les afficher :

  for (int i = 0; i < n; i++) {
      printf("%f\n", tab[i]);
  }
  

Les tableaux de taille dynamique

Dans les exemples précédents, les tableaux avaient une taille fixe connue à la compilation. Quand cela est possible, c'est la meilleure approche car elle est plus simple et plus performante. Cependant, il est parfois nécessaire de créer des tableaux dont la taille n'est pas connue à la compilation. Quand c'est le cas, il n'est plus possible de déclarer un tableau de la manière classique, il faut alors utiliser les fonctions malloc et free du module stdlib de la bibliothèque standard pour allouer et désallouer des tableaux. La différence principale est que lors de la déclaration classique, la mémoire est allouée sur la stack, ce qui est rapide mais qui nécessite une taille connue à la compilation, tandis qu'avec malloc, la mémoire est allouée sur la heap, ce qui est plus lent mais qui permet d'avoir des tailles dynamiques. Une autre différence est que la mémoire allouée dans la stack est automatiquement libérée à la fin de l'exécution des fonctions, tandis que la mémoire allouée dans la heap doit être libérée manuellement avec free pour éviter les fuites de mémoire.

Comme vous pouvez le voir, l'allocation dynamique d'un tableau est un peu plus compliquée que la déclaration classique. Nous allons donc décomposer cet appel à malloc :

• (float*) est un cast qui permet de convertir un type en un autre. En réalité, la fonction malloc n'alloue pas un tableau, elle alloue un bloc de mémoire d'une certaine taille mais sans type particulier et elle renvoie un pointeur void* vers ce bloc. Il faut donc convertir le pointeur renvoyé par malloc en pointeur vers le type souhaité (float* dans ce cas) pour interpréter le bloc de mémoire correctement.
• sizeof(float) * (unsigned int)entree_utilisateur calcule la taille du bloc de mémoire à allouer. sizeof(float) renvoie la taille en octets d'un seul float et cette taille est ensuite multipliée par le nombre d'éléments souhaités dans le tableau (entree_utilisateur dans ce cas, mais qui est casté en unsigned int car malloc requiert un int non-signé) pour obtenir la taille totale du bloc de mémoire à allouer.

Il y a aussi l'instruction free(tab); qui permet de libérer la mémoire allouée dynamiquement pour le tableau tab. Ce n'est pas fait automatiquement pour les tableaux dynamiques donc pour chaque appel à malloc, il faut faire un appel correspondant à free lorsque le tableau n'est plus nécessaire.

Comportement spéciaux des tableaux avec les fonctions

Étant donné que les tableaux sont en réalité des pointeurs et qu'ils peuvent être stockés dans la stack ou dans la heap, ils ont des comportements un peu particuliers lorsqu'ils sont utilisés avec des fonctions.

Bonnes pratiques