Comment Ca Marche - Communauté informatique  
   
Accueil - Encyclopédie informatiqueTélécharger l'encyclopédieContribuer à cet article

Langage C - Les tableaux

Tableaux en langage C Encyclopédie


Type de données complexes

Les variables, telles que nous les avons vues, ne permettent de stocker qu'une seule donnée à la fois. Or, pour de nombreuses données, comme cela est souvent le cas, des variables distinctes seraient beaucoup trop lourdes à gérer. Heureusement, le langage C propose des structures de données permettant de stocker l'ensemble de ces données dans une « variable commune ». Ainsi, pour accéder à ces valeurs il suffit de parcourir la variable de type complexe composée de « variables » de type simple.

Le langage C propose deux types de structures :

  • les tableaux, permettant de stocker plusieurs données de même type
  • les structures, pouvant contenir des données hétérogènes

La notion de tableau

On appelle tableau une variable composée de données de même type, stockée de manière contiguë en mémoire (les unes à la suite des autres).

Un tableau est donc une suite de cases (espace mémoire) de même taille. La taille de chacune des cases est conditionnée par le type de donnée que le tableau contient.
Les éléments du tableau peuvent être :

  • des données de type simple : int, char, float, long, double...
    (la taille d'une case du tableau est alors le nombre d'octets sur lequel la donnée est codée)
  • des pointeurs (objets contenant une adresse mémoire. Ce type d'entité sera expliqué dans les chapitres suivants)
  • des tableaux
  • des structures

Voici donc une manière de représenter un tableau :

donnéedonnéedonnée...donnéedonnéedonnée

  • Lorsque le tableau est composé de données de type simple, on parle de tableau monodimensionnel (ou vecteur)
  • Lorsque celui-ci contient lui-même d'autres tableaux on parle alors de tableaux multidimensionnels (aussi matrice ou table)

Les tableaux unidimensionnels

Déclaration

Un tableau unidimensionnel est un tableau qui contient des éléments simples (des éléments qui ne sont pas des tableaux). Un tableau unidimensionnel est donc une suite de « cases » de même taille contenant des éléments d'un type donné (de la longueur de la case en quelque sorte).
Un tableau contenant des entiers peut se représenter de la façon suivante :

intintint...intintint

En langage C, la syntaxe de la définition d'un tableau unidimensionnel est la suivante :

type Nom_du_tableau [Nombre d'éléments]
  • type définit le type d'élément que contient le tableau (rappel : un tableau en langage C est composé uniquement d'éléments de même type), c'est-à-dire qu'il définit la taille d'une case du tableau en mémoire
  • Nom_du_tableau est le nom que l'on décide de donner au tableau, le nom du tableau suit les mêmes règles qu'un nom de variable
  • Nombre d'éléments est un nombre entier qui détermine le nombre de cases que le tableau doit comporter

Voici par exemple la définition d'un tableau qui doit contenir 8 éléments de type char :

char Tableau [8]

Calcul de la taille du tableau

Etant donné qu'un tableau est composé d'un nombre fixé d'éléments d'un type donné, la taille d'un tableau est déterminée dès sa définition.

Pour connaître la taille d'un tableau, c'est-à-dire déterminer le nombre d'octets que celui-ci occupe en mémoire, il y a deux possibilités :

  • Calculer manuellement la taille du tableau : il suffit de multiplier la taille du type d'élément par le nombre d'éléments qui composent le tableau
  • Utiliser l'opérateur sizeof() : l'opérateur sizeof() permet de retourner directement la taille de l'élément qui lui est passé en argument, ainsi en lui passant un tableau comme opérande, sizeof() est capable de vous retourner directement la taille de celui-ci

Voici différents exemples de tableaux, et leurs tailles respectives :

Définition du tableau Taille du tableau (en octets)
char Tableau1[12] 1 * 12 = 12
int Tableau2[10] 2 * 10 = 20
float Tableau3[8] 4 * 8 = 32
double Tableau4[15] 8 * 15 = 120

Accéder aux éléments

Pour accéder à un élément du tableau, le nom que l'on a donné à celui-ci ne suffit pas car il comporte plusieurs éléments. Ainsi, on définit un nombre appelé indice (en anglais index) qui, combiné avec le nom du tableau, permet de décrire exactement chaque élément.

Pour accéder à un élément du tableau, il suffit donc de donner le nom du tableau, suivi de l'indice de l'élément entre crochets :

 Nom_du_tableau[indice]

  • L'indice du premier élément du tableau est 0
  • Un indice est toujours positif
  • L'indice du dernier élément du tableau est égal au nombre d'éléments - 1
Ainsi, on accédera au 5ème élément du tableau en écrivant :

 Nom_du_tableau[4]

Manipuler les éléments

Un élément du tableau (repéré par le nom du tableau et son indice) peut être manipulé exactement comme une variable, on peut donc effectuer des opérations avec (ou sur) des éléments de tableau.

Définissons un tableau de 10 entiers :

 int Toto[10];

Pour affecter la valeur 6 au huitième élément on écrira :

 Toto[7] = 6;

Pour affecter au 10ème élément le résultat de l'addition des éléments 1 et 2, on écrira :

 Toto[9] = Toto[0] + Toto[1];

Initialiser les éléments

Lorsque l'on définit un tableau, les valeurs des éléments qu'il contient ne sont pas définies, il faut donc les initialiser, c'est-à-dire leur affecter une valeur.
Une méthode rustique consiste à affecter des valeurs aux éléments un par un :

 Toto[0] = Toto[1] = Toto[2] = 0;

L'intérêt de l'utilisation d'un tableau est alors bien maigre...

Une manière plus élégante consiste à utiliser le fait que pour passer d'un élément du tableau à l'élément suivant il suffit d'incrémenter son indice. Il est donc possible d'utiliser une boucle qui va permettre d'initialiser successivement chacun des éléments grâce à un compteur qui servira d'indice :

 int Toto[10];

int Indice;

for (Indice = 0; Indice <= 9; Indice++) {
Toto[Indice] = 0;

}

Cette méthode, aussi utile soit elle, n'a d'intérêt que lorsque les éléments du tableau doivent être initialisés à une valeur unique ou une valeur logique (proportionnelle à l'indice par exemple). Pour initialiser un tableau avec des valeurs spécifiques, il est possible d'initialiser le tableau à la définition en plaçant entre accolades les valeurs, séparées par des virgules :

 int Toto[10] = {1, 2, 6, 5, 2, 1, 9, 8, 1, 5};

  • Le nombre de valeurs entre accolades ne doit pas être supérieur au nombre d'éléments du tableau
  • Les valeurs entre accolades doivent être des constantes (l'utilisation de variables provoquera une erreur du compilateur)
  • Si le nombre de valeurs entre accolades est inférieur au nombre d'éléments du tableau, les derniers éléments sont initialisés à 0
  • Il doit y avoir au moins une valeur entre accolades
Ainsi, l'instruction suivante permet d'initialiser tous les éléments du tableau à zéro :

 int Toto[10] = {0};

Il est conseillé d'employer le plus possible des constantes dans vos programmes, notamment pour la taille des tableaux. Le code ci-dessus peut s'écrire ainsi :

#define NB_ELEMENT_TOTO 10
int Toto[NB_ELEMENT_TOTO];
int Indice;
for (Indice = 0; Indice < NB_ELEMENT_TOTO; Indice++) {
Toto[Indice] = 0;
} 

Voici les avantages liés à l'utilisation de constantes :

  • Moins d'erreurs d'exécution dues à un débordement difficile à déceler.
  • Pour modifier la taille du tableau il suffit de changer le define en début du code source.
  • Le code possède une lisibilité accrue.

Les tableaux multidimensionnels

Les tableaux multidimensionnels sont des tableaux qui contiennent des tableaux.

Par exemple le tableau bidimensionnel (3 lignes, 4 colonnes) suivant, est en fait un tableau comportant 3 éléments, chacun d'entre eux étant un tableau de 4 éléments :

       
       
       

est stocké en mémoire de la manière suivante :
    
    
    

Définition

Un tableau multidimensionnel se définit de la manière suivante :

 type Nom_du_tableau [a1][a2][a3] ... [aN]
  • Chaque élément entre crochets désigne le nombre d'éléments dans chaque dimension
  • Le nombre de dimensions n'est pas limité

Un tableau d'entiers positifs à deux dimensions (3 lignes, 4 colonnes) se définira avec la syntaxe suivante :

 int Tableau [3][4]

On peut représenter un tel tableau de la manière suivante :

Tableau[0][0] Tableau[0][1] Tableau[0][2] Tableau[0][3]
Tableau[1][0] Tableau[1][1] Tableau[1][2] Tableau[1][3]
Tableau[2][0] Tableau[2][1] Tableau[2][2] Tableau[2][3]

Il va de soi que cette représentation est arbitraire, car elle suppose que le premier indice est l'indice de ligne, et le second est l'indice de colonne.
On aurait tout aussi bien pu représenter le tableau de la manière suivante :

Tableau[0][0] Tableau[1][0] Tableau[2][0]
Tableau[0][1] Tableau[1][1] Tableau[2][1]
Tableau[0][2] Tableau[1][2] Tableau[2][2]
Tableau[0][3] Tableau[1][3] Tableau[2][3]

On utilise toutefois généralement la première représentation, car elle correspond mieux à la façon selon laquelle le tableau est stocké en mémoire.

Initialiser les éléments

L'initialisation d'un tableau multidimensionnel se fait à peu près de la même façon que pour les tableaux unidimensionnels. Il y a donc plusieurs façons d'initialiser un tableau multidimensionnel :

  • Initialisation individuelle de chaque élément :
    Nom_du_tableau [0][0] = 2;
    
    Nom_du_tableau [0][1] = 3;
    
    ...
  • Initialisation grâce à des boucles :
    Il faut faire des boucles imbriquées correspondant chacune à un indice d'une dimension. Par exemple les éléments de Tableau[3][4] pourront être initialisés à 0 par les instructions suivantes :
    int i,j;
    
    for (i=0; i<=2; i++){
    	for (j=0; j<=3; j++){
    		Tableau[i][j] = 0;
    
    	}
    }
  • Initialisation à la définition :
    type Nom_du_tableau [Taille1][Taille2]...[TailleN] = {a1, a2, ... aN};

    Les valeurs sont attribuées aux éléments successifs en incrémentant d'abord les indices de droite, c'est-à-dire pour un tableau à 2 dimensions : [0][0], [0][1], [0][2] ... puis [1][0] etc.
  • Initialisation grâce à la fonction memset :
    int toto[10];
    /* Met à zéro toute la zone mémoire */
    memset(*toto, 0, sizeof(toto));
    Synopsis de la fonction memset :
    #include <string.h>
    void * memset ( void * buffer, int c, size_t num ); 

Discussions pertinentes trouvées dans le forum

14/11 16h12 html débordement span tableaux HTML débordement de SPAN / tableaux Webmastering 15/11 12h28->Yorgat10
20/04 15h15 tableaux croisés excel tableaux croisés excel Logiciels/Pilotes 15/02 10h34->n28akira4
21/07 09h48 php tableaux [Php] petite question sur les tableaux Webmastering 21/07 13h56->Padoo3
11/01 12h25 xslt boucles tableaux [XSLT] Boucles et tableaux... Webmastering 11/01 18h39->Reivax9622
15/10 11h01 tableaux html Problèmes de tableaux en HTML Internet 15/10 13h47->Alasea1
30/03 10h30 php comparer 2 tableaux [php] comparer 2 tableaux Développement 30/03 10h33->kilian1
19/11 15h43 tableaux tableaux Développement 21/11 22h18->johan21
11/11 22h03 tableaux les tableaux en C Développement 13/11 16h28->lami20j17
15/05 22h32 tableaux pointeurs [C] tableaux de pointeurs Développement 16/05 00h44->Luffy =)14
24/05 21h16 tableaux classes Problème C++ : tableaux et classes Développement 30/05 11h20->Char Snipeur14
Discussion fermée Problème résolu Tableaux C Plus de discussions sur « Tableaux C »

Ce document intitulé « Langage C - Les tableaux » issu de l'encyclopédie informatique Comment Ça Marche (www.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.