Blog ENI : Toute la veille numérique !
-25€ dès 75€ sur les livres en ligne, vidéos... avec le code FUSEE25. J'en profite !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Du C au C++
  3. Les tableaux
Extrait - Du C au C++ De la programmation procédurale à l'objet (2ième édition)
Extraits du livre
Du C au C++ De la programmation procédurale à l'objet (2ième édition)
2 avis
Revenir à la page d'achat du livre

Les tableaux

Tableaux statiques

1. Qu’est-ce qu’un tableau ?

Un tableau est un ensemble d’objets de même type : un tableau de int, de float de double, de structure de même type, etc.

Le fait qu’il soit statique signifie qu’il est non dynamique, c’est-à-dire que sa taille est fixe et que son espace mémoire est alloué par la machine à la déclaration.

Chaque élément du tableau est numéroté du premier 0 au dernier qui est le nombre d’éléments dans le tableau moins un. Le numéro d’un élément est appelé son indice. L’indice associé à l’opérateur crochet [ ] va permettre d’accéder à l’élément correspondant.

Par exemple, avoir dans un programme un tableau de 10 entiers, c’est avoir un regroupement de 10 entiers en une seule variable de type tableau de int. Les indices des éléments vont de 0 pour le premier à 9 pour le dernier. Chaque int du tableau a sa propre valeur. Nous pouvons le représenter de la façon suivante :

images/03ri02.png

l’entier n°4 vaut 12, l’entier n°1 vaut 32, l’entier n°8 vaut 123, l’entier n°9 vaut 9, etc.

2. Disposer d’un tableau statique dans un programme

a. Définir et déclarer un tableau

Pour définir et déclarer un tableau dans un programme il faut donner :

  • le type des éléments

  • un nom pour le tableau

  • le nombre des éléments entre crochets

  • un point-virgule

Soit le formalisme :


<type> <nom> <[ constante entière] > < ; >
 

Par exemple :


int tab [10];        // déclaration d'un tableau de 10 int 
float f[90]          // déclaration d'un tableau de 90 float
 

La déclaration peut se faire dans n’importe quel bloc d’instructions du programme et les règles de visibilité sont les mêmes que pour les variables simples.

Attention ! Le nombre des éléments doit toujours être une valeur entière et constante. Cela ne peut pas être une variable. Pour avoir un nombre variable d’éléments, il faut un tableau dynamique, c’est-à-dire utiliser des pointeurs (voir le chapitre Les pointeurs).

b. Utiliser des #define pour les tailles

Il y a trois formes pour une constante entière :...

Exemples d’utilisations de tableaux

1. Chaînes de caractères

Une chaîne de caractères (string en anglais) est une suite de caractères stockée dans un tableau de char et terminée par le caractère ’\0’.

Le ’\0’ marque la fin de la chaîne quelle que soit la taille du tableau mais le nombre total de caractères dans la chaîne ne peut pas dépasser la taille du tableau.

Toutes les fonctions de traitement de chaînes de caractères s’appuient sur le ’\0’ final pour trouver la fin de la chaîne et jamais sur la taille du tableau.

Un tableau de char peut être initialisé à la déclaration avec une chaîne de caractères, soit par exemple la séquence :


char s[100]="bonjour\n"; // 9 caractères dans la chaîne : '\0' implicite 
                         // le reste du tableau n'est pas utilisé 
   printf(s); 
   s[3]='s'; 
   s[5]='i'; 
   printf(s);
 

La chaîne "bonjour\n" est une constante chaîne de caractères (telle quelle, elle n’est pas modifiable). Un ’\0’ est ajouté par la machine à toutes les constantes chaînes de caractères. C’est pourquoi cette chaîne a 9 caractères au total : 7 lettres, 1 retour chariot et le ’\0’ final. Le tableau s est initialisé avec cette chaîne de 9 caractères mais c’est le seul cas où l’utilisation de l’opérateur d’affectation est utilisable en C pour une copie de chaîne de caractères. Sinon pour copier deux chaînes de caractères, il faut utiliser la fonction strcpy().

En cas d’oubli du ’\0’ final le résultat est incertain, le programme plante ou bien il y a un affichage bizarre avec des signes inattendus (ce qui traîne en mémoire avant de tomber sur un ’\0’). Vous pouvez tester par exemple :


char s1[]={'a','b','c','d'}; // manque le '\0' final : 
                             // résultat incertain 
   printf("test sans \\0 : %s\n",s1);
 

