Langage C (Chapitre 4 : Les tableaux)

Chapitre 4 : Les Tableaux

I. Introduction :
Les tableaux sont certainement les variables structurées les plus populaires. Ils sont
disponibles dans tous les langages de programmation et servent à résoudre une multitude de
problèmes. Dans une première approche, le traitement des tableaux en C ne diffère pas de
celui des autres langages de programmation, cependant le langage C permet un accès encore
plus direct et plus rapide aux données d'un tableau (à travers les pointeurs).

II. Les tableaux à une dimension :

II.1 Définition :
Un tableau (uni-dimensionnel) A est une variable structurée formée d'un nombre entier N de
variables simples du même type, qui sont appelées les composantes du tableau. Le nombre de
composantes N est alors la dimension du tableau. En faisant le rapprochement avec les
mathématiques, on dit encore que "A est un vecteur de dimension N"

Exemple :

La déclaration :

int JOURS[12]={31,28,31,30,31,30,31,31,30,31,30,31};

définit un tableau du type int de dimension 12. Les 12 composantes sont initialisées par les
valeurs respectives 31, 28, 31, ... , 31. On peut accéder à la première composante du tableau
par JOURS[0], à la deuxième composante par JOURS[1], ... , à la dernière composante par
JOURS[11].

II.2 Déclaration et mémorisation :

a. Déclaration :

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

Les noms des tableaux sont des identificateurs qui doivent correspondre aux
restrictions définies dans les autres chapitres

Réalisé par : Bassem Boughzala (ISET RADES) Page 1/12

Langage C (Chapitre 4 : Les tableaux)

Exemples :

int A[25]; ou bien long A[25]; ou bien ...

float B[100]; ou bien double B[100]; ou bien ...
int C[10];
char D[30];

b. Mémorisation :

En C, le nom d'un tableau est le représentant de l'adresse du premier élément du tableau.

Les adresses des autres composantes sont calculées (automatiquement) relativement à cette
adresse.

Exemple :

short A[5] = {1200, 2300, 3400, 4500, 5600};

Si un tableau est formé de N composantes et si une composante a besoin de M octets en

mémoire, alors le tableau occupera de N*M octets.

Exemple :
En supposant qu'une variable du type long occupe 4 octets (c.-à-d: sizeof(long)=4),
pour le tableau T déclaré par: long T[15]; C réservera N*M = 15*4 = 60 octets en mémoire.

II.3 Initialisation et réservation automatique :

a. Initialisation :

Lors de la déclaration d'un tableau, on peut initialiser les composantes du tableau, en

indiquant la liste des valeurs respectives entre accolades.

Exemples

int A[5] = {10, 20, 30, 40, 50};

float B[4] = {-1.05, 3.33, 87e-5, -12.3E4};
int C[10] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};

Il faut évidemment veiller à ce que le nombre de valeurs dans la liste corresponde à la

dimension du tableau. Si la liste ne contient pas assez de valeurs pour toutes les composantes,
les composantes restantes sont initialisées par zéro.

b. Réservation automatique :

Réalisé par : Bassem Boughzala (ISET RADES) Page 2/12

Langage C (Chapitre 4 : Les tableaux)

Si la dimension n'est pas indiquée explicitement lors de l'initialisation, alors l'ordinateur réserve
automatiquement le nombre d'octets nécessaires.

Exemples

int A[] = {10, 20, 30, 40, 50};

==> réservation de 5*sizeof(int) octets (dans notre cas: 10 octets)

float B[] = {-1.05, 3.33, 87e-5, -12.3E4};

==> réservation de 4*sizeof(float) octets (dans notre cas: 16 octets)

int C[] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};

==> réservation de 10*sizeof(int) octets (dans notre cas: 20 octets)

Exemples

II.4 Accès aux composantes :

En déclarant un tableau par: int A[5]; nous avons défini un tableau A avec cinq composantes,
auxquelles on peut accéder par: A[0], A[1], ... , A[4]

Exemple :

Réalisé par : Bassem Boughzala (ISET RADES) Page 3/12

Langage C (Chapitre 4 : Les tableaux)

Considérons un tableau T de dimension N:

En Langage C,

- l'accès au premier élément du tableau se fait par T[0]

