Cours Programmation en Langage C: Chapitre 5 - Les Tableaux

Ce cours aborde les tableaux en langage C, un concept fondamental en programmation. Il s'inscrit dans un cursus d'informatique appliquée de première année et présente la définition, la déclaration, l'initialisation, ainsi que plusieurs exemples pratiques d'utilisation des tableaux unidimensionnels.

Définition et déclaration des tableaux unidimensionnels

Un tableau unidimensionnel est une variable structurée composée d'un nombre entier n de variables simples du même type, appelées composantes du tableau. En langage C, la déclaration d'un tableau se fait selon la syntaxe :

<TypeSimple> <NomTableau>[<Dimension>];

Par exemple, la déclaration int tab[5]; crée un tableau nommé tab contenant 5 éléments de type entier. Les indices commencent à 0, donc les éléments sont accessibles par tab[0] à tab[4].

En C, le nom du tableau représente l'adresse du premier élément. Les adresses des autres éléments sont calculées automatiquement à partir de cette adresse de base. Par exemple :

int tab[5] = {11, 12, 13, 14, 15};

Dans cet exemple, tab[0] vaut 11, tab[1] vaut 12, etc. Si l'adresse de tab[0] est F800, alors tab[1] aura une adresse calculée automatiquement (par exemple F810), et ainsi de suite.

La taille mémoire occupée par un tableau est égale au produit du nombre de composantes N par la taille en octets M d'une composante. Par exemple, si une variable de type long occupe 4 octets, alors un tableau long tab[15]; occupera 15 × 4 = 60 octets.

Initialisation et réservation automatique de la mémoire

Lors de la déclaration, il est possible d'initialiser un tableau en indiquant la liste des valeurs entre accolades :

int tab[5] = {10, 20, 30, 40, 50};
char tab[5] = {'A', 'b', 'C', 'd', 'e'};

Si la liste contient moins de valeurs que la dimension du tableau, les composantes restantes sont initialisées à zéro.

Si la dimension n'est pas explicitement indiquée, elle est automatiquement déduite du nombre d'éléments fournis :

int tab[] = {10, 20, 30, 40, 50};  // 5 éléments
int C[] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};  // 10 éléments

La structure for est particulièrement adaptée pour manipuler les tableaux. Par exemple, pour afficher les éléments et leurs adresses :

#include <stdio.h>
void main() {
    int tab[5] = {11, 12, 13, 14, 15};
    printf("l'adresse de début est %p\n", tab);
    for(int i = 0; i < 5; i++)
        printf("l'élément est %d, son adresse est %p\n", tab[i], &tab[i]);
}

Lecture et affichage des éléments d'un tableau

Pour saisir un nombre variable d'éléments dans un tableau, on peut réserver un espace mémoire suffisamment grand, puis lire le nombre d'éléments à saisir :

#include <stdio.h>
void main() {
    int tab[20];
    int i, n;
    printf("saisir le nombre d’éléments : ");
    scanf("%d", &n);
    for(i = 0; i < n; i++)
        scanf("%d", &tab[i]);
    for(i = 0; i < n; i++)
        printf("%d ", tab[i]);
}

Quelques remarques importantes :

• La fonction scanf nécessite l'adresse des éléments, d'où l'utilisation de &tab[i].
• Le format %d indique que l'on lit des entiers.
• La condition dans la boucle for est une condition de répétition, la boucle s'exécute tant que i < n.
• Pour afficher les éléments de façon lisible, il est conseillé d'ajouter un espace ou une tabulation dans la chaîne de format.

Exemples pratiques d'utilisation des tableaux

Calcul de la somme et de la moyenne

Ce programme remplit un tableau d'entiers, affiche ses éléments, puis calcule et affiche la somme et la moyenne :

