Il arrive en C qu’on est besoin, à un moment ou à un autre, de stocker des valeurs dans ce qu’on appel une table de donnée (ou encore plus simplement : tableau). Le langage C permet cela voyons maintenant comment déclarer un tableau.
Il existe deux types de tableaux :
Les tableaux Statiques : ce sont des tableaux dont la taille est connue à la compilation
Les tableaux Dynamiques : ce sont des tableaux dont la taille n’est connue qu’à l’exécution.
Pour le moment nous ne verrons que les tableaux statiques, nous aborderons les tableaux dynamiques lorsque nous parlerons de la gestion de la mémoire ou encore d’allocation dynamique.
1 – Déclaration d’un tableau
Syntaxe :
Code c:
Type nomDuTableau[nombreDElements];
Exemple :
Code c:
int tableau[4];
On déclare ici un tableau de type int contenant 4 valeurs de type int. « [4] » représente le nombre de cases du tableau, on aura donc ici un tableau de type int de 4 cases, ces cases étant remplies de données de type int uniquement .
De plus la taille du tableau doit être connue à la compilation, et on évitera par dessus tout de définir sa taille à partir d’une variable. Ainsi :
Code c:
int variable = 4;
int tableau[variable];
N’est valable qu’en C99.
Utiliser un tableau
Maintenant que notre tableau est créé, il va falloir le remplir de valeurs. Pour initialiser toutes les cases du tableau à 0 on peut utiliser la méthode qui suit :
Code c:
int tableau[4] = {0};
On initialise ici toutes les cases du tableau à zéro.
Cependant, il se peut que dès la déclaration du tableau, on connaisse certaines valeurs, on peut donc remplir notre tableau avec celle-ci.
Rappel : Toutes les valeurs du tableau sont du même type que le tableau … (mieux vaut trop que pas assez )
Code c:
int tableau[4] = {2, 23, 25, 92};
Chaque case du tableau (ici 4) est donc initialisée à une valeur de type int donnée. Ici tableau[0] vaudra 2; tableau[1] vaudra 23; etc.
Il faut savoir que si on indique pas toutes les valeurs du tableau, alors les valeurs non définies prendrons la valeur 0.
Par exemple :
Code c:
int tableau[4] = {2};
Alors seulement tableau[0] aura la valeur 2.
A notée qu’on peut aussi remplir le tableau de cette façon :
Code c:
int tableau[] = {2, 23, 25, 92};
Vous voyez ici qu’on indique plus le nombres de cases du tableau, enfait le compilateur se chargera pour nous de calculer la taille du tableau.
Maintenant que notre tableau est rempli, il peut être intéressant d’exploiter les valeurs qui lui sont rattachées.
il faut savoir que la première valeur se situe dans la case 0 du tableau et non dans la case 1. Ce qui peut porter à confusion car on serait tenter de récupérer la valeur situer dans tableau[4] mais si on fait cela, on essaye de d’accéder à une case en mémoire qui n’est pas accordée au tableau et très certainement pas non plus à notre programme (ce qui à le dont d’énerver particulièrement votre OS qui vous le signalera par sa belle fenêtre d’erreur prévue à cet effet ), soyez vigilant donc et n’oubliez pas que la dernière valeur de votre tableau se situe dans la case tailleTableau – 1 donc dans notre cas tableau[3]
Pour récupérer les valeurs d’un tableau, une boucle for peut faire l’affaire ainsi si on souhaite retrouver les valeurs du tableau, on utilise la méthode suivante :
Code c:
for (i = 0; i < 4; i++) {
printf(« Valeur contenu dans tableau[%d] = %dn », i, tableau[i]);
/* A chaque tour de boucle on incrémente (= i + 1) notre variable i, ce qui fait qu’on accédera à toute las cases du tableau, on arrête la boucle quand i est égal à trois pour éviter d’accéder dans un bloc mémoire qui ne nous est pas réservé */
}
Ce qui nous donne après compilation :
Code console:
Valeur de tableau[0] = 2
Valeur de tableau[1] = 23
Valeur de tableau[2] = 25
Valeur de tableau[3] = 92
Pour résumer ce paragraphe je vous propose de concevoir ensemble un programme qui calcul la moyenne de toutes les valeurs de notre tableau.
Code c:
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i = 0;
double tableau[4] = {2.0, 16.5, 58.56, 19.92};
/* On initialise notre tableau avec 4 valeurs de type double */
double moyenne = 0.0;
double sommeTotale = 0.0;
for (i = 0; i < 4; i++) {
printf(« Valeur de tableau[%d] = %lfn », i, tableau[i]);
sommeTotale += tableau[i]; // Revient à écrire sommeTotale = sommeTotale + tableau[i]
/* On affiche les valeurs contenues dans le tableau et on les additionne à la variable sommeTotale */
}
moyenne = sommeTotale / 4;
printf(« nMoyenne des valeurs du tableau : %lf », moyenne);
return 0;
}
Ce qui nous donne :
Code console:
Valeur de tableau[0] = 2.000000
Valeur de tableau[1] = 16.500000
Valeur de tableau[2] = 58.560000
Valeur de tableau[3] = 19.920000
Moyenne des valeurs du tableau : 24.245000
2 – Utiliser un tableau dans une fonction
Pour envoyer un tableau à une fonction, il suffit simplement de lui envoyer son adresse à une variable du même type que notre tableau. C’est aussi simple que ça
Voilà un petit code source qui nous présente cela :
Code c:
#include <stdio.h>
#include <stdlib.h>
void afficherTableau(int tableau[]);
int main(void)
{
int tableau[4] = {2, 23, 25, 92};
afficherTableau(tableau);
return 0;
}
void afficherTableau(int tableau[])
{
int i = 0;
for (i = 0; i < 4; i++)
printf(« Tableau[%d] = %dn », i , tableau[i]);
}
Ce qui nous donne :
Code console:
Tableau[0] = 2
Tableau[1] = 23
Tableau[2] = 25
Tableau[3] = 92
On suppose ici qu’on connait la taille du tableau car sinon il vous faudra aussi envoyer la taille de celui ci pour éviter les erreurs
Faites attention donc à ce que la lecture et l’écriture des données d’un tableau soit dans les limites de celui-ci !
Il est aussi possible d’envoyer un tableau à une fonction de cette manière :
Code c:
void afficherTableau(int *tableau);
int main(void)
{
int tableau[4] = {2, 23, 25, 92};
afficherTableau(tableau);
return 0;
}
void afficherTableau(int *tableau)
{
int i = 0;
for (i = 0; i < 4; i++)
printf(« Tableau[%d] = %dn », i , tableau[i]);
}
Vous voyez ici qu’on a simplement remplacer les crochet par une étoile symbolisant un pointeur, c’est autorisé car un tableau est considéré comme un pointeur. Vous pouvez accéder aux éléments du tableau de la même manière en respectant les limites de celui-ci.
Entrainez vous à réaliser de petits programmes envoyant des tableaux à des fonctions, c’est le meilleur moyen de progresser
3 – Les tableaux à deux dimensions
Pour le moment nous avons vu des tableaux à une seule dimension. Mais il est possible en C de créer des tableaux à deux dimensions, aussi appeler matrice (toute référence à un film américain est à proscrire )
Ce style de tableaux est assez complexe et déroutants pour les débutants cependant leur utilité n’est plus à démontrer et il est probable qu’un jour où l’autre vous en ayez besoin.
Avant de vous montrer la syntaxe d’un tableau à deux dimensions, il me semble essentiel d’en rappeler le principe.
Deux dimensions signifient qu’on a deux entrées dans notre tableau. Ainsi voilà à quoi ressemblerait un tableau de 2 cases sur 2 :
Ainsi la valeur 10 se trouve dans la colonne 1 à la ligne 1 et la valeur 15 dans la colonne 2 à la ligne 1.
En C, on commence d’abord par la colonne puis par la ligne, de plus la premières colonnes se situé aussi à la case 0 et non à 1, ainsi on dira la valeur 10 est dans la colonne 0 à la ligne 0.
Voici donc comment déclarer notre tableau de 2 colonnes sur 2 lignes en C :
Code c:
int tableau[2][2];
Maintenant nous allons initialisée notre tableau avec les valeurs ci-dessus, en commençant donc par remplir chaque colonne une par une.
Code c:
int tableau[2][2] = {{10, 20}, {15, 35}};
On délimite ici chaque colonne par des accolades, ce n’est pas obligatoire mais ça permet de clairement voir ce que l’on fait sans être embrouillé avec les différentes valeurs. On commence donc par la colonne 0 et on rempli chaque ligne de cette colonne, dans l’ordre jusqu’à ce qu’elle soit pleine, ensuite on passe à la colonne suivante.
Voyons comment utiliser nos tableaux dans des fonctions.
4 – Utiliser un tableau à deux dimensions dans une fonction
Envoyer un tableau à deux dimensions à une fonction n’est pas très compliqué, puisqu’on utilise la même syntaxe que pour un tableau à une dimension, si ce n’est qu’on rajoute bien évidemment la deuxième paire de crochets pour signaler qu’on utilisera une matrice.
Contrairement à un tableau à une dimension, il faut écrire la taille de votre tableau à deux dimensions.
Ainsi il faut donc suivre le code suivant :
Code c:
#include <stdio.h>
#include <stdlib.h>
void afficherTableau(int tableau[2][2]);
int main(void)
{
int tableau[2][2] = {{10, 20} , {15, 35}};
afficherTableau(tableau);
return 0;
}
void afficherTableau(int tableau[2][2])
{
/* … */
}
Maintenant si on souhaite récupérer les valeurs du tableau (pour les afficher par exemple, deux boucles for suffisent :
Code c:
#include <stdio.h>
#include <stdlib.h>
void afficherTableau(int tableau[2][2]);
int main(void)
{
int tableau[2][2] = {{10, 20} , {15, 35}};
afficherTableau(tableau);
return EXIT_SUCCESS; /* Equivalent à return 0 sous Windows, permet un code portable */
}
void afficherTableau(int tableau[2][2])
{
int i = 0;
int j = 0;
for (i = 0; i < 2; i++) {
for(j = 0; j < 2; j++) {
printf(« Tableau[%d][%d] = %dn », i, j, tableau[i][j]);
}
}
}
En oubliant pas qu’on lis les valeurs colonnes par colonnes et non pas lignes par lignes ! Ici ce code nous affiche donc :
Code console:
Tableau[0][0] = 10
Tableau[0][1] = 20
Tableau[1][0] = 15
Tableau[1][1] = 35
Voilà vous savez l’essentiel à savoir sur les tableaux. Si vous avez la moindre question n’hésitez pas à la poser sur le forum. Dans le prochain tutoriel nous verrons les types avancées du langage C : structures, typedef, unions et énumérations.