- l'accès au dernier élément du tableau se fait par T[N-1]

II.5 Affichage et affectation :

La structure for se prête particulièrement bien au travail avec les tableaux. La plupart
des applications se laissent implémenter par simple modification des exemples-types de
l'affichage et de l'affectation.

a) Affichage du contenu d'un tableau :

main()
{
int A[5];
int I; /* Compteur */
for (I=0; I<5; I++)
printf("%d ", A[I]);
return 0;
printf("\n");
}

Remarques:
- Avant de pouvoir afficher les composantes d'un tableau, il faut évidemment leur
affecter des valeurs.
- Pour être sûr que les valeurs sont bien séparées lors de l'affichage, il faut inclure
au moins un espace dans la chaîne de format. Autres possibilités :
printf("%d\t", A[I]); /* tabulateur */
printf("%7d", A[I]); /* format d'affichage */

b) Affectation avec des valeurs provenant de l'extérieur :

main()
{
int A[5];
int I; /* Compteur */
for (I=0; I<5; I++)
scanf("%d", &A[I]);
return 0;
}

Réalisé par : Bassem Boughzala (ISET RADES) Page 4/12

Langage C (Chapitre 4 : Les tableaux)

Remarques:

- Comme scanf a besoin des adresses des différentes composantes du tableau, il faut faire
précéder le terme A[I] par l'opérateur adresse '&'.
- La commande de lecture scanf doit être informée du type exact des données à lire.
(Ici: %d ou %i pour lire des valeurs du type int)

c) Programme Général de traitement des tableaux unidimensionnels en C :

#include<stdio.h>
#define dim 100
void main()
{
int t[dim],n, i;
do
{
printf("\n Donner la dimension du tableau: ");
scanf("%d",&n);
}
while((n<1)||(n>100));
printf("\n ****** remplissage du tableau ******\n");
for(i=0;i<n;i++)
{
printf("t[%d]= ",i);
scanf("%d",&t[i]);
}

/******* Traitement *********/

printf("\n ****** Affichage des elements du tableau ****** \n");

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

Exercices d'applications :
Exercice 1 :
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension
maximale : 50 composantes), remplit le tableau par des valeurs entrées au clavier et affiche le
tableau. Calculer et afficher ensuite la somme des éléments du tableau.

Exercice 2 :
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension
maximale : 50 composantes), remplit le tableau par des valeurs entrées au clavier et affiche le
tableau. Effacer ensuite toutes les occurrences de la valeur 0 dans le tableau T et tasser les
éléments restants. Afficher le tableau résultant.

Exercice 3 :
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension
maximale : 50 composantes), remplit le tableau par des valeurs entrées au clavier et affiche le

Réalisé par : Bassem Boughzala (ISET RADES) Page 5/12

Langage C (Chapitre 4 : Les tableaux)

tableau. Ranger ensuite les éléments du tableau T dans l'ordre inverse sans utiliser de tableau
d'aide. Afficher le tableau résultant.
Idée : Echanger les éléments du tableau à l'aide de deux indices qui parcourent le tableau en
commençant respectivement au début et à la fin du tableau et qui se rencontrent en son milieu.

Exercice 4 :
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension
maximale : 50 composantes), remplit le tableau par des valeurs entrées au clavier et affiche le
tableau. Copiez ensuite toutes les composantes strictement positives dans un deuxième tableau
TPOS et toutes les valeurs strictement négatives dans un troisième tableau TNEG. Afficher les
tableaux TPOS et TNEG.

III. Les tableaux à deux dimensions :

III.1 Définition :

En C, un tableau à deux dimensions A est à interpréter comme un tableau (uni-

dimensionnel) de dimension L dont chaque composante est un tableau (uni-dimensionnel) de
dimension C. On appelle L le nombre de lignes du tableau et C le nombre de colonnes du
tableau. L et C sont alors les deux dimensions du tableau. Un tableau à deux dimensions
contient donc L*C composantes.

- On dit qu'un tableau à deux dimensions est carré, si L est égal à C.

- En faisant le rapprochement avec les mathématiques, on peut dire que "A est un vecteur
de L vecteurs de dimension C", ou mieux : "A est une matrice de dimensions L et C".

