HOWTO · C
Initialiser un tableau à 0 en C
Ce tutoriel présente les différentes façons d'initialiser un tableau à 0 en C
Sur cette page
Pour initialiser à zéro chaque élément d’un tableau de int au moment de sa déclaration, écrivez int values[5] = {0};. C initialise le premier élément avec 0, puis initialise également à zéro tous les autres éléments de l’agrégat. Si le tableau existe déjà, affectez une valeur à chaque élément dans une boucle. memset peut remplir les octets d’un tableau avec des zéros, mais ce remplissage ne remplace pas de manière générale une initialisation typée.
Initialiser un tableau à zéro lors de sa déclaration
Utilisez un initialiseur lorsque vous connaissez la taille du tableau au moment de sa déclaration. L’exemple complet suivant affiche les cinq valeurs initialisées.
#include <stdio.h>
int main(void) {
int values[5] = {0};
for (size_t i = 0; i < sizeof values / sizeof values[0]; ++i) {
printf("%d%s", values[i], i == 4 ? "\n" : " ");
}
return 0;
}
0 0 0 0 0
L’initialiseur {0} donne explicitement la valeur zéro au premier élément ; l’initialisation de l’agrégat met à zéro les éléments omis. Vous pouvez aussi ne pas fournir d’initialiseur pour un objet à durée de stockage statique ou liée à un thread : C l’initialise automatiquement à zéro. Un tableau local ordinaire sans initialiseur a une durée de stockage automatique ; ses éléments ne sont donc pas mis à zéro automatiquement. Ajoutez un initialiseur ou affectez les éléments avant de les lire.
Initialiser un tableau à zéro avec une boucle
Une boucle est utile lorsque le tableau est déjà déclaré ou lorsque ses valeurs sont choisies pendant l’exécution. Cet exemple complet utilise le nombre d’éléments du tableau comme limite de boucle et affiche le résultat.
#include <stdio.h>
int main(void) {
int values[5];
size_t count = sizeof values / sizeof values[0];
for (size_t i = 0; i < count; ++i) {
values[i] = 0;
}
for (size_t i = 0; i < count; ++i) {
printf("%d%s", values[i], i + 1 == count ? "\n" : " ");
}
return 0;
}
0 0 0 0 0
L’expression sizeof fonctionne ici parce que values est un tableau dans la même portée, et non un paramètre pointeur. Si vous transmettez un tableau à une fonction, transmettez sa longueur séparément ; dans la fonction, le paramètre est ajusté en pointeur et sizeof renvoie la taille du pointeur.
Utiliser memset() avec précaution
La fonction de la bibliothèque standard memset écrit la même valeur d’octet dans une région mémoire. Incluez <string.h> et utilisez sizeof values pour couvrir tout le tableau dans cette portée, comme dans cet exemple complet.
#include <stdio.h>
#include <string.h>
int main(void) {
int values[5];
memset(values, 0, sizeof values);
for (size_t i = 0; i < sizeof values / sizeof values[0]; ++i) {
printf("%d%s", values[i], i == 4 ? "\n" : " ");
}
return 0;
}
0 0 0 0 0
Le troisième argument indique un nombre d’octets ; sizeof values convient donc à ce tableau. memset n’affecte pas une valeur typée à chaque élément : elle écrit une représentation composée uniquement de bits à zéro. Utilisez-la uniquement si cette représentation convient au type des éléments et à la plateforme. Pour initialiser portablement un tableau à zéro au sens de sa valeur, préférez {0} lors de sa déclaration. Ne supposez pas que des octets nuls représentent un pointeur nul ou un zéro flottant sur toutes les implémentations de C.
Initialiser un tableau avec des valeurs autres que zéro
Énumérez les valeurs souhaitées dans l’initialiseur, par exemple int values[] = {2, 4, 6};. C déduit la dimension externe du nombre de valeurs initiales. Pour un tableau multidimensionnel, seule la dimension externe peut être omise dans cette forme : int grid[][3] = {{1, 2, 3}, {4, 5, 6}}; ; la dimension interne doit être indiquée.
Les désignateurs de plage GNU, comme int values[5] = {[0 ... 4] = 7};, sont une extension de GCC et ne font pas partie de la syntaxe portable du C standard. Pour assurer la portabilité entre compilateurs C, utilisez une liste d’initialisation ordinaire ou une boucle. Un littéral composé comme (int[]){1, 2, 3} crée un tableau sans nom dont la durée de vie est limitée au bloc dans ce contexte de fonction ; il ne s’agit pas d’une allocation dynamique et il ne remplace pas une déclaration de tableau nommé pour l’initialisation générale.