Programmation C++/Les tableaux
Les tableaux à une dimension.
Les tableaux sont des structures de données constituées d'un certain nombre d'éléments de même type. On peut accéder directement à un élément du tableau en indiquant son indice entre crochets (indice de 0 à "nombre_d_éléments"-1).
Les tableaux statiques.
Syntaxe.
 "type identificateur"["taille"];
Sémantique.
codice_1 est un tableau de codice_2 éléments de type codice_3. codice_2 est obligatoirement une valeur constante. La taille du tableau est donc figée une fois pour toute et ne peut pas être modifiée en cours d'exécution.
Pour désigner la i-ième case de tableau, on écrit
 "identificateur"["i"]
où codice_5 est un entier quelconque. Les cases sont numérotées à partir de 0 : les valeurs possibles de i vont donc de codice_6 à codice_7.
Pointeurs et tableaux.
Il existe un lien entre les pointeurs et les tableaux : "identificateur" est en fait un pointeur constant vers un élément de type "type", pointant le premier élément du tableau, en d'autres termes le nom d'un tableau est un pointeur constant sur le premier élément du tableau.
Exemple.
using namespace std;
int main()
 int i;
 int const tailleTableau(10); //taille du tableau
 int tableau[tailleTableau]; //déclaration du tableau
 for (int i(0); i<tailleTableau; i++ )
 tableau[i]=i*i;
 cout«"Le tableau ["«i«"] contient la valeur "«tableau[i]«endl;
 return 0;
Exécution.
Le tableau [0] contient la valeur 0
Le tableau [1] contient la valeur 1
Le tableau [2] contient la valeur 4
Le tableau [3] contient la valeur 9
Le tableau [4] contient la valeur 16
Le tableau [5] contient la valeur 25
Le tableau [6] contient la valeur 36
Le tableau [7] contient la valeur 49
Le tableau [8] contient la valeur 64
Le tableau [9] contient la valeur 81
Les tableaux dynamiques.
Un tableau dynamique est un tableau dont le nombre de cases peut varier au cours de l'exécution du programme. Il permet d'ajuster la taille du tableau au besoin du programmeur.
L'opérateur new.
Syntaxe : 
 "pointeur"=new "type"["taille"];
L'opérateur new[] permet d'allouer une zone mémoire pouvant stocker "taille" éléments de type "type", et retourne l'adresse de cette zone. Le paramètre "taille" est un entier qui peut être quelconque (variable, constante, expression). codice_8 renverra un pointeur vers un "type". La variable "pointeur" est donc du type "type *". Les cases du tableau seront numérotées de 0 à "taille"-1 et on y accédera comme un tableau statique. S'il n'y a pas assez de mémoire disponible, codice_8 renvoie le pointeur codice_10.
L'opérateur codice_11.
Syntaxe : 
 delete[] "pointeur";
Cette utilisation de delete[] permet de détruire un tableau précédemment alloué grâce à new[].
Le programmeur en C++ doit gérer la destruction effective des tableaux qu'il a créé dynamiquement.
Exemple.
using namespace std;
int main()
 int i, taille;
 cout « "Tapez la valeur de taille : ";
 cin » taille;
 int *t;
 t = new int[taille];
 for (i = 0; i < taille; i++)
 t[i] = i * i;
 for (i = 0; i < taille; i++)
 cout « t[i] « endl;
 delete[] t;
 return 0;
Exécution 1.
 Tapez la valeur de taille : 4
 0 
 1 
 4 
 9 
Exécution 2.
 Tapez la valeur de taille : 6
 0
 1
 4
 9
 16
 25
Tableaux multidimensionnels.
Un tableau peut avoir plus d'une dimension (matrice 2D, matrice 3D, ..).
Par contre, on ne peut pas utiliser l'expression suivante pour l'allocation dynamique de tableaux à plusieurs dimensions:
 "pointeur"=new "type"["taille1"]["taille2"]"...";
