Chapitre 3 : Tableaux

Chapitre 3 : Tableaux



A) Tableaux à un seul indice :



1) 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 ...)


2) Déclaration :



2.a) Façon directe :


int age[15] ;

float taille[25], poids[70] ;

age est un tableau de 15 entiers. age[0], age[1], ...,
A[14] sont 15 éléments du tableau age. Chacun est de
type entier.

taille est un tableau de 25 réels. Ses éléments sont
taille[0], taille[1], ..., taille[24].

etc ...

La façon de déclarer directement les tableaux est simple.


2.b) Façon structurée :


Déclarer les tableaux age, taille, poids, sexe d'un groupe
de 150 personnes ou moins.

1. Style de C :

#define MAX_PERS 150

int age[MAX_PERS] ;
float taille[MAX_PERS], poids[MAX_PERS] ;
char sexe[MAX_PERS] ;
int nbPers ; /* le nombre effectif de personnes traitées */
2. Style en PASCAL (avec typedef : définition de type)

La déclaration typedef permet de créer des synonymes et
de les employer dans d'autres déclarations. Cette technique
est utilisée pour clarifier un programme:

typedef int Entier ; /* Entier est synonyme à int */
typedef char * Chaine ; /* Chaine est synonyme à char* */

Avec : typedef int TabEntier[MAX_PERS] ;
TabEntier est le nom du type tableau de 150 entiers.

Les déclarations des tableaux peuvent se faire comme suit :

#define MAX_PERS 150

typedef int TabEntier[MAX_PERS] ;
typedef float TabReel [MAX_PERS] ;
typedef char TabCar[MAX_PERS] ;

TabEntier age ; /* tableau d'entiers */
TabReel taille, poids ; /* tableau des réels */
TabCar sexe ; /* tableau des caractères */

3. Style de C++ (utilisation de const à la place de #define)
(Ce n'est plus une matière du IFT 1160)

const int MAX_PERS = 150;

float taille[MAX_PERS], poids[MAX_PERS]; /* non valide en */
char sexe[MAX_PERS]; /* C standard */
etc ...


3) Schéma d'un tableau :


On représente un tableau comme une commode à plusieurs tiroirs
dont chaque tiroir contient un seul objet de même type :


+---------------+
age[0] | 45 |
+---------------+
age[1] | 20 |
+---------------+
age[2] | 27 |
+---------------+
age[3] | 49 |
+---------------+
...... | ... |
+---------------+
...... | .... |
+---------------+
age[14] | 21 |



4) Manipulations d'un tableau :


1. On crée souvent des tableaux en lisant un ou plusieurs
fichiers de données. La boucle while est fréquente :

Exemple :
......

int n = 0 ; /* compteur */

while ( !feof(donnees) ) {

fscanf(donnees,"%f\n", &taille[n]) ;

n++ ;
}
fclose (donnees);


2. On parcoure les indices d'un tableau avec la boucle for.
notez que le premier indice est zéro :


for ( i = 0 ; i < nbElement ; i++ ) .....

3. Sur l'en-tête des fonctions, on n'a pas besoin de
mentionner les bornes des tableaux à un seul indice :

float moyenne ( float t[], int n )
/* Cette fonction calcule et retourne la valeur
moyenne d'un tableau t qui contient n réels */

......

void trier ( int age[], float taille[], int nbPers)


4. Le nom d'un tableau n'est pas du tout une variable. C'est
une constante de type pointeur : c'est l'adresse de son
premier élément indice 0.

float taille[10] ;

taille est équivalent à &taille[0]

Ainsi taille = ..... ; est toujours invalide
(on affecte à une variable, pas à une constante).


5. En C, on peut déclarer et initialiser un tableau :

#define NB_NOTES 7

float bareme[NB_NOTES] = { 100.0, 100.0, 25.0, 35.0, 40.0,
100.0, 100.0 } ;

