Informatique - EMINES – Université Mohamed VI

Les tableaux
Sommaire
I. Introduction ..................................................................................................................................... 2
1. Limites des données élémentaires ............................................................................................... 2
2. Domaines d'utilisation : ............................................................................................................... 2
3. Description .................................................................................................................................. 2
II. Syntaxe en langage algorithmique................................................................................................... 2
1. Syntaxe de déclaration en dimension 1 ................................................................................... 2
2. Syntaxe d'accès aux composantes d'un tableau de dimension 1 .............................................. 3
3. Syntaxe d'accès aux composantes en dimension D ................................................................. 3
III. Les tableaux en langage C ........................................................................................................... 3
1. Déclaration .................................................................................................................................. 3
a. Exercice 1 : .................................................................................................................................. 4
2. Utilisation .................................................................................................................................... 4
a. Exercice 2 : .................................................................................................................................. 4
b. Exercice 3: ................................................................................................................................... 5
3. Cas d’un tableau de caractères .................................................................................................... 5
4. Tableau à 2 dimensions ............................................................................................................... 5
a. Exercice 4: ................................................................................................................................... 5
b. Exercice 5: ................................................................................................................................... 6

1
 Informatique - EMINES – Université Mohamed VI

Les tableaux

I. Introduction
1. Limites des données élémentaires
- Exemple
On souhaite saisir 6 notes et les afficher de la plus petite à la plus grande

C'est faisable mais ce n'est pas extensible. Avec 16 notes il faudra 10 variables de plus et le code pour
les ordonner va très vite devenir illisible. De plus si on ne connait pas par avance le nombre de notes à
saisir, on ne sait pas faire.
L'origine de ces problèmes, c'est notre incapacité à définir un ensemble de données homogènes
- Solution
Regrouper des éléments de même type au sein d'une collection d'éléments. Pouvoir parcourir cette
collection et si besoin accéder facilement à chaque élément.

2. Domaines d'utilisation :
On utilise souvent les tableaux à un seul indice pour :
- calculer les statistiques de base (moyenne, écart-type, plus grande et plus petite valeurs
, ...)
- trier, rechercher un élément en particulier
- afficher les informations traitées (avant ou après le tri, satisfont aux conditions
voulues, etc ...)

3. Description
Un tableau regroupe un nombre n d'éléments de même type. Chaque case du tableau est identifiée par
un indice allant de 0 jusqu'à n-1. n est aussi appelé la taille du tableau

II. Syntaxe en langage algorithmique

1. Syntaxe de déclaration en dimension 1

nomTableau : Tableau[N] de type

2
 Informatique - EMINES – Université Mohamed VI

N: Constante entière littérale ou non littérale définissant la taille selon l'unique indice
Syntaxe de déclaration en dimension 2
nomTableau : Tableau[N][M] de type
N et M: Constantes entières littérales ou non définissant les tailles (selon chacune des 2 dimensions)
Syntaxe de déclaration en dimension D

nomTableau : Tableau[N1][N2]...[ND] de type

N1, N2, ..., ND: D constantes entières littérales ou non définissant les tailles (selon chacune des n
dimensions)
ATTENTION: Non initialisation du contenu des tableaux au moment de leur déclaration (i.e. leurs
composantes ne sont pas initialisées et sont donc de valeur aléatoire)

2. Syntaxe d'accès aux composantes d'un tableau de dimension 1

En lecture ou en écriture:
nomTableau[indice]
indice: Constante entière, variable entière ou expression à résultat entier
Syntaxe d'accès aux composantes d'un tableau de dimension 2
En lecture ou en écriture:
nomTableau[indice1][indice2]
indice1 et indice2: Constantes entières, variables entières ou expressions à résultat entier

3. Syntaxe d'accès aux composantes en dimension D

En lecture ou en écriture:
nomTableau[i1][i2]...[iD]
i1, i2, ..., iD: Constantes entières, variables entières ou expressions à résultat entier
Exemples:
nomTableau[0], nomTableau[1], nomTableau[i], nomTableau[i+k], nomTableau[i][k]

ATTENTION: Pour un tableau de taille N, indices définis de 0 à N-1 et pas de 1 à N

III. Les tableaux en langage C

1. Déclaration
Comme une variable, on déclare son type, puis son nom. On rajoute le nombre d’éléments du tableau
entre crochets [ ] :
float tab[5] ; : est un tableau de 5 flottants.
int tablo[8] ; : est un tableau de 8 entiers.

