En C, les tableaux per­met­tent de stocker un ensemble de données associées sans avoir à créer plusieurs variables. En règle générale, les tableaux sont uni­di­men­sion­nels, mais ils peuvent être étendus à autant de di­men­sions que vous le souhaitez. Nous vous montrons comment créer et utiliser ef­fi­ca­ce­ment des tableaux 2D en C.

Notions de base sur les tableaux en C

Pour pouvoir créer et maîtriser les tableaux (arrays) 2D en C, il faut d’abord avoir quelques bases sur les tableaux dans le langage de pro­gram­ma­tion C. Comme dans de nombreux autres langages, les tableaux sont des blocs de mémoire dans lesquels plusieurs valeurs du même type de données peuvent être stockées. Il est ainsi possible de stocker plusieurs valeurs sous un nom de variable et de les regrouper. La taille du tableau doit être connue au moment de la com­pi­la­tion et ne peut pas être modifiée ul­té­rieu­re­ment. Le bloc de code suivant montre comment créer des tableaux en C :

int nombres1[15];
// Les valeurs stockées peuvent être spécifiées lors de la création :
int nombres2[5] = {1, 2, 3, 4, 5};
c

Dans cet exemple, le type de données à en­re­gis­trer est indiqué comme d’habitude avant le nom de la variable. Les crochets indiquent que cette variable n’est pas une valeur unique, mais un tableau. L’entier entre les crochets indique combien d’éléments de ce type de données peuvent être stockés dans le tableau. Dans l’exemple ci-dessus, le tableau nombres1 est créé non ini­tia­lisé, ce qui signifie qu’aucune valeur n’est écrite dans les champs. Ceux-ci peuvent alors être remplis plus tard avec des valeurs dans le code.

Le tableau nombres2 est quant à lui ini­tia­lisé ma­nuel­le­ment dès sa création. Cette approche n’est pas re­com­man­dée dans la plupart des cas, car elle est très coûteuse pour les grands tableaux et le code qui en résulte est souvent peu lisible. Essayez donc plutôt de remplir vos tableaux de manière pro­gram­ma­tique par exemple avec une boucle For :

int nombres3[100];
for(int i = 0; i < 100; i++) {
nombres3[i] = i + 1;
}
// Crée un tableau contenant les entiers de 1 à 100
c
Note

Selon le système d’ex­ploi­ta­tion sur lequel vous tra­vail­lez, le standard C que vous utilisez et l’endroit où vous avez déclaré une variable non ini­tia­li­sée dans votre programme, cette variable peut contenir une valeur aléatoire. Cela s’applique également pour les champs de tableau. Il est donc pré­fé­rable de ne pas accéder à des champs que vous n’avez pas encore ini­tia­li­sés, surtout si la valeur qui y est stockée doit être in­ter­pré­tée comme un pointeur.

Une fois qu’un tableau a été créé, l’index permet d’accéder à des valeurs in­di­vi­duelles. Notez que les tableaux com­men­cent par l’index 0. Voici un exemple :

int nombres2[5] = {1, 2, 3, 4, 5};
nombres2[3] = nombres2[2];
printf("%d\n", nombres2[3]);
// Sortie : 3
c

Un array 2D en C peut être réalisé en créant un tableau dans lequel chaque champ contient un autre tableau. Découvrez-en plus dans la suite de l’article !

Array 2D en C : comment faire ?

Les tableaux 2D en C ne sont rien d’autre que des tableaux uni­di­men­sion­nels dont les champs con­tien­nent chacun un autre tableau. Un tableau 2D peut donc être considéré comme un tableau ou une matrice de valeurs. Les tableaux 2D peuvent être créés et remplis avec la syntaxe suivante :

ints_two_dimensions[10][10];
ints_two_dimensions [0][1] = 0;
ints_two_dimensions [2][1] = 2;
ints_two_dimensions [9][4] = 36;
// etc.
c

Ici, le nombre entre crochets de gauche re­pré­sente l’index dans le premier tableau auquel on veut accéder, et celui de droite l’index dans le second. On peut se re­pré­sen­ter ces deux nombres comme des coor­don­nées 2D ou des numéros de ligne ou de colonne. Comme les tableaux à une dimension, les tableaux à deux di­men­sions peuvent être ini­tia­li­sés avec des valeurs dès leur création.

