Les tableaux sont un ensemble de variables regroupées dans une même entité.
Ainsi une chaîne de caractères « abcd » n’est qu’une liste de caractères : le premier vaut « a », le second vaut « b » …
Mais attention, la première case d’une liste est numérotée n°0 et non n°1. Du coup, il y a un décalage de un par rapport à la logique humaine de base où on nomme la première case la case n°1.
Mais, on peut également créer une liste contenant les nombres 12, 45, 41 et –12.
Pour le cas "AbcD" :
| Case | contient |
|---|---|
| [0] | A |
| [1] | b |
| [2] | c |
| [3] | D |
Pour le cas 12, 45, 41 et –12 :
| Case | contient |
|---|---|
| [0] | 12 |
| [1] | 45 |
| [2] | 41 |
| [3] | -12 |
Un tableau doit par contre contenir le même type de variables dans toutes ses cases.
#include <iostream>
using namespace std;
int main()
{
int nombresPremiers[5]; //Déclare un tableau de 5 int : de [0] à [4]
nombresPremiers[0]=2;
nombresPremiers[1]=3;
nombresPremiers[2]=5;
nombresPremiers[3]=7;
nombresPremiers[4]=11;
string nPremiers[5]; //Déclare un tableau de 5 string : de [0] à [4]
nPremiers[0]="Deux";
nPremiers[1]="Trois";
nPremiers[2]="Cinq";
nPremiers[3]="Sept";
nPremiers[4]="Onze";
cout << nPremiers[2];
return 0;
}
Que fait ce programme ? Rien. Enfin, pas exactement.
Premièrement, il crée un tableau d’integers pouvant contenir 5 éléments et affecte une valeur dans chaque case.
Attention néanmoins, les cases sont numérotées de 0 à 4, pas de 1 à 5. Mais il y en a cinq : 0 1 2 3 et 4.
Ensuite, il crée un tableau de string pouvant contenir 5 éléments et affecte une valeur dans chaque case.
On notera que les cases du tableau sont définies par les crochets [ et ].
01° Lancer le programme ci-dessous. Ensuite, tenter d’afficher le contenu de toutes les cases des deux tableaux en utilisant une boucle for (on sait ici que les tableaux ne possèdent que 5 cases, numérotées de 0 à 4).
for (int i(0); i<5; ++i) // i va donc prendre les valeurs 0,1,2,3 et 4
{
cout << monTableau[i] << endl;
}
02° A la suite des actions précédentes, demander de rentrer un numéro de case compris entre 0 et 4 et afficher le contenu de la case n°X de la liste. Pensez à tester le contenu de la variable qui doit contenir le numéro de la case, sinon ça peut être fâcheux… Revoyez le chapitre sur les tests logiques pour cela.
Remarque : la taille du tableau est à imposer dès le début. On ne peut pas paramétrer cette taille. Si on se rend compte qu’en fin de compte, on aura voulu 300 cases plutôt que 5, il faut changer les dimensions de tous les tableaux du programme. En espérant ne pas en avoir oublier un seul !
On peut heureusement faire un peu mieux : on peut définir une constante (c’est une variable dont on ne peut pas changer la valeur une fois la première affectation effectuée) et utiliser cette constante pour définir la taille de tous les tableaux dont vous voulez garantir une taille fixe.
Remarque : les constantes sont haituellement notées uniquement en majuscules. C'est une convention d'écriture, pas une obligation. Pour vous le montrer, j'alternerai entre les deux façons de les noter. Dans les chapitres suivants, nous passerons au tout majuscule.
Elle se déclare comme une variable normale mais on utilise le mot-clé const :
int tailleVoulue = 5 ; # déclare une variable de type integer qui contient 5 pour l’instant
int const TAILLE_VOULUE = 5 ; # déclare une constante de type integer qui contiendra toujours 5
03° Changer le programme pour pouvoir déclarer la taille du tableau par une constante et afficher le contenu de nombresPremier[6] (17 pour ceux qui ne suivent pas).
04° Modifier la constante de taille pour qu’elle soit de 100 cases. Afficher les contenus. Les cases non affectées sont-elles réellement vides ?
05° TP : Créer un programme qui permet de stocker les notes d’un élève dans deux tableaux : le tableau des notes et le tableau des coefficients des matières. Réaliser une affectation quelconque des notes. Le programme devra pouvoir afficher : la plus grande note, la plus basse note, la moyenne sans coefficient des matières, la moyenne avec coefficient des matières.
Le problème fondamental des tableaux en C est leur état statique. La taille est fixée et le contenu imposé par la déclaration.
Il existe en réalité un type particulier de tableau pouvant évoluer : les tableaux dynamiques. En effet, on ne peut pas toujours savoir à l’avance le nombre de clients connectés en même temps par exemple. On pourrait créer un immense tableau contenant un nombre incroyable de cases mais cela risque de ralentir le systême pour rien s’ils ne sont que 10. Dans ce cas, le tableau dynamique est la solution. On les nomme également VECTORS.
Nous allons d’abord devoir inclure une bibliothèque : #include <vector> car elle n’est pas chargée de base.
Déclarer un tableau dynamique est légèrement différent de la déclaration d’un tableau statique.
Pour déclarer un tableau statique :
int const tailleVoulue = 5 ;
int nombresPremiers[tailleVoulue]; //Déclare un tableau de tailleVoulue int
Pour déclarer un tableau dynamique :
#include <vector> //à ne pas oublier avant la fonction main() puis
vector<int> tableau(5); // à l’endroit habituel pour vos déclarations
On voit donc que la déclaration d’un vector / tableau dynamique est assez différente de la déclaration classique d’une variable. On notera aussi l’usage des (5) pour donner la taille initiale plutôt que [5] dans le cas du tableau classique : pensez donc bien à utiliser des parenthèses ( ) et pas des crochets [ ] comme pour un tableau statique.
06° Tester le programme suivant qui vous montre comment on déclare un tableau dynamique :
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> notes(3);
// Déclaration des notes
notes[0]=10;
notes[1]=15;
notes[2]=8;
cout <<"CONTENU INITIAL DU TABLEAU DE NOTES\n";
cout << "qui compte " << notes.size()<<" notes.\n";
for (int i(0) ; i < notes.size() ; i++)
{
cout <<"Case numero " <<i <<" contient " << notes[i]<<".\n";
}
return 0;
}
07° A quoi sert visiblement size() lorsqu’on tente de comprendre le code ?
Et maintenant, deux autres fonctions pratiques sur ce type de tableau :
monTableau.push_back(8); // qui permet de créer une nouvelle case et d’y stocker 8.
monTableau.pop_back(); // qui supprime la dernière case du tableau.
08° Demander vous ce que va afficher le code suivant dans lequel j’ai inséré les trois lignes surlignées. Lancer pour vérifier.
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> notes(3);
// Déclaration des notes
notes[0]=10;
notes[1]=15;
notes[2]=8;
notes.push_back(18);
notes.push_back(20);
notes.pop_back();
cout <<"CONTENU INITIAL DU TABLEAU DE NOTES\n";
cout << "qui compte " << notes.size()<<" notes.\n";
for (int i(0) ; i < notes.size() ; i++)
{
cout <<"Case numero " <<i <<" contient " << notes[i]<<".\n";
}
return 0;
}
Il nous reste à voir les tableaux en deux dimensions par exemple. Exemple de déclaration :
int const TAILLE_Y(3);
int const TAILLE_X(5);
int tableau[TAILLE_Y][TAILLE_X];
X correspond à la largeur du tableau et Y correspond à sa hauteur.
Pour se donner une idée du tableau précédent :
| Axe X | |||||
|---|---|---|---|---|---|
| Axe Y | [0] [0] | [0] [1] | [0] [2] | [0] [3] | [0] [4] |
| [1] [0] | [1] [1] | [1] [2] | [1] [3] | [1] [4] | |
| [2] [0] | [2] [1] | [2] [2] | [2] [3] | [2] [4] |
09° Créer un programme qui affiche le contenu d’une grille 3x3 contenant :
| Axe X | |||
|---|---|---|---|
| Axe Y | [0] [0] = 0 | [0] [1] = 1 | [0] [2] = 3 |
| [1] [0] = 3 | [1] [1] = 4 | [1] [2] = 5 | |
| [2] [0] = 6 | [2] [1] = 7 | [2] [2] = 8 |
10° Permettre de modifier le contenu d’une des cases et d’afficher la nouvelle grille. Pendant aux tabulations (« \t ») pour parvenir à afficher correctement les modifications si le nombre dépasse 9.
11° Créer une boucle qui demande de rentrer le contenu d’une case jusqu’à ce que trois cases horizontales soient remplies par ‘X’ ou que l’utilisateur tape « Q » pour quitter. On ne fera pas de tests sur la validité des valeurs car cela prendrait trop de lignes de codes. Nous verrons à l’étape suivante (les fonctions) comment réaliser ces tests facilement sans recopier trop de lignes de codes identiques.
Il y a encore beaucoup à dire mais pour l'instant, c'est suffisant. Des informations supplémentaires seront ajoutées plus tard.