Exemple :
Considérons un tableau NOTE à deux dimensions pour mémoriser les notes des élèves dans
les 10 devoirs d'un trimestre.

int NOTE[10][20] = {{45, 34, ... , 50, 48},

{39, 24, ... , 49, 45},
... ... ...
{40, 40, ... , 54, 44}};

Réalisé par : Bassem Boughzala (ISET RADES) Page 6/12

Langage C (Chapitre 4 : Les tableaux)

Dans une ligne nous retrouvons les notes de tous les élèves dans un devoir. Dans une
colonne, nous retrouvons toutes les notes d'un élève.

III.2 Déclaration et mémorisation :

a) Déclaration :

Déclaration de tableaux à deux dimensions en C

<TypeSimple> <NomTabl>[<DimLigne>][<DimCol>];

Exemples :

int A[10][10]; ou bien long A[10][10]; ou bien ...

float B[2][20]; ou bien double B[2][20]; ou bien ...
int C[3][3];
char D[15][40];

b) Mémorisation :

Comme pour les tableaux à une dimension, le nom d'un tableau est le représentant de l'adresse
du premier élément du tableau (c.-à-d. l'adresse de la première ligne du tableau). Les
composantes d'un tableau à deux dimensions sont stockées ligne par ligne dans la mémoire.

Exemple: Mémorisation d'un tableau à deux dimensions

short A[3][2] = {{1, 2 },

{10, 20 },
{100, 200}};

Un tableau de dimensions L et C, formé de composantes dont chacune a besoin de M octets,

occupera L*C*M octets en mémoire. Notre exemple occupera en mémoire (3*2*2 = 12 octets).

En supposant qu'une variable du type double occupe 8 octets (c-à-d : sizeof(double)=8), pour
le tableau T déclaré par: double T[10][15]; C réservera L*C*M = 10*15*8 = 1200 octets en
mémoire.

Réalisé par : Bassem Boughzala (ISET RADES) Page 7/12

Langage C (Chapitre 4 : Les tableaux)

III.3 Initialisation et réservation automatique :

a) Initialisation :

Lors de la déclaration d'un tableau, on peut initialiser les composantes du tableau, en

indiquant la liste des valeurs respectives entre accolades. A l'intérieur de la liste, les
composantes de chaque ligne du tableau sont encore une fois comprises entre accolades. Pour
améliorer la lisibilité des programmes, on peut indiquer les composantes dans plusieurs lignes.

Exemples

int A[3][10] ={{ 0,10,20,30,40,50,60,70,80,90},

{10,11,12,13,14,15,16,17,18,19},
{ 1,12,23,34,45,56,67,78,89,90}};

float B[3][2] = {{-1.05, -1.10 },

{86e-5, 87e-5 },
{-12.5E4, -12.3E4}};

Exemples

Réalisé par : Bassem Boughzala (ISET RADES) Page 8/12

Langage C (Chapitre 4 : Les tableaux)

b) Réservation automatique :
Si le nombre de lignes L n'est pas indiqué explicitement lors de l'initialisation, l'ordinateur
réserve automatiquement le nombre d'octets nécessaires.

int A[][10] = {{ 0,10,20,30,40,50,60,70,80,90},

{10,11,12,13,14,15,16,17,18,19},
{ 1,12,23,34,45,56,67,78,89,90}};

Réservation de 3*10*2 = 60 octets

float B[][2] = {{-1.05, -1.10 },

{86e-5, 87e-5 },
{-12.5E4, -12.3E4}};

Réservation de 3*2*4 = 24 octets

Exemple

III.4 Accès aux composantes :

Les éléments d'un tableau de dimensions L et C se présentent de la façon suivante:

/ \
| A[0][0] A[0][1] A[0][2] . . . A[0][C-1] |
| A[1][0] A[1][1] A[1][2] . . . A[1][C-1] |
| A[2][0] A[2][1] A[2][2] . . . A[2][C-1] |
| . . . . . . . . . . . . . . . |
| A[L-1][0] A[L-1][1] A[L-1][2] . . . A[L-1][C-1] |
\ /

Attention ! :

Considérons un tableau A de dimensions L et C.