floats_two_dimensions[2][6] = {
{0.1, 3.56, 6.346, 8.9, 45.345, 2.284},
{7.0, 1.12, 9.74, 0.0, 3.56, 4.4}
};
c

Le principe d’un tableau à l’intérieur d’un autre tableau n’est pas limité à deux di­men­sions. Avec cette méthode, vous pouvez créer des tableaux avec le nombre de di­men­sions de votre choix.

int ints_four_dimensions[10][10][10][10];
c
Hé­ber­ge­ment Web
Hé­ber­ge­ment Web de pointe au meilleur prix
  • 3x plus rapide, 60 % d'éco­no­mie
  • Haute dis­po­ni­bi­lité >99,99 %
  • Seulement chez IONOS : jusqu'à 500 Go inclus

Exemples d’uti­li­sa­tion d’arrays 2D en C

Itérer sur un tableau 2D

Le cas d’uti­li­sa­tion le plus courant des tableaux 2D en C (ou des tableaux mul­ti­di­men­sion­nels) est la création de struc­tures de données mul­ti­di­men­sion­nelles. Dans l’exemple suivant, un tableau à deux di­men­sions est rempli al­ter­na­ti­ve­ment de 0 et de 1 pour re­pré­sen­ter un échiquier :

#include <stdio.h>
#define ARRAY_LENGTH 8
int main() {
    int échiquier[8][8];
    for(int i = 0; i < ARRAY_LENGTH; i++) {
        for(int j = 0; j < ARRAY_LENGTH; j++) {
            échiquier[i][j] = (i + j) % 2;
            printf("%d", échiquier[i][j]);
        }
        printf("\n");
    }
    return 0;
}
/*
Sortie : 
01010101
10101010
01010101
10101010
01010101
10101010
01010101
10101010
*/
c

Un tableau de chaînes de ca­rac­tères

Un détail qui a son im­por­tance pour une uti­li­sa­tion habile des tableaux : un tableau n’est en fait qu’un pointeur vers un endroit de la mémoire et c’est ainsi que le com­pi­la­teur C le comprend. L’index, qui est indiqué lors de l’écriture ou de la lecture de champs in­di­vi­duels, re­pré­sente donc le dé­pla­ce­ment le long du tableau par rapport à l’adresse de base. L’exemple suivant permet d’illustrer :

int nombres2[5] = {1, 2, 3, 4, 5};
printf("%d\n", *nombres2); 
// Sortie: 1 
printf("%d\n", *(nombres2 + 2));
// Sortie: 3
c

Les chaînes de ca­rac­tères sont traitées de la même manière en C. Ainsi, il est possible d’itérer sur une chaîne de ca­rac­tères comme s’il s’agissait d’un tableau. C’est ce que montre l’exemple suivant, dans lequel trois ensembles stockés dans un tableau sont affichés caractère par caractère en ma­jus­cules. Pour accéder aux ca­rac­tères, on utilise le champ d’index du tableau (crochets) :

#include <stdio.h>
int main() {
    char* phrases[3];
    phrases[0] = "Bonjour, ceci est la première phrase.\n";
    phrases[1] = "Ceci est seulement la deuxième phrase.\n";
    phrases[2] = "Et maintenant, il y en a trois.\n";
    printf("Phrases originales :\n\n");
    for(int i = 0; i < 3; i++) { 
        printf("%s", phrases[i]);
    }
    printf("\nPhrases modifiées :\n\n");
    for(int i = 0; i < 3; i++) {
        int j = 0;
        while(phrases[i][j] != '\n') {
            if(phrases[i][j] >= 'a' && phrases[i][j] <= 'z') {
                printf("%c", phrases[i][j] - 0x20);
            } else {
                printf("%c", phrases[i][j]);
            }
            j++;
        }
        printf("\n");
    }
    return 0;
}
// Sortie :
Phrases originales :
Bonjour, ceci est la première phrase.
Ceci est seulement la deuxième phrase.
Et maintenant, il y en a trois.
Phrases modifiées :
BONJOUR, CECI EST LA PREMIERE PHRASE.
CECI EST SEULEMENT LA DEUXIEME PHRASE.
ET MAINTENANT, IL Y EN A TROIS.
*/
c
Aller au menu principal