Ainsi, bareme[0] vaut 100.0 (on corrige l'intra sur 100)
bareme[1] vaut 100.0 (on corrige le final sur 100)
bareme[2] vaut 25.0 (on corrige le TP1 sur 25)
etc ....

6. En C, si t est le nom d'un tableau, on a :

t + i &t[i]
* (t + i) t[i]

7. On peut utiliser des pointeurs pour manipuler un tableau.
Cependant, il est souhaitable d'être d'abord capable de
manipuler les indices avant d'utiliser des pointeurs qui,
eux provoquent souvent des erreurs si on ne maîtrise pas
bien le concept des pointeurs.

Exemples : Écrire une fonction qui affiche le contenu du
tableau des tailles à l'écran :

a. avec les indices (plus simples à comprendre)

void afficher ( float taille[], int nbPers )
{ int i ;

for ( i = 0 ; i < nbPers ; i++ )
printf("%3d) %8.2f\n", i, taille[i]) ;
}

b. avec un pointeur (un peu plus compliqué)


void afficher ( float * P, int nbPers )
{ int i ;

for ( i = 0 ; i < nbPers ; i++ )
printf("%3d) %8.2f\n", i, *(P+i) ) ;
}

OU (encore plus compliqué) :

void afficher ( float * P, int nbPers )
{ int i ;

while ( i < nbPers )
printf("%3d) %8.2f\n", i++, *P++ ) ;
}

L'utilisation de pointeur est plus fréquente dans le
traitement des chaînes de caractères (sous forme tableau des
caractères ou pointeur vers le type caractère).


5) Exemples et exercices :


Exemple 1 : création des tableaux et calculs des statistiques :

On dispose du fichier texte "Mesures.Dta". Chaque ligne de ce
fichier contient les informations d'une seule personne: sa
taille et son poids.

On a 20 personnes ou moins dans le fichier.

Écrire un programme utilisant des tableaux et des fonctions pour
calculer et afficher les statistiques suivantes :

Pour 17 personnes lues dans le fichier:

1. La taille
- moyenne : 1.68 mètre
- la plus grande : 1.83 mètre
- la plus petite : 1.43 mètre


2. Le poids
- moyen : 61.69 kgs
- le plus lourd : 86.20 kgs
- le plus léger : 42.50 kgs


Solution :


/* Fichier Tableau1.C
Matière principale : tableaux à un seul indice

Données : "Mesures.Dta" (une taille et un poids par ligne)
1.63 54.9
1.57 56.3
1.73 63.0
etc ...
*/

#include

#define MAX_PERS 20 */ 20 personnes ou moins dans le fichier */

void creer ( float taille[], float poids[], int * P )
{
FILE * aLire = fopen("Mesures.Dta", "r");
int n = 0 ;
while ( !feof(aLire) ) {
fscanf(aLire, "%f%f\n", &taille[n], &poids[n]);
n++;
}
fclose (aLire);
*P = n ;
}
/* Cette fonction permet de calculer la valeur moyenne
/ d'un tableau t qui contient exactement n réels. */

float moyenne ( float t [], int n )
{
float somme = 0.0 ;

int i ;

for ( i = 0 ; i < n ; i++ ) somme += t[i];

return somme / n ;
}

/* Cette fonction détermine la plus grande et la plus
petite valeur dans un tableau T de N réels. */

void determiner ( float t[], int n, float * PG, float * PP )
{
float plusGrande = t[0] ,
plusPetite = t[0] ;

int i ;

for ( i = 1 ; i < n ; i++ ) {

if ( t[i] > plusGrande ) plusGrande = t[i] ;
if ( t[i] < plusPetite ) plusPetite = t[i] ;
}

*PG = plusGrande ;
*PP = plusPetite ;
}

void main()
{
float taille [MAX_PERS],
poids [MAX_PERS] ;
int nbPers ;

float grandeTaille, petiteTaille,
lourdPoids , legerPoids ;

creer (taille, poids, &nbPers) ;

printf("Pour %d personnes lues dans le fichier: ", nbPers);

determiner (taille, nbPers, &grandeTaille, &petiteTaille);

printf(" 1. La taille\n");

printf(" - moyenne : %6.2f mètre\n",