Un tableau est un type de structure de données utilisé pour stocker la collection d’éléments du même type de données conservés dans des emplacements de mémoire contigus. Les tableaux peuvent être unidimensionnels ou multidimensionnels en fonction du nombre de directions dans lesquelles le tableau peut se développer. Dans cet article, nous étudierons les tableaux multidimensionnels tels que les tableaux bidimensionnels et les tableaux tridimensionnels.

Qu’est-ce qu’un tableau multidimensionnel en C++ ?

Un tableau multidimensionnel est un tableau comportant plusieurs dimensions. C'est la collection homogène d'éléments où chaque élément est accessible à l'aide de plusieurs indices.

Déclaration de tableau multidimensionnel

  datatype     arrayName    [    size1][size2]...[sizeN];>

où,

• Type de données: Type de données à stocker dans le tableau.
• nom du tableau : Nom du tableau.
• taille1, taille2,…, tailleN : Taille de chaque dimension.

Exemple:

Two dimensional array: int two_d[2][4]; Three dimensional array: int three_d[2][4][8];>

Taille d'un tableau multidimensionnel

La taille d'un tableau est égale à la taille du type de données multipliée par le nombre total d'éléments pouvant être stockés dans un tableau. Nous pouvons calculer le nombre total d'éléments dans un tableau en multipliant la taille de chaque dimension d'un tableau multidimensionnel.

Par exemple:

int arr1[2][4];>

• Le tableau int arr1[2][4] peut stocker le total (2*4) = 8 éléments.
• En C++, le type de données int prend 4 octets et nous avons 8 éléments dans le tableau 'arr1' du type int.
• Taille totale = 4*8 = 32 octets .

int arr2[2][4][8];>

• Tableau entier arr2[2][4][8] peut stocker un total (2*4*8) = 64 éléments.
• La taille totale de ' arr2 ' = 64*4 = 256 octets .

Pour vérifier le calcul ci-dessus, nous pouvons utiliser taille de() méthode pour trouver la taille d’un tableau.

C++

>

>

freddie mercure né

Size of array arr1: 32 bytes Size of array arr2: 256 bytes>

Les tableaux multidimensionnels les plus utilisés sont :

• Tableau bidimensionnel
• Tableau tridimensionnel

Tableau bidimensionnel (ou tableau 2D)

Un tableau bidimensionnel en C++ est une collection d'éléments organisés en lignes et en colonnes. Il peut être visualisé sous forme de tableau ou de grille, où chaque élément est accessible à l'aide de deux indices : un pour la ligne et un pour la colonne. Comme pour un tableau unidimensionnel, les indices d'un tableau bidimensionnel vont également de 0 à n-1 pour les lignes et les colonnes.

Syntaxe du tableau 2D

data_Type nom_tableau[ n ][ m ];

Où,

• n: Nombre de rangées.
• m: Le nombre de colonnes.

Nous pouvons déclarer un tableau 2D de manière statique et dynamique. Dans la déclaration statique, la mémoire est allouée pendant la compilation et dans la mémoire dynamique, pendant l'exécution. Ce qui précède est la syntaxe de la déclaration statique d'un tableau 2D. Pour savoir comment déclarer dynamiquement le tableau 2D, reportez-vous à ce article.

Initialisation de tableaux bidimensionnels en C++

Différentes manières d'initialiser un tableau 2D sont présentées ci-dessous :

conversion de chaîne en date

• Utilisation de la liste d'initialisation
• Utiliser des boucles

1. Initialisez le tableau 2D à l'aide de la liste Initializer

Nous pouvons initialiser un tableau 2D à l’aide d’une liste d’initialisation de deux manières. Vous trouverez ci-dessous la première méthode d'initialisation d'un tableau 2D à l'aide d'une liste d'initialisation.

Première méthode : Le tableau ci-dessous comporte 2 lignes et 4 colonnes. Les éléments sont remplis de manière à ce que les 4 premiers éléments soient remplis dans la première ligne et les 4 éléments suivants dans la deuxième ligne.

int arr[2][4] = {0, 1, 2, 3, 4, 5, 6, 7};>

Deuxième méthode : La méthode ci-dessous est la manière la plus simple d'initialiser un tableau 2D. La liste imbriquée représente les éléments d'une ligne et le nombre d'éléments à l'intérieur est égal au nombre de colonnes dans un tableau 2D. Le nombre de listes imbriquées représente le nombre de colonnes.

int x[2][4] = {{0, 1, 2, 3}, {4, 5, 6, 7}};>

2. Initialisation du tableau 2D à l'aide de boucles

Nous pouvons également initialiser un tableau 2D à l'aide de boucles. Pour initialiser un tableau 2D, nous devons utiliser deux boucles imbriquées et les boucles imbriquées sont égales à la dimension. Par exemple, pour initialiser un tableau 3D, nous devons utiliser trois boucles imbriquées. Voyons un exemple.

Exemple: Dans l'exemple ci-dessous, nous avons initialisé le tableau 2D avec 1. La boucle externe est utilisée pour suivre les lignes i = 0 signifie la première ligne en raison de l'indexation 0 de la même manière j = 0 signifie la première colonne et en combinant cela x [0] [0] représente la première cellule du tableau 2D.

int x[2][4]; for(int i = 0; i <2; i++){  for(int j = 0; j <4; j++){  x[i][j] = 1;  } }>

