Tableaux en C ++ - Déclarer - Initialiser - Exemples de pointeur vers tableau

Qu'est-ce qu'un tableau?

Un tableau est une structure de données qui stocke un élément du même type de données de manière séquentielle. 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 de la baie
• Types de tableaux
• Réseau unidimensionnel
• Réseau multidimensionnel
• Réseau bidimensionnel
• Réseau à trois dimensions
• Pointeur vers un tableau
• Accéder aux valeurs d'un tableau
• 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 des variables ou une collection de données d'un type de données similaire ensemble 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 ++ consiste à 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 seule dimension en C ++.

• Type: le type est le type d'éléments à stocker dans le tableau et doit être un type de données C ++ valide.
• 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. Ce doit être un 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];

L'âge du tableau stockera 5 entiers représentant les âges des différents élèves.

Initialisation de la baie

L'initialisation d'un tableau est le processus d'affectation / de 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 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'indice 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 [], 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 le précédent. Vous pouvez également affecter un élément à un tableau à l'aide de 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 ^e élément du tableau.

Types de tableaux

Il existe deux types de tableaux C ++:

• Un tableau dimensionnel
• Réseau multidimensionnel
• Pointeur vers un tableau

Réseau 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é un tableau 1-D. Syntaxe:

datatype array-name[size];

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

Par exemple:

#include using namespace std;int main(){int age[5] = { 19, 18, 21, 20, 17 };for (int x = 0; x < 5; x++){cout <
Production:

Voici une capture d'écran du code:

Explication du code:

Inclure le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
Inclure l'espace de noms std afin d'utiliser ses classes et ses fonctions sans l'appeler.
Appel de la fonction main () à l'intérieur de laquelle la logique du programme doit être ajoutée.
Début du corps de la fonction main ().
Déclarer un tableau nommé age pour stocker 5 entiers. Les 5 entiers ont également été initialisés.
Créez une variable entière x en utilisant une boucle for.
Le début du corps de la boucle for.
Utilisation de 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 dans une nouvelle ligne après chaque itération.
Fin du corps de la boucle for.
Fin du corps de la fonction main ().

Réseau 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:
Réseau 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 l'élément appartient.
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 2x3. Il y a 2 lignes et 3 colonnes. L'élément 0 est accessible en tant que [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 en tant que [1] [2] car il est situé au 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 être effectuée comme suit:
int a[2][3] = {0, 2, 1, 4, 3, 7};};
L'exemple C ++ suivant montre comment initialiser et parcourir un tableau 2D:
#include using namespace std;int main(){// a 2x3 arrayint a[3][2] = { {0, 2}, {1, 4}, {3, 7} };// traverse array elementsfor (int i=0; i<3; i++)for (int j=0; j<2; j++){cout << "a[" <
Production:

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

Explication du code:

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

Réseau à trois dimensions
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:
#includeusing 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";}
Production:

Voici une capture d'écran du code:

Explication du code:

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

Pointeur vers un tableau
Un pointeur est une variable qui contient une adresse. Autre que d'utiliser 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 using namespace std;int main(){int *john;int age[5] = { 19, 18, 21, 20, 17 };john = age;cout << john << "\n";cout << *john;}
Production:

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

Explication du code:

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

Les noms de tableau 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 de l'âge du tableau avec * (age + 3). Par exemple:
#include using namespace std;int main() {// an array of 5 elements.int age[5] = { 19, 18, 21, 20, 17 };int *p;p = age;// output array valuescout << "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;}
Production:

Voici une capture d'écran du code:

Explication du code:

Inclure le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
Inclure l'espace de noms std afin d'utiliser ses classes et ses fonctions sans l'appeler.
Appel de la fonction main () et début du corps de la fonction main ().
Un commentaire. Le compilateur C ++ ignorera cela.
Déclarer un tableau nommé age pour stocker 5 entiers.
Créer un pointeur entier p.
Affecter à p la valeur de l'adresse du premier élément du tableau age.
Un commentaire. Le compilateur C ++ ignorera cela.
Imprimez du texte sur la console.
Créez un entier x en utilisant une boucle for. Le {marque le début du corps de la boucle for.
Imprimez les valeurs de x combinées avec un autre texte sur la console.
Imprimez les valeurs de * (p + x) sur la console.
Fin du corps de la boucle for.
Imprimez du texte sur la console.
Créez une variable x en utilisant une boucle for. Le {marque le début du corps de la boucle for.
Imprimez les valeurs de x de 0 à 4 avec un autre texte.
Imprimez les valeurs de * (âge + x).
Fin du corps de la boucle for.
Valeur renvoyée si le programme s'exécute avec succès.
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 déclarons simplement que l'âge de john est stocké à l'index 2 du tableau nommé age. Cela signifie que l'âge de john est la 3 ème valeur de l'âge du tableau. Voici un exemple C ++ complet qui montre comment accéder et imprimer cette valeur:
#includeusing namespace std;int main(){int age[5] = { 19, 18, 21, 20, 17 };int john = age[2];cout << "The age of John is:"<
Production:

Voici une capture d'écran du code:

Explication du code:

Inclure le fichier d'en-tête iostream dans notre code. Cela nous permettra de lire et d'écrire sur la console.
Inclure l'espace de noms std afin d'utiliser ses classes et ses fonctions sans l'appeler.
Appel de la fonction main () dans laquelle le code doit être ajouté.
Début d'un corps de la fonction main ().
Déclarer un tableau nommé age pour stocker 5 éléments entiers.
Accéder à la valeur stockée à l'index 2 de l'âge du tableau et stocker sa valeur dans une variable nommée john.
Impression de 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 parcourus facilement.
Facile à manipuler les données de 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 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 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'index 0, tandis que le dernier élément est à l'index n-1, où est le nombre total d'éléments du tableau.
La déclaration d'un tableau implique la définition des 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 en trois dimensions est un tableau de tableaux.
Les éléments peuvent être ajoutés à un tableau à l'aide de leurs index.
Les éléments du tableau sont accessibles à l'aide de leurs index.
Un tableau multidimensionnel a plusieurs dimensions.
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.