Programmation C++/Les tableaux
Un livre de Wikibooks.
Sections |
[modifier] 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).
[modifier] Les tableaux statiques
[modifier] Syntaxe
type identificateur[taille];
[modifier] 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
identificateur[i]
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.
[modifier] 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 element du tableau.
[modifier] Exemple
#include <iostream> using namespace std; int main() { int i; int t[10]; for(i=0 ; i<10 ; i++) t[i] = i * i; for(i=0 ; i<10 ; i++) cout << t[i] << endl; return 0; }
[modifier] Exécution
0 1 4 9 16 25 36 49 64 81
[modifier] 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.
[modifier] 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). new renverra un pointeur vers un type. La variable pointeur est donc du type type *. Les cases du tableaux 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.
[modifier] L'opérateur delete[]
Syntaxe :
delete[] pointeur;
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.
[modifier] Exemple
#include <iostream> 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; }
[modifier] Exécution 1
Tapez la valeur de taille : 4 0
1
4
9
[modifier] Exécution 2
Tapez la valeur de taille : 6 0 1 4 9 16 25
[modifier] 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.
[modifier] Parcours d'un tableau
Le parcours de tous les éléments d'un tableau se fait avec une boucle for. 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 inclu 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 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).
[modifier] Les tableaux à deux dimensions
[modifier] Statiques
- Syntaxe
type identificateur[taille_i][taille_j];
- Sémantique :
identificateur est un tableau de taille_i sur taille_j cases. Pour chaques cases i choisies, il y a taille_j cases disponibles, ce genre de tableau sert bien souvent à la réalisation de carte pour la création de jeux videos en deux dimension. Les taille_i et taille_j ne peuvent changer au cours du programme. Pour le faire, il faut utiliser les tableaux dynamiques.
[modifier] Exemple
#include <iostream> 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; }
[modifier] 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
[modifier] Dynamiques
[modifier] Exemple
#include <iostream> 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 << endl; } Free_Tab(); return 0; } void Free_Tab(){ for(int i=0 ; i < nLignes ; i++) delete[] t[i]; delete[] t; }
[modifier] Exécution 1
Tapez la valeur de taille_i : 3 Tapez la valeur de taille_j : 6 0 0 0 0 0 0 0 1 2 3 4 5 0 2 4 6 8 10
[modifier] Exécution 2
Tapez la valeur de taille_i : 8 Tapez la valeur de taille_j : 2 0 0 0 1 0 2 0 3 0 4 0 5 0 6 0 7
[modifier] Les tableaux de char
Un tableau de caractères constitue une chaîne de caractères. Exemple :
char chaine[20] = "BONJOUR";
La variable chaine peut stocker jusqu'à 20 caractères, et contient les caractères suivants :
'B','O','N','J','O','U','R','\0'
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 à :
char chaine[20] = {'B','O','N','J','O','U','R','\0'};
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 :
char chaine[] = "BONJOUR"; // tableau de 8 caractères
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.
Si votre compilateur supporte Unicode, vous pouvez utiliser des chaînes de wchar_t (16 bits) au lieu de char (8 bits). Dans ce cas, il faut précéder les caractères par L :
wchar_t chaine[20] = L"BONJOUR";
Equivaut à :
wchar_t chaine[20] = {L'B',L'O',L'N',L'J',L'O',L'U',L'R',L'\0'};
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)
Utiliser Unicode peut être une option de compilation (Visual C++). Le type TCHAR est défini par le compilateur comme char ou wchar_t, selon l'option Unicode. Les constantes sont alors à encadrer par la macro _T(x) qui ajoutera L si nécessaire :
TCHAR chaine1[20] = _T("BONJOUR"); TCHAR chaine2[20] = {_T('B'),_T('O'),_T('N'),_T('J'),_T('O'),_T('U'),_T('R'),_T('\0')};
Le nom des fonctions de manipulation commencent par _tcs :
- int _tcslen(const TCHAR* source)
- _tcscpy(TCHAR* dest, const TCHAR* source)
