Tableaux en C++ | Déclarer | Initialiser | Pointeur vers des exemples de tableaux

Qu'est-ce qu'un tableau ?

Un tableau est une structure de données qui stocke séquentiellement un élément du même type de données. Un tableau C++ a une taille fixe.

Vous pouvez voir un tableau comme une collection de variables d'un type de données similaire. Au lieu de déclarer chaque variable et de lui attribuer une valeur individuellement, vous pouvez déclarer une variable (le tableau) et y ajouter les valeurs des différentes variables. Chaque valeur ajoutée au tableau est identifiée par un index.

Dans ce didacticiel C++, vous apprendrez :

• Qu'est-ce qu'un tableau ?
• Pourquoi avons-nous besoin de tableaux ?
• Déclarer un tableau en C++
• Initialisation du tableau
• Types de tableaux
• Tableau unidimensionnel
• Tableau multidimensionnel
• Tableau bidimensionnel
• Tableau tridimensionnel
• Pointeur vers un tableau
• Accéder aux valeurs d'un Array
• Avantages d'un tableau en C++
• Inconvénients d'un tableau en C++

Pourquoi avons-nous besoin de tableaux ?

Les tableaux sont très importants dans tout langage de programmation. Ils offrent un moyen plus pratique de stocker ensemble des variables ou une collection de données d'un type de données similaire au lieu de les stocker séparément. Chaque valeur du tableau sera accessible séparément.

Déclarer un tableau en C++

La déclaration de tableau en C++ implique d'indiquer le type ainsi que le nombre d'éléments à stocker par le tableau. Syntaxe :

type array-Name [ array-Size ];

Règles de déclaration d'un tableau à une dimension en C++.

• Tapez : Le type est le type des éléments à stocker dans le tableau, et il doit s'agir d'un type de données C++ valide.
• Nom de la baie : Le array-Name est le nom à attribuer au tableau.
• Taille du tableau : Le array-Size est le nombre d'éléments à stocker dans le tableau. Il doit être un entier et supérieur à 0.

Par exemple, vous pouvez créer un tableau nommé age et stocker les âges de 5 élèves comme suit :

int age[5];

Le tableau age stockera 5 nombres entiers représentant les âges des différents élèves.

Initialisation du tableau

L'initialisation d'un tableau est le processus d'assignation/de stockage d'éléments dans un tableau. L'initialisation peut se faire en une seule instruction ou une par une. Notez que le premier élément d'un tableau est stocké à l'index 0, tandis que le dernier élément est stocké à l'index n-1, où n est le nombre total d'éléments dans le tableau.

Dans le cas du tableau age, le premier élément sera stocké à l'index 0, tandis que le dernier élément sera stocké à l'index 4.

Utilisons le tableau d'âge pour montrer comment l'initialisation du tableau peut être effectuée :

int age[5] = {19, 18, 21, 20, 17};

Le nombre total d'éléments dans le { } ne peut pas dépasser la valeur indiquée dans le [ ]. L'élément 19 est à l'index 0, 18 à l'index 1, 21 à l'index 2, 20 à l'index 3 et 17 à l'index 4. Si vous n'indiquez pas le nombre d'éléments à stocker dans le tableau entre [ ], le tableau sera seulement assez grand pour contenir les éléments ajoutés dans { }. Par exemple :

int age[] = {19, 18, 21, 20, 17};

L'instruction ci-dessus créera exactement le même tableau que la précédente. Vous pouvez également affecter un élément à un tableau en utilisant son index. Par exemple :

age[3] = 20;

L'instruction ci-dessus stockera la valeur 20 à l'index 3 du tableau nommé age. Cela signifie que 20 sera le 4 ^ème élément du tableau.

Types de tableaux

Il existe deux types de tableaux C++ :

• Tableau unidimensionnel
• Tableau multidimensionnel
• Pointeur vers un tableau

Tableau unidimensionnel

Il s'agit d'un tableau dans lequel les éléments de données sont disposés linéairement dans une seule dimension. Il est communément appelé tableau 1-D. Syntaxe :

datatype array-name[size];

• Le tableau-nom est le nom du tableau.
• La taille est le nombre d'éléments à stocker dans le tableau.

Par exemple :

#include <iostream>
using namespace std;