Le tableau s1 est un tableau de quatre caractères mais ce n’est pas une chaîne de caractères parce qu’il manque le ’\0’ final.

Il existe de nombreuses...

Tableaux et structures

1. Tableau comme champ dans une structure

Une structure peut contenir des tableaux. L’accès au tableau se fait comme pour n’importe quel autre champ avec l’opérateur point. Soit par exemple la structure test suivante :


typedef struct{ 
    char nom[80]; 
    float calc; 
    int stock[10]; 
}test;
 

Dans le programme suivant, une struct test est initialisée et affichée :


#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
test t1; 
int i; 
 
    strcpy(t1.nom,"Michael"); 
    printf("Nom : %s\n",t1.nom); 
    t1.calc=(float)rand() / RAND_MAX; 
    printf("Calcul : %f\n",t1.calc); 
 
    for (i=0; i<10; i++){ 
       t1.stock[i]=rand()%256; 
       printf("Valeurs %d stockees : %d\n", i, t1.stock[i]; 
    } 
    return 0; 
}
 

On commence par déclarer la structure t1, ensuite :

  • initialisation et affichage du champ nom.

  • initialisation du champ calc avec une valeur flottante aléatoire entre 0 et 1 et affichage de la valeur.

  • initialisation du champ stock, un tableau de 10 entiers avec des valeurs aléatoires et affichage du tableau. Une boucle est utilisée pour accéder aux éléments du tableau.

2. Tableau de structures

On peut avoir un tableau dans une structure et il est possible également d’avoir un tableau de structures. Soit en global la définition et déclaration de la structure suivante :


struct pix{ 
    int x, y, color; 
};
 

Dans un programme, nous déclarons une struct pix et un tableau de trois struct pix. Elles sont ensuite initialisées et affichées, d’abord la structure seule puis le tableau de structures :


#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
struct pix  p, tab[3]; 
int i; 
    // initialisation structure seule 
    p.x=0; 
    p.y=50; 
    p.color=255; 
    // affichage structure seule 
    printf("x=%d,y=%d,color=%d",p.x,p.y,p.color); 
 
    //initialisation du tableau de structures  
    for (i=0; i<3; i++){ 
        tab[i].x=0; 
        tab[i].y=50; 
        tab[i].color=255; 
        //affichage de chaque structure 
        printf("tab[%d].x=%d,y=%d,color=%d", 
             i,tab[i].x,tab[i].y,tab[i].color); 
 
    } 
 ...

Tableaux et fonctions

1. Utiliser un tableau déclaré en global

L’utilisation des tableaux avec des fonctions renvoie à la visibilité (accessibilité) des variables dans un programme : le tableau pourra être déclaré en global avec des fonctions écrites pour lui seul et sans paramètre, mais il pourra aussi être déclaré en local, par exemple dans le main(), avec des fonctions généralisées qui pourront être utilisées avec différents tableaux.

Pour rappel, toutes les variables peuvent être déclarées en local ou en global :

  • Les variables sont dites "locales" à la fonction dans laquelle elles sont déclarées. C’est-à-dire qu’elles sont visibles (accessibles) uniquement dans le bloc de la fonction et dans tous ses sous-blocs imbriqués. Dans ce cas, les valeurs des variables peuvent circuler grâce aux paramètres d’entrée et au mécanisme de retour (return) des fonctions.

  • Mais il est possible de déclarer des variables au niveau fichier en dehors de tout bloc, au-dessus du main(). Dans ce cas, la variable est accessible de tous les blocs et toutes les fonctions dans le fichier, sans avoir à utiliser les paramètres d’entrée ou la valeur de retour.

    La déclaration en global est utilisée pour les définitions de type notamment les structures, pour des valeurs constantes (#define, enum...), pour les déclarations de fonction et pour quelques variables essentielles afin de simplifier l’écriture de petits programmes (moins de 500 lignes de code). En aucun cas cette propriété n’est utilisée si la "globalité" de la variable n’est pas justifiée. Mal utilisée, cette propriété risque de nuire au développement (en général le développement se trouve rapidement paralysé au-delà de 1000 lignes de code).

Le programme suivant illustre comment utiliser cette propriété pour un tableau de données dans un programme :


#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
 
// valeur constante définie en global 
#define NBMAX  50 
 
// tableau déclaré en global...