ATTENTION !
▪ Les numéros des éléments d’un tableau de n éléments vont de 0 à n-1.
▪ La taille du tableau doit être une constante, donc int tab[n]; où n serait une variable déjà
déclarée est une mauvaise déclaration. Par contre si on a défini #define N 100 en directive, on
peut déclarer int tab[N] ; car N est alors une constante.

On peut initialiser un tableau lors de sa déclaration :

/* initialisation de tous les éléments de tab */

float tab[5] = { 1, 2, 3, 4, 5} ;

3
 Informatique - EMINES – Université Mohamed VI

/* initialisation de certains éléments de tableau toto[0]=2; toto[1]=4 ; toto[2]=6 ; */

float toto[10] = {2, 4, 6} ;

a. Exercice 1 :
Ci-dessous deux algorithmes le premier permet de saisir un tableau, alors que le deuxième permet
d’afficher un tableau :

algoSaisieTab
variables
i: entier
n : entier
tableau T : réel
Debut
Pour i allant de 0 à n-1
écrire ("Saisie de l'élément ", i + 1)
lire (T[i] )
FinPour
Fin

algoAfficheTab
variables
i: entier
n : entier
tableau T : réel
Début
Pour i allant de 0 à n-1
écrire ("T[",i, "] =", T[i])
FinPour
Fin

Ecrivez un programme permettant de traduire cela en langage C

2. Utilisation
Comme schématisé au-dessous, on accède à l’élément i d’un tableau en
faisant suivre le nom du tableau par le numéro i entre crochets. Un élément float tab[5];
de tableau s’utilise comme une variable quelconque. On peut donc faire tab[0]
référence à un élément pour une affectation : x=tab[2], tab[3]=3, ou dans tab[1]
une expression : if (tab[i]< 0). tab[2]
tab[3]
tab[4]

a. Exercice 2 :
Pour le calcul du nombre d'étudiants ayant une note supérieure à 10 avec les tableaux, on peut écrire :

Variables i ,nbre : entier

tableau notes[30] : réel
Début
nbre ← 0

4
 Informatique - EMINES – Université Mohamed VI

Pour i allant de 0 à 29
Si (notes[i] >10) alors
nbre ←nbre+1
FinSi
FinPour
écrire ("le nombre de notes supérieures à 10 est : ", nbre)
Fin
Ecrivez un programme permettant de réaliser cela.

b. Exercice 3:

Ecrire un algorithme qui lit la taille N d'un tableau T1 du type entier, remplit le tableau par des valeurs
entrées au clavier et affiche le tableau.

Copier dans un tableau T2 les valeurs > 10 et dans T1 les valeurs <=10.

Exemple :

Tableau 1 : 4 -8 7 -9 1 5 -4 6
Tableau 2 : 14 72 15 55

Traduire l’algorithme en langage C.

3. Cas d’un tableau de caractères

Un tableau de caractères est en fait une chaîne de caractères. Son initialisation peut se faire de
plusieurs façons :

char chaine1[10]={’B’,’o’,’n’,’j’,’o’,’u’,’r’ };

ATTENTION ! Le compilateur rajoute toujours un caractère ‘\0’ à la fin d’une chaîne de caractères.
Il faut donc que le tableau ait au moins un élément de plus que la chaîne.

4. Tableau à 2 dimensions
Un tableau à 2 dimensions est similaire à une matrice. Il se déclare donc de la façon suivante:

int tableau[2][3] ; /* tableau de 2 lignes et 3 colonnes */

Comme il est schématisé ci-contre, tableau[i][j] fait référence à

Colonne 0

Colonne 1

Colonne2

l’élément de la ligne i et de la colonne j de tableau. Tout comme

un tableau à 1 dimension, tableau[i][j] se manipule comme
n’importe quelle variable.

a. Exercice 4: Ligne 0
Ecrivez un algorithme remplissant un tableau de L lignes sur C
Ligne 1
colonnes, avec des zéros.
Traduire l’algorithme en langage C
Tableau [1][2]

5
 Informatique - EMINES – Université Mohamed VI

b. Exercice 5:
Que produit l’algorithme suivant ?
Tableau N(6) en Entier
Variables i, k en Entier
Début
N(0) ← 1
Pour k ← 1 à 6
N(k) ← N(k-1) + 2
k Suivant
Pour i ← 0 à 6
Ecrire N(i)
i suivant
Fin
Peut-on simplifier cet algorithme avec le même résultat ?
Ecrire la traduction de cet algorithme en langage C.