#include <stdio.h>
void main() {
    int tab[50];
    int i, n, som = 0;
    float moyenne;

    printf("saisir la taille du tableau : ");
    scanf("%d", &n);

    for(i = 0; i < n; i++)
        scanf("%d", &tab[i]);

    for(i = 0; i < n; i++)
        printf("l'élément d'indice %d est %d\n", i, tab[i]);

    for(i = 0; i < n; i++)
        som += tab[i];

    printf("la somme est %d\n", som);
    printf("la moyenne est %5.2f\n", som / (float)n);
}

Inversion des éléments d'un tableau sans tableau d'aide

Ce programme lit un tableau, affiche ses éléments, inverse leur ordre sans utiliser de tableau auxiliaire, puis affiche le tableau inversé :

#include <stdio.h>
void main() {
    int tab[50];
    int i, j, aide, n;

    printf("saisir la taille du tableau : ");
    scanf("%d", &n);

    for(i = 0; i < n; i++)
        scanf("%d", &tab[i]);

    for(i = 0; i < n; i++)
        printf("%d\n", tab[i]);

    for(i = 0, j = n - 1; i < j; i++, j--) {
        aide = tab[i];
        tab[i] = tab[j];
        tab[j] = aide;
    }

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

Séparation des valeurs positives et négatives dans deux tableaux

Ce programme remplit un tableau, puis copie les valeurs positives ou nulles dans un tableau tpos et les valeurs strictement négatives dans un tableau tneg. Il affiche ensuite ces deux tableaux :

#include <stdio.h>
void main() {
    int tab[50], tpos[50], tneg[50];
    int pos = 0, neg = 0;
    int i, n;

    printf("saisir la taille du tableau : ");
    scanf("%d", &n);

    for(i = 0; i < n; i++)
        scanf("%d", &tab[i]);

    for(i = 0; i < n; i++) {
        if(tab[i] >= 0) {
            tpos[pos] = tab[i];
            pos++;
        }
        if(tab[i] < 0) {
            tneg[neg] = tab[i];
            neg++;
        }
    }

    printf("Affichage du tableau positif\n");
    for(i = 0; i < pos; i++)
        printf("%d\n", tpos[i]);

    printf("Affichage du tableau négatif\n");
    for(i = 0; i < neg; i++)
        printf("%d\n", tneg[i]);
}

Recherche du maximum et du minimum dans un tableau

Ce programme lit un tableau d'entiers, puis détermine la plus grande et la plus petite valeur ainsi que leur position dans le tableau. En cas de plusieurs maxima ou minima, la position du premier rencontré est retenue :

#include <stdio.h>
void main() {
    int tab[5];
    int i, n, min = 0, max = 0;

    printf("saisir la taille du tableau : ");
    scanf("%d", &n);

    for(i = 0; i < n; i++)
        scanf("%d", &tab[i]);

    for(i = 0; i < n; i++) {
        if(tab[i] > tab[max]) max = i;
        if(tab[i] < tab[min]) min = i;
    }

    printf("le maximum est %d, son indice est %d\nle minimum est %d, son indice est %d\n",
           tab[max], max, tab[min], min);
}

Points clés

• Un tableau unidimensionnel est une variable structurée composée d’éléments du même type accessibles par un indice.
• La déclaration en C se fait avec Type nom[dimension], et le nom du tableau représente l’adresse du premier élément.
• La mémoire occupée par un tableau est égale à la taille d’un élément multipliée par le nombre d’éléments.
• Il est possible d’initialiser un tableau lors de sa déclaration avec une liste de valeurs entre accolades.
• Si la dimension n’est pas précisée, elle est automatiquement déduite du nombre d’éléments initialisés.
• La boucle for est adaptée pour parcourir et manipuler les tableaux.
• Pour lire des valeurs dans un tableau avec scanf, il faut fournir l’adresse des éléments (&tab[i]).
• Des exemples concrets montrent comment calculer la somme et la moyenne, inverser un tableau, séparer les valeurs positives et négatives, et trouver les valeurs extrêmes.