Cours programmation en langage C: Chapitre 5 - Les tableaux

Ce cours traite des tableaux en langage C, un concept fondamental pour les étudiants en informatique de première année. Il présente la définition, la déclaration, l'initialisation, la manipulation et des exemples pratiques d'utilisation des tableaux unidimensionnels.

Les tableaux à une dimension

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.

Déclaration et mémorisation

La syntaxe générale pour déclarer un tableau fixe le type et la taille de la structure :

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

Par exemple :

int tab[5];

déclare un tableau nommé tab de 5 éléments de type entier. Les indices vont de 0 à 4, donc :

• première composante : tab[0]
• deuxième composante : tab[1]
• dernière composante : 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.

#include <stdio.h>
void main()
{
    int x = 5;
    printf("la valeur de x est %d, son adresse est %p\n", x, &x);
}

Exemple d'exécution :

la valeur de x est 5, son adresse est 0012FF7C

#include <stdio.h>
void main()
{
    int tab[5];
    printf("l'adresse de début est %p\n", tab);
}

Exemple d'exécution :

l'adresse de début est 0012FF6C

Exemple avec initialisation :

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

Les indices et valeurs sont :

• tab[0] = 11, adresse &tab[0] = F800
• tab[1] = 12, adresse &tab[1] = F810
• tab[2] = 13, adresse &tab[2] = F820
• tab[3] = 14, adresse &tab[3] = F830
• tab[4] = 15, adresse &tab[4] = F840

Si un tableau a N composantes et que chaque composante occupe M octets, alors le tableau occupe N*M octets en mémoire.

Exemple :

long tab[15]; // sizeof(long) = 4 octets
// mémoire réservée = 15 * 4 = 60 octets

Initialisation et réservation automatique

Lors de la déclaration, on peut initialiser les composantes du tableau en listant les valeurs entre accolades :

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

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

Si la dimension n'est pas indiquée, elle est automatiquement déduite du nombre de valeurs :

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

Exemple d'affichage des éléments et de leurs adresses

Le programme suivant illustre la contiguïté mémoire des éléments d'un tableau :

#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]);
}

Exécution :

l'adresse de début est 0012FF6C
l'élément est 11, son adresse est 0012FF6C
l'élément est 12, son adresse est 0012FF70
l'élément est 13, son adresse est 0012FF74
l'élément est 14, son adresse est 0012FF78
l'élément est 15, son adresse est 0012FF7C

Lecture et écriture dans un tableau

Pour lire et écrire dans un tableau, on utilise souvent la boucle for. Exemple :

#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]);
}

Remarques importantes :

• La fonction scanf nécessite l'adresse de la variable, d'où l'utilisation de &tab[i].
• Le format de lecture doit correspondre au type des données (ici %d pour int).
• 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 valeurs séparées, on peut utiliser un espace, une tabulation (\t) ou un formatage précis.

Exemples pratiques

Exemple 1 : Somme et moyenne d'un tableau

Ce programme calcule la somme cumulative puis la moyenne des valeurs saisies :

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

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

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

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

    // Calcul de la somme
    for (i = 0; i < n; i++)
        som += tab[i];

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

Exemple 2 : Inversion des éléments d'un tableau sans tableau d'aide

L'inversion s'effectue en échangeant les éléments symétriques par rapport au centre :

#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]);
}

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

Ce traitement répartit les valeurs dans deux tableaux distincts selon leur signe :

#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++;
        }
        else
        {
            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]);
}

Exemple 4 : Recherche du maximum et du minimum dans un tableau

La recherche mémorise la position du premier extremum rencontré :

#include <stdio.h>
void main()
{
    int tab[50];
    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\n", tab[max], max);
    printf("le minimum est %d, son indice est %d\n", tab[min], min);
}

Glossaire des termes clés

• Tableau unidimensionnel : variable structurée composée d'un nombre fixe de variables simples du même type.
• Composante : élément individuel d'un tableau, accessible par un indice.
• Indice : numéro entier qui identifie la position d'une composante dans un tableau, commençant à 0.
• Initialisation : affectation des valeurs aux composantes d'un tableau lors de sa déclaration.
• Adresse : emplacement mémoire d'une variable ou d'une composante de tableau.
• sizeof : opérateur qui donne la taille en octets d'un type ou d'une variable.
• scanf : fonction C pour la lecture des données au clavier, nécessite l'adresse de la variable.
• printf : fonction C pour l'affichage des données à l'écran, nécessite un format adapté au type des données.
• Boucle for : structure de contrôle permettant de répéter un bloc d'instructions un nombre déterminé de fois.

Points clés à retenir

• Un tableau en C est une collection d'éléments du même type, accessibles via des indices commençant à 0.
• Le nom d'un tableau représente l'adresse de son premier élément en mémoire.
• La déclaration d'un tableau fixe sa taille, mais elle peut être déduite automatiquement lors de l'initialisation.
• Les boucles for sont particulièrement adaptées pour parcourir et manipuler les tableaux.
• Pour lire des valeurs dans un tableau avec scanf, il faut passer l'adresse des éléments.
• Il est possible de manipuler un tableau pour calculer la somme, la moyenne, inverser l'ordre des éléments, ou séparer les valeurs selon un critère.
• La recherche du maximum et du minimum dans un tableau peut être réalisée en parcourant tous les éléments et en mémorisant les indices correspondants.