# Programmation C++/Les tableaux

* Avant-propos
* Introduction
* Compilation
* Un premier programme
* Les commentaires
* Le préprocesseur
* Les types de base et les déclarations
** Exercices
* Les opérations de base
* Les entrées-sorties
* Les pointeurs
** Exercices
* Les références
* Les tableaux
** Exercices
** Exercices sur les tableaux statiques
** Exercice : Tris des tableaux à une dimension
** Solution : Tris des tableaux à une dimension
* Les structures de contrôle
** Exercices
** Exercices if...else et switch
* Les fonctions
** Exercices
* Les structures
** Exercices
* Les classes
** Exercices
** Exercices de développement
* Les espaces de noms
* Les exceptions
* Les templates
** Exercices
* Conventions d'appel
* Les fichiers
* La librairie standard
* Expressions rationnelles
* Interfaces graphiques
* Bibliographie et liens

## Anciennes pages

* Opérateurs
* Héritage
* Polymorphisme
* Avant-propos
* Introduction
* Compilation
* Un premier programme
* Les commentaires
* Le préprocesseur
* Les types de base et les déclarations
** Exercices
* Les opérations de base
* Les entrées-sorties
* Les pointeurs
** Exercices
* Les références
* Les tableaux
** Exercices
** Exercices sur les tableaux statiques
** Exercice : Tris des tableaux à une dimension
** Solution : Tris des tableaux à une dimension
* Les structures de contrôle
** Exercices
** Exercices if...else et switch
* Les fonctions
** Exercices
* Les structures
** Exercices
* Les classes
** Exercices
** Exercices de développement
* Les espaces de noms
* Les exceptions
* Les templates
** Exercices
* Conventions d'appel
* Les fichiers
* La librairie standard
* Expressions rationnelles
* Interfaces graphiques
* Bibliographie et liens

## Anciennes pages

* Opérateurs
* Héritage
* Polymorphisme
[ Modifier le sommaire ]

## 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
#### Sémantique

identificateur est un tableau de taille éléments de type type. taille 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
où i est un entier quelconque. Les cases sont numérotées à partir de 0 : les valeurs possibles de i vont donc de 0 à taille-1.

#### 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
##### 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 :
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). new 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, new renvoie le pointeur NULL.

#### L'opérateur delete

Syntaxe :
Cette utilisation de delete permet de détruire un tableau précédemment alloué grâce à new.
N'oubliez surtout pas les crochets juste après delete, sinon le tableau ne sera pas correctement libéré.
Le programmeur en C++ doit gérer la destruction effective des tableaux qu'il a créé dynamiquement.

#### 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:
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 :
Par exemple, un tableau dynamique constitué de 5 entiers et nommé « tableau_nombre_entiers » sera défini de la sorte :
Mais on peut bien sûr définir un tableau qui ne comporte aucune taille, ce qui est bien utile pour un tableau... dynamique !
Pour accéder aux valeurs d'un vector, on procède la même manière que pour tous les tableaux, par exemple :
Mais on peut également affecter à tout le vector une même valeur en l'indiquant juste après la taille avec une virgule. Exemple :
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 :
À l'inverse, pour supprimer une case, on utilise la fonction pop_back :
Enfin, pour récupérer la taille du vector, on utilise la fonction size :

### Parcours d'un tableau

Le parcours des éléments d'un tableau se fait généralement avec une boucle for (on peut aussi utiliser while ou do...while). Exemple :
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 :
Initialement le pointeur p pointe le premier élément du tableau. L'instruction p++ dans la boucle for 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 int, soit 4 octets en général).

## Les tableaux à deux dimensions
### Statiques

* Syntaxe
type identificateur[taille_i][taille_j];
* Sémantique :
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.

#### Exécution
### Dynamiques
#### Exécution 2
## Les tableaux de caractères

Un tableau de caractères constitue une chaîne de caractères. Exemple avec des caractères de huit bits:

### Les tableaux de char

Un tableau de char constitue une chaîne de caractères. Exemple :
La variable chaine peut stocker jusqu'à 20 caractères, et contient les caractères suivants :
Le dernier caractère est nul pour indiquer la fin de la chaîne de caractères. Il est donc important de prévoir son stockage dans le tableau. Dans cet exemple, 8 caractères sont donc nécessaires.
L'exemple précédent équivaut à :
Si la chaîne est initialisée à la déclaration, on peut également laisser le compilateur détecter le nombre de caractères nécessaires, en omettant la dimension :
Dans ce cas la variable ne pourra stocker que des chaînes de taille inférieure ou égale à celle d'initialisation.
Les fonctions de manipulation de chaîne de caractères sont les mêmes que dans le langage C. Elles portent un nom commençant par str (String) :

#### int strlen(const char* source)

    Retourne la longueur de la chaîne source (sans le caractère nul final).

#### void strcpy(char* dest, const char* source)

    Copie la chaîne source dans le tableau pointé par dest.

### Les tableaux de char16_t and char32_t

À partir de C++11 (C++ norme de 2011) trois types de chaînes de caractères sont prise en charge: UTF-8, UTF-16, et UTF-32. Le type char conserve ses unités de codage de huit bits pour le codage des caractères Unicode via UTF-8, les nouveaux types char16_t et char32_t sont des unités de codage de seize ou trente-deux bits pour le codage des caractères Unicode via UTF-16 ou UTF-32.
Ces types sont standard à partir de C++2011 mais n'existent pas sur des compilateurs plus anciens, ni même sur les compilateur C-2011.
Il est également possible de les initialiser avec des littéraux, selon le cas:

### Les tableaux de wchar_t

Les compilateurs moderne permettent de faire des chaînes de wchar_t (16 bits ou 32 bits) au lieu de char (8 bits). Ceci a été fait pour permettre de représenter une plus grande partie des caractères Unicode, même si on peut représenter l'ensemble de ces caractères en UTF-8.
Dans ce cas, il faut précéder les caractères par L :
Equivaut à :
Les fonctions permettant leur manipulation portent un nom similaire, excepté que str doit être remplacé par wcs (Wide Character String) :
* int wcslen(const wchar_t* source)
* wcscpy(wchar_t* dest, const wchar_t* source)

### Portabilité

Certains environnements de développement (Visual C++ en particulier) considèrent Unicode comme une option de compilation. Cette option de compilation définit alors le type TCHAR comme char (option legacy) ou wchar_t (option unicode), selon l'option Unicode. Les constantes sont alors à encadrer par la macro _T(x) qui ajoutera L si nécessaire :
Le nom des fonctions de manipulation commencent par _tcs :
* int _tcslen(const TCHAR* source)
* _tcscpy(TCHAR* dest, const TCHAR* source)

## Voir aussi

* Exercices
* Exercices sur les tableaux statiques