L'allocation dynamique de tableaux à deux dimensions est expliquée ci-dessous.
Les "vectors".
Les "vectors" (vecteur en français) sont un type de tableaux dynamiques très puissants qui suivent la syntaxe suivante : 
vector<type> nom(taille);
Par exemple, un tableau dynamique constitué de 5 entiers et nommé « tableau_nombre_entiers » sera défini de la sorte :
vector<int> tableau_nombres_entiers(5);
Mais on peut bien sûr définir un tableau qui ne comporte aucune taille, ce qui est bien utile pour un tableau... dynamique !
vector<int> tableau_nombres;
Pour accéder aux valeurs d'un "vector", on procède la même manière que pour tous les tableaux, par exemple :
tableau_nombres_entiers[0] = 0;
tableau_nombres_entiers[1] = 2;
Mais on peut également affecter à tout le "vector" une même valeur en l'indiquant juste après la taille avec une virgule. Exemple :
using namespace std;
vector<int> tableau_nombre_entiers(5, 10); //Ce tableau est composé de 5 nombres entiers qui sont tous égaux à 10
vector<string> tableau_lettres(4, "bonjour !"); //Ce tableau est composé de 4 chaînes de caratères qui sont égales à « bonjour ! »
Cela signifie que "tableau_nombre_entiers[0]=tableau_nombre_entiers[1]=tableau_nombre_entiers[2]=tableau_nombre_entiers[3]=tableau_nombre_entiers[4]=10" ; et de même "tableau_lettres[0]=tableau_lettres[1]=tableau_lettres[2]=tableau_lettres[3]="bonjour !"".
Comme on le sait, les "vectors" sont des tableaux dynamiques, ainsi peuvent-ils s'agrandir ou se rétrécir. Pour ajouter une case supplémentaire au tableau, il suffit de faire appel à la fonction "push_back()" :
vector<int> tableau_entiers;
tableau_entiers.push_back(7); //On ajoute une première case au tableau qui comporte le nombre 7
tableau_entiers.push_back(18); //On ajoute une deuxième case au tableau qui comporte le nombre 18
À l'inverse, pour supprimer une case, on utilise la fonction "pop_back()" :
vector<int> tableau_entiers(10); //Un tableau dynamique d'entiers à 10 cases
tableau_entiers.pop_back(); //Plus que 9 cases
tableau_entiers.pop_back(); //Plus que 8 cases
Enfin, pour récupérer la taille du "vector", on utilise la fonction "size()" :
vector<int> tableau_entiers(5); //Un tableau de 5 entiers
int taille = tableau_entiers.size(); //'taille' a pour valeur 5
Parcours d'un tableau.
Le parcours des éléments d'un tableau se fait généralement avec une boucle codice_12 (on peut aussi utiliser codice_13 ou codice_14).
Exemple :
int nombres[10] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 };
for (int i = 0; i < 10; i++) // i va de 0 à 9 inclus
 cout « "nombres [ " « i « " ] = " « nombres[i] « endl;
Les éléments d'un tableau sont stockés dans des zones contigües.
Il est donc possible d'utiliser un pointeur pour parcourir un tableau :
int nombres[10] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 };
int *p = nombres;
for (int i = 0; i < 10; i++, p++)
 cout « "Nombre : " « *p « endl;
Initialement le pointeur codice_15 pointe le premier élément du tableau.
L'instruction codice_16 dans la boucle codice_12 incrémente le pointeur, c'est-à-dire qu'il passe à l'élément suivant. L'adresse contenue dans le pointeur n'augmente pas de 1, mais de la taille de l'élément pointé (ici codice_18, soit 4 octets en général).
Les tableaux à deux dimensions.
Statiques.
"type identificateur[taille_i][taille_j];"
"identificateur" est un tableau de "taille_i" sur "taille_j" cases. Pour chaque case "i" choisie, il y a "taille_j" cases disponibles.
Les "taille_i" et "taille_j" ne peuvent changer au cours du programme. Pour le faire, il faut utiliser les tableaux dynamiques.
Exemple.
using namespace std;
int main() {
 int t[10][5];
 for (int i = 0; i < 10; i++)
 for (int j = 0; j < 5; j++)
 t[i][j] = i * j;
 for (int i = 0; i < 10; ++i) {
 for (int j = 0; j < 5; ++j){
 cout « t[i][j] « " ";
 cout « endl;

return 0;
Exécution.
 0 0 0 0 0
 0 1 2 3 4
 0 2 4 6 8
 0 3 6 9 12
 0 4 8 12 16
 0 5 10 15 20
 0 6 12 18 24
 0 7 14 21 28
 0 8 16 24 32
 0 9 18 27 36
Dynamiques.
Exemple.
using std::cout;
using std::cin;
int **t;
int nColonnes;
int nLignes;
void Free_Tab(); // Libérer l'espace mémoire;
int main(){
 cout « "Nombre de colonnes : "; cin » nColonnes;
 cout « "Nombre de lignes : "; cin » nLignes;
 /* Allocation dynamique */
 t = new int* [ nLignes ];
 for (int i=0; i < nLignes; i++)
 t[i] = new int[ nColonnes ];
 /* Initialisation */
 for (int i=0; i < nLignes; i++)
 for (int j=0; j < nColonnes; j++)
 t[i][j] = i*j;
 /* Affichage */
 for (int i=0; i < nLignes; i++) {
 for (int j=0; j < nColonnes; j++)
 cout « t[i][j] « " ";
 cout « std::endl;