int main()
{
	int age[5] = { 19, 18, 21, 20, 17 };
	for (int x = 0; x < 5; x++)
	{
		cout <<age[x]<<"\n";
	}
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Inclure le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Inclure l'espace de noms std afin d'utiliser ses classes et fonctions sans l'appeler.
3. Appeler la fonction main() à l'intérieur de laquelle la logique du programme doit être ajoutée.
4. Début du corps de la fonction main().
5. Déclarer un tableau nommé age pour stocker 5 entiers. Les 5 entiers ont également été initialisés.
6. Créez une variable entière x à l'aide d'une boucle for.
7. Le début du corps de la boucle for.
8. Utiliser la variable de boucle x pour itérer sur les valeurs du tableau age et les imprimer sur la console. Le "\n" est un caractère de nouvelle ligne et s'imprime dans une nouvelle ligne après chaque itération.
9. Fin du corps de la boucle for a.
10. Fin du corps de la fonction main().

Tableau multidimensionnel

Il s'agit d'un tableau dans lequel les éléments de données sont agencés pour former un tableau de tableaux. Un tableau multidimensionnel peut avoir n'importe quel nombre de dimensions, mais les tableaux bidimensionnels et tridimensionnels sont courants. Syntaxe :

datatype array-name[d1][d2][d3]...[dn];

Le nom-tableau est le nom du tableau qui aura n dimensions. Par exemple :

Tableau bidimensionnel

Un tableau 2D stocke les données dans une liste avec un tableau 1-D. C'est une matrice avec des lignes et des colonnes. Pour déclarer un tableau 2D, utilisez la syntaxe suivante :

type array-Name [ x ][ y ];

Le type doit être un type de données C++ valide. Voir un tableau 2D comme un tableau, où x désigne le nombre de lignes tandis que y désigne le nombre de colonnes. Cela signifie que vous identifiez chaque élément dans un tableau 2D en utilisant la forme a[x][y], où x est le nombre de lignes et y le nombre de colonnes auxquelles appartient l'élément.

Voici un exemple d'initialisation d'un tableau 2D :

int a[2][3] = {  
   {0, 2, 1} ,   /*  row at index 0 */
   {4, 3, 7} ,   /*  row at index 1 */
   };

Dans l'exemple ci-dessus, nous avons un tableau 2D qui peut être vu comme une matrice 2 × 3. Il y a 2 lignes et 3 colonnes. L'élément 0 est accessible sous la forme a[0][1] car il est situé à l'intersection de la ligne indexée 0 et de la colonne indexée 1. L'élément 3 est accessible sous la forme a[1][2] car il est situé à la intersection de la ligne indexée 1 et de la colonne indexée 2.

Notez que nous avons simplement ajouté des accolades pour différencier les différentes rangées d'éléments. L'initialisation aurait également pu se faire comme suit :

int a[2][3] = {0, 2, 1, 4, 3, 7};
   };

L'exemple C++ suivant montre comment initialiser et traverser un tableau 2D :

#include <iostream>
using namespace std;
int main() 
{
	// a 2x3 array
	int a[3][2] = { {0, 2}, {1, 4}, {3, 7} };

	// traverse array elements

	for (int i=0; i<3; i++)
		for (int j=0; j<2; j++) 
		
		{
			cout << "a[" <<i<< "][" <<j<< "]: ";
			cout << a[i][j] << endl;
		}
	return 0;
}

Sortie :

Voici une capture d'écran du code ci-dessus :

Explication du code :

1. Inclure le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Inclure l'espace de noms std afin d'utiliser ses classes et fonctions sans l'appeler.
3. Appeler la fonction main() dans laquelle le code doit être ajouté.
4. Début du corps de la fonction main().
5. Un commentaire. Le compilateur C++ ignorera cela.
6. Déclarer un tableau 2D de 3 lignes et 2 colonnes. Des éléments ont également été ajoutés au tableau.
7. Un commentaire. Le compilateur C++ ignorera cela.
8. Créer une variable i en utilisant une boucle for a. Cette variable itérera sur les index de ligne du tableau.
9. Créer une variable j en utilisant une boucle for a. Cette variable itérera sur les index de colonne du tableau.
10. Début du corps des boucles.
11. Imprimez les valeurs des variables i et j sur la console entre crochets sur la console.
12. Imprime la valeur stockée à l'index [i][j] du tableau a.
13. Fin du corps des boucles.
14. La fonction main() doit renvoyer une valeur entière si le programme fonctionne correctement.
15. Fin du corps de la fonction main().

Tableau tridimensionnel

Un tableau 3D est un tableau de tableaux. Chaque élément d'un tableau 3D est identifié par un ensemble de 3 index. Pour accéder aux éléments d'un tableau 3D, on utilise trois boucles for. Par exemple :

#include<iostream>
using namespace std;
void main()
{
	int a[2][3][2] = {{{4, 8},{2, 4},{1, 6}}, {{3, 6},{5, 4},{9, 3}}};
	cout << "a[0][1][0] = " << a[0][1][0] << "\n";
	cout << "a[0][1][1] = " << a[0][1][1] << "\n";
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Inclure le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Inclure l'espace de noms std afin d'utiliser ses classes et fonctions sans l'appeler.
3. Appeler la fonction main() à l'intérieur de laquelle la logique du programme doit être ajoutée.
4. Début du corps de la fonction main().
5. Déclarer un tableau 3D nommé an de taille 2x3x2. Les valeurs du tableau ont également été initialisées.
6. Accéder à l'élément stocké à l'index [0][1][0] du tableau et l'imprimer sur la console.
7. Accéder à l'élément stocké à l'index [0][1][1] du tableau et l'imprimer sur la console.
8. Fin du corps de la fonction main().

Pointeur vers un tableau

Un pointeur est une variable qui contient une adresse. Outre l'utilisation d'un pointeur pour stocker l'adresse d'une variable, nous pouvons l'utiliser pour stocker l'adresse d'une cellule de tableau. Le nom d'un tableau pointe constamment vers son premier élément. Considérez la déclaration ci-dessous :

int age[5];

L'âge est un pointeur vers $age[0], l'adresse du premier élément d'un tableau nommé age. Prenons l'exemple suivant :

#include <iostream>
using namespace std;
int main()
{
	int *john;

	int age[5] = { 19, 18, 21, 20, 17 };

	john = age;

	cout << john << "\n";

	cout << *john;
	
}

Sortie :

Notez que la première valeur de la sortie ci-dessus peut renvoyer une valeur différente en fonction de l'adresse attribuée au premier élément du tableau dans la mémoire de votre ordinateur.

Voici une capture d'écran du code :

Explication du code :

1. Inclure le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Inclure l'espace de noms std afin d'utiliser ses classes et fonctions sans l'appeler.
3. Appeler la fonction main() à l'intérieur de laquelle la logique du programme doit être ajoutée.
4. Début du corps de la fonction main().
5. Déclarer une variable de pointeur nommée *john.
6. Déclarer un tableau d'entiers nommé age pour stocker 5 entiers. Les valeurs des entiers ont également été initialisées.
7. Attribuer à la variable john la valeur de l'adresse de l'item stocké dans le premier index du tableau age.
8. Imprimer la valeur de la variable john, qui est l'adresse de l'élément stocké dans le premier index du tableau age.
9. Imprimer la première valeur stockée dans le tableau age.
10. Fin du corps de la fonction main().

Les noms de tableaux peuvent être utilisés comme pointeurs constants, et l'inverse est également vrai. Cela signifie que vous pouvez accéder à la valeur stockée à l'index 3 du tableau age avec *(age + 3). Par exemple :

#include <iostream>
using namespace std;

int main() {
	// an array of 5 elements.
	int age[5] = { 19, 18, 21, 20, 17 };
	int *p;

	p = age;

	// output array values

	cout << "Using pointer: " << endl;

	for (int x=0; x<5; x++) {
		cout << "*(p + " << x << ") : ";
		cout << *(p + x) << endl;
	}
	cout << "Using age as address: " << endl;

	for (int x = 0; x < 5; x++) {
		cout << "*(age + " << x << ") : ";
		cout << *(age + x) << endl;
	}

	return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Inclure le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Inclure l'espace de noms std afin d'utiliser ses classes et fonctions sans l'appeler.
3. Appel de la fonction main() et début du corps de la fonction main().
4. Un commentaire. Le compilateur C++ ignorera cela.
5. Déclarer un tableau nommé age pour stocker 5 entiers.
6. Création d'un pointeur entier p.
7. Attribuer à p la valeur de l'adresse du premier élément du tableau age.
8. Un commentaire. Le compilateur C++ ignorera cela.
9. Imprimez du texte sur la console.
10. Créer un entier x en utilisant une boucle for a. Le { marque le début du corps de la boucle for a.
11. Imprimez les valeurs de x combinées avec un autre texte sur la console.
12. Imprimez les valeurs de *(p + x) sur la console.
13. Fin du corps de la boucle for a.
14. Imprimez du texte sur la console.
15. Créez une variable x en utilisant une boucle for a. Le { marque le début du corps de la boucle for.
16. Imprimez les valeurs de x de 0 à 4 à côté d'un autre texte.
17. Imprimez les valeurs de *(age + x).
18. Fin du corps de la boucle for.
19. Valeur de retour si le programme s'exécute avec succès.
20. Fin du corps de la fonction main().

Accéder aux valeurs d'un Array

Les éléments d'un tableau sont accessibles à l'aide de leurs index respectifs. L'index de l'élément auquel accéder est ajouté entre crochets [ ] immédiatement après le nom du tableau. Par exemple :

int john = age[2];

Dans l'exemple ci-dessus, nous indiquons simplement que l'âge de john est stocké à l'index 2 du tableau nommé age. Cela signifie que l'âge de Jean est le 3 ^ème valeur dans le tableau age. Voici un exemple C++ complet qui montre comment accéder à cette valeur et l'imprimer :

#include<iostream>

using namespace std;

int main()
{

	int age[5] = { 19, 18, 21, 20, 17 };

	int john = age[2];

	cout << "The age of John is:"<<john;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Inclure le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Inclure l'espace de noms std afin d'utiliser ses classes et fonctions sans l'appeler.
3. Appeler la fonction main() dans laquelle le code doit être ajouté.
4. Début d'un corps de la fonction main().
5. Déclarer un tableau nommé age pour stocker 5 éléments entiers.
6. Accéder à la valeur stockée à l'index 2 du tableau age et stocker sa valeur dans une variable nommée john.
7. Imprimer la valeur de la variable john sur la console à côté d'un autre texte.

Avantages d'un tableau en C++

Voici les avantages/avantages de l'utilisation de Array en C++ :

• Les éléments du tableau peuvent être traversés facilement.
• Facile à manipuler les données du tableau.
• Les éléments du tableau sont accessibles de manière aléatoire.
• Les tableaux facilitent l'optimisation du code ; par conséquent, nous pouvons effectuer beaucoup de travail en utilisant moins de code.
• Facile à trier les données du tableau.

Inconvénients d'un tableau en C++

• Un tableau a une taille fixe ; par conséquent, nous ne pouvons pas lui ajouter de nouveaux éléments après l'initialisation.
• Allouer plus de mémoire que nécessaire entraîne un gaspillage d'espace mémoire, et moins d'allocation de mémoire peut créer un problème.
• Le nombre d'éléments à stocker dans un tableau doit être connu à l'avance.

Résumé

• Un tableau est une structure de données qui stocke des éléments du même type de données.
• Les éléments du tableau sont stockés séquentiellement.
• Les éléments du tableau sont indiqués à l'aide de leurs index respectifs. Le premier élément est à l'indice 0, tandis que le dernier élément est à l'indice n-1, où est le nombre total d'éléments du tableau.
• La déclaration d'un tableau implique de définir les types de données des éléments du tableau ainsi que le nombre d'éléments à stocker dans le tableau.
• Un tableau unidimensionnel stocke les éléments de manière séquentielle.
• Un tableau à deux dimensions stocke les éléments dans des lignes et des colonnes.
• Un tableau tridimensionnel est un tableau de tableaux.
• Les éléments peuvent être ajoutés à un tableau en utilisant leurs index.
• Les éléments du tableau sont accessibles à l'aide de leurs index.
• Un tableau multidimensionnel a plus d'une dimension.
• Le nom du tableau pointe vers son premier élément.
• Les tableaux ont une taille fixe, ce qui signifie que de nouveaux éléments ne peuvent pas être ajoutés au tableau après son initialisation.