Tableaux dans C++ | Déclarer | Initialiser | Exemples de pointeur vers un tableau

Pourquoi avons-nous besoin de tableaux ?

Arrays sont très importants dans n’importe quel 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éclarez un tableau dans C++

Déclaration de tableau dans 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 dans C++.

• Type : Le type est le type d'éléments à stocker dans le tableau, et il doit s'agir d'un valide C++ type de données.
• Nom du tableau : Le nom du tableau est le nom à attribuer au tableau.
• Taille du tableau : La taille du tableau est le nombre d'éléments à stocker dans le tableau. Il doit s'agir d'un nombre entier 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 étudiants.

Initialisation de la baie

L'initialisation d'un tableau est le processus d'attribution/stockage d'éléments à un tableau. L'initialisation peut être effectuée 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 age pour dé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 ne sera que suffisamment 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 attribuer 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^th élément du tableau.

Types de tableaux

Il existe deux types de C++ tableaux :

• 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. C'est ce qu'on appelle communément un tableau 1D. Syntaxe:

datatype array-name[size];

• Le nom du tableau 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. Y compris le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Y compris l'espace de noms std afin d'utiliser ses classes et fonctions sans l'appeler.
3. Appel de 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 parcourir les valeurs de l'âge du tableau et les imprimer sur la console. Le « \n » est un caractère de nouvelle ligne et s'imprime sur une nouvelle ligne après chaque itération.
9. Fin du corps du pour la boucle.
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 disposé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 du tableau est le nom du tableau qui aura n dimensions. Par exemple:

Tableau à deux dimensions

Un tableau 2D stocke les données dans une liste avec un tableau 1D. 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 valide C++ type de données. Considérez un tableau 2D sous forme de 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 d'un tableau 2D sous 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 de comment initialiser 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é à l'intersection de la ligne indexée 1 et de la colonne indexée 2. intersection de la ligne indexée et de la colonne indexée .

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};
   };

C++ L'exemple montre comment initialiser et parcourir 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. Y compris le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Y compris l'espace de noms std afin d'utiliser ses classes et fonctions sans l'appeler.
3. Appel de la fonction main() dans laquelle le code doit être ajouté.
4. Début du corps de la fonction main().
5. Un commentaire. Le C++ le compilateur 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 C++ le compilateur ignorera cela.
8. Créer une variable en utilisant une boucle for. Cette variable parcourra les index de ligne du tableau.
9. Création d'une variable j en utilisant une boucle for. Cette variable parcourra les index de colonnes 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. Imprimez 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, nous utilisons 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. Y compris le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Y compris l'espace de noms std afin d'utiliser ses classes et fonctions sans l'appeler.
3. Appel de 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éclaration d'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

A aiguille 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 d'un 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. Y compris le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Y compris l'espace de noms std afin d'utiliser ses classes et fonctions sans l'appeler.
3. Appel de 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éclaration d'une variable de pointeur nommée *john.
6. Déclaration d'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'élément stocké dans le premier index du tableau age.
8. Impression de la valeur de la variable john, qui est l'adresse de l'élément stocké dans le premier index du tableau age.
9. Impression de la première valeur stockée dans l'âge du tableau.
10. Fin du corps de la fonction main().

Les noms de tableaux peuvent être utilisés comme pointeurs constants, et vice versa 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. Y compris le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Y compris 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 C++ le compilateur ignorera cela.
5. Déclarer un tableau nommé age pour stocker 5 entiers.
6. Créer un pointeur entier p.
7. Attribuer à p la valeur de l'adresse du premier élément du tableau age.
8. Un commentaire. Le C++ le compilateur ignorera cela.
9. Imprimez du texte sur la console.
10. Créez un entier x en utilisant une boucle for. Le { marque le début du corps de la boucle for.
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.
14. Imprimez du texte sur la console.
15. Créez une variable x en utilisant une boucle for. Le { marque le début du corps de la boucle for.
16. Imprimez les valeurs de x de 0 à 4 avec un autre texte.
17. Imprimez les valeurs de *(age + x).
18. Fin du corps de la boucle for.
19. Valeur renvoyée si le programme s'exécute avec succès.
20. Fin du corps de la fonction main().

Accéder aux valeurs d'un tableau

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 John est le 3^rd valeur dans l’âge du tableau. Voici un complet C++ exemple qui montre comment accéder et imprimer cette valeur :

#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. Y compris le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
2. Y compris l'espace de noms std afin d'utiliser ses classes et fonctions sans l'appeler.
3. Appel de 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 de l'âge du tableau et stocker sa valeur dans une variable nommée john.
7. Impression de la valeur de la variable john sur la console avec un autre texte.

Avantages d'un tableau dans C++

Voici les avantages/avantages de l’utilisation d’Array dans C++:

• Les éléments du tableau peuvent être parcourus 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 dans C++

• Un tableau a une taille fixe ; par conséquent, nous ne pouvons pas y 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 une allocation moindre 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 désignés à l'aide de leurs index respectifs. Le premier élément est à l'index 0, tandis que le dernier élément est à l'index n-1, où correspond 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 bidimensionnel stocke les éléments dans des lignes et des colonnes.
• Un tableau tridimensionnel est un tableau de tableaux.
• Des é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.