Réalisé par : Bassem Boughzala (ISET RADES) Page 9/12

Langage C (Chapitre 4 : Les tableaux)

En C,

- les indices du tableau varient de 0 à L-1, respectivement de 0 à C-1.

- la composante de la Nième ligne et Mième colonne est notée : A[N-1][M-1]

III.5 Affichage et affectation :

a) Affichage des éléments :

Lors du travail avec les tableaux à deux dimensions, nous utiliserons deux indices (p.ex:
I et J), et la structure for, souvent imbriquée, pour parcourir les lignes et les colonnes des
tableaux.
main()
{
int A[5][10];
int I,J;
/* Pour chaque ligne ... */
for (I=0; I<5; I++)
{
/* ... considérer chaque composante */
for (J=0; J<10; J++)
printf("%7d", A[I][J]);
/* Retour à la ligne */
printf("\n");
}
}

Remarques :
- Avant de pouvoir afficher les composantes d'un tableau, il faut leur affecter des
valeurs.
- Pour obtenir des colonnes bien alignées lors de l'affichage, il est pratique d'indiquer la
largeur minimale de l'affichage dans la chaîne de format. Pour afficher des matrices du
type int (valeur la plus 'longue': -32768), nous pouvons utiliser la chaîne de
format "%7d" : printf("%7d", A[I][J]);
b) remplissage de la matrice :
main()
{
int A[5][10];
int I,J;
/* Pour chaque ligne ... */
for (I=0; I<5; I++)
/* ... considérer chaque composante */
for (J=0; J<10; J++)
scanf("%d", &A[I][J]);
return 0;
}

c) Programme Général de traitement des tableaux bidimensionnels en C :

Réalisé par : Bassem Boughzala (ISET RADES) Page 10/12

Langage C (Chapitre 4 : Les tableaux)

#include<stdio.h>
#include<stdlib.h>
#define nb_lig 50
#define nb_col 50
void main()
{ int M[nb_lig][nb_col],l,c,i,j;
do
{
printf("\n Donner le nombre de lignes et de colonnes de la matrice ");
printf("\n ********* Maximum (50 lignes et 50 colonnes) ******** : ");
scanf("%d%d",&l,&c);
}
while(l<1 || l>nb_lig || c<1 || c>nb_col);

printf("\n\n ***** Remplissage de la matrice ***** \n\n");

/* Pour chaque ligne ... */
for (i=0; i<l; i++)
/* ... considérer chaque composante */
for (j=0; j<c; j++)
{
printf("M[%d][%d] = ",i,j);
scanf("%d",&M[i][j]);
}

/********** Traitement **********/

printf("\n\n ***** Affichage de la matrice ***** \n\n");

/* Pour chaque ligne ... */
for (i=0; i<l; i++)
{
/* ... considérer chaque composante */
for (j=0; j<c; j++)
printf("%7d", M[i][j]);
/* Retour à la ligne */
printf("\n");
}
system("pause");
}

Exercices d'applications :
Exercice 5 :
Ecrire un programme qui lit les dimensions L et C d'un tableau T à deux dimensions du
type int (dimensions maximales : 50 lignes et 50 colonnes). Remplir le tableau par des valeurs
entrées au clavier et afficher le tableau ainsi que la somme de tous ses éléments.

Réalisé par : Bassem Boughzala (ISET RADES) Page 11/12

Langage C (Chapitre 4 : Les tableaux)

Exercice 6 :
Ecrire un programme qui lit les dimensions L et C d'un tableau T à deux dimensions du
type int (dimensions maximales : 50 lignes et 50 colonnes). Remplir le tableau par des valeurs
entrées au clavier et afficher le tableau ainsi que la somme de chaque ligne et de chaque colonne
en n'utilisant qu'une variable d'aide pour la somme.
Exercice 7 :
Ecrire un programme qui transfère un tableau M à deux dimensions L et C (dimensions
maximales : 10 lignes et 10 colonnes) dans un tableau V à une dimension L*C.

Exemple:
/ \
| a b c d | / \
| e f g h | ==> | a b c d e f g h i j k l |
| i j k l | \ /
\ /

Réalisé par : Bassem Boughzala (ISET RADES) Page 12/12