Accéder aux éléments des tableaux bidimensionnels en C++

Nous pouvons accéder aux éléments d'un tableau à 2 dimensions à l'aide d'index de lignes et de colonnes. C'est similaire à la position des éléments de la matrice, mais la seule différence est qu'ici l'indexation commence à 0.

Syntaxe:

array_name[i][j];>

où,

• je: Index de la ligne.
• j: Index de la colonne.

Exemple: Vous trouverez ci-dessous l'index des éléments de la deuxième ligne et de la troisième colonne.

int x[1][2];>

Comprenons cela en utilisant du code en imprimant les éléments d'un tableau 2D.

Exemple de tableau 2D

C++

>

>

1 2 3 4 5 6 7 8 9 10 11 12>

Explication: Dans le code ci-dessus, nous avons initialisé le décompte par « 1 » et déclaré un tableau 2D avec 3 lignes et 4 colonnes, après quoi nous avons initialisé le tableau avec la valeur du décompte et la valeur d'incrément du décompte à chaque itération de la boucle. Ensuite, nous imprimons le tableau 2D à l'aide d'une boucle imbriquée et nous pouvons voir dans la sortie ci-dessous qu'il y a 3 lignes et 4 colonnes.

Complexité temporelle : O(n*m)
Complexité spatiale : O(n*m)

où n est le nombre de lignes et m le nombre de colonnes.

Tableau tridimensionnel en C++

Le tableau 3D est une structure de données qui stocke des éléments dans une structure tridimensionnelle de type cuboïde. Il peut être visualisé comme une collection de plusieurs tableaux bidimensionnels empilés les uns sur les autres. Chaque élément d'un tableau 3D est identifié par ses trois indices : l'indice de ligne, l'indice de colonne et l'indice de profondeur.

topologies

Déclaration d'un tableau tridimensionnel en C++

Pour déclarer un tableau 3D en C++, nous devons spécifier sa troisième dimension ainsi que les dimensions 2D.

Syntaxe:

dataType arrayName[d][r];>

• Type de données: Type de données à stocker dans chaque élément.
• nom du tableau : Nom du tableau
• d: Nombre de tableaux 2D ou Profondeur du tableau.
• r: Nombre de lignes dans chaque tableau 2D.
• c : Nombre de colonnes dans chaque tableau 2D.

Exemple:

int array[3][5][2];>

Initialisation d'un tableau tridimensionnel en C++

Pour initialiser le tableau 3D en C++, nous suivons les mêmes méthodes que celles utilisées pour initialiser le tableau 2D. Dans un tableau 3D, nous avons une dimension supplémentaire, nous devons donc ajouter une liste d'éléments imbriquées supplémentaire.

Un tableau 3D en C peut être initialisé en utilisant :

1. Liste d'initialisation
2. Boucles

Initialisation du tableau 3D à l'aide de la liste d'initialisation

Méthode 1 : Dans cette méthode, nous devons écrire le nombre total d'éléments entre accolades, et chaque élément est placé à sa position en fonction de la dimension donnée.

int x[3][5][2] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,   10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  20, 21, 22, 23, 24, 25, 26, 27, 28, 30};>

Méthode 2 (mieux) : Dans cette méthode, nous avons partitionné les éléments à l'aide de listes imbriquées et c'est facile à lire.

int x[3][5][2] =   {      {   {0, 1}, {2, 3}, {4, 5}, {6, 7}, {8, 9}   }  ,     {   {10, 11}, {12, 13}, {14, 15}, {16, 17}, {18, 19}   }  ,    {   {20, 21}, {22, 23}, {24, 25}, {26, 27}, {28, 30}   }  ,    }  ;>

Initialisation d'un tableau 3D à l'aide de boucles

Cette méthode revient à initialiser un tableau 2D à l'aide de boucles avec une boucle imbriquée supplémentaire pour la troisième dimension.

int x[3][5][2]; for (int i = 0; i <3; i++) {  for (int j = 0; j <5; j++) {  for (int k = 0; k <2; k++) {  x[i][j][k] =   (some_value)  ;  }  } }>

Accéder aux éléments dans un tableau tridimensionnel en C++

Accéder aux éléments des tableaux 3D est aussi simple que d'accéder aux éléments des tableaux 2D. Ici, ce que nous devons faire un travail supplémentaire consiste à ajouter une boucle imbriquée supplémentaire pour garder une trace de la troisième dimension.

C++

comment fonctionne un ordinateur

>

>

x[0][0][0] = 0 x[0][0][1] = 1 x[0][0][2] = 2 x[0][1][0] = 3 x[0][1][1] = 4 x[0][1][2] = 5 x[1][0][0] = 6 x[1][0][1] = 7 x[1][0][2] = 8 x[1][1][0] = 9 x[1][1][1] = 10 x[1][1][2] = 11>

Explication: Dans le code ci-dessus, nous avons initialisé le tableau 3D en utilisant la boucle comme expliqué ci-dessus avec le nombre de 0 à 7 en utilisant la variable count puis en accédant aux éléments en utilisant la même boucle utilisée pour initialiser le tableau 3D. La seule différence est qu'au lieu d'attribuer un élément à une position particulière, disons x[0][0][1]=1 nous imprimons l'élément stocké à cet emplacement, comme le montre la sortie ci-dessous.