Maîtriser les tableaux multidimensionnels en C++ : Déclaration, initialisation et boucles

Tableaux multidimensionnels C++

Ce guide vous guide à travers la déclaration, l'initialisation et l'itération sur les tableaux 2-D et 3-D en C++. Des exemples de code pratiques et bonnes pratiques sont inclus.

En C++, un tableau multidimensionnel est simplement un tableau de tableaux. Par exemple :

int x[3][4];

Ici, x est un tableau bidimensionnel qui peut contenir 12 éléments. Visualisez-le comme un tableau avec 3 lignes et 4 colonnes.

Les tableaux tridimensionnels suivent la même logique :

float x[2][4][3];

Avec 24 éléments au total, calculé en multipliant les dimensions : 2 × 4 × 3 = 24.

---

Initialisation de tableau multidimensionnel

Comme les tableaux unidimensionnels, les tableaux multidimensionnels peuvent être initialisés de plusieurs façons, mais la clarté importe. Les sections suivantes montrent les pratiques recommandées.

1. Initialisation de tableau bidimensionnel

int test[2][3] = {2, 4, 5, 9, 0, 19};

Bien que syntaxiquement correct, ce style est difficile à lire. Préférez un initialiseur imbriqué :

int test[2][3] = {{2, 4, 5}, {9, 0, 19}};

Ceci rend les 2 lignes et 3 colonnes explicites.

---

2. Initialisation de tableau tridimensionnel

int test[2][3][4] = {3, 4, 2, 3, 0, -3, 9, 11, 23, 12, 23, 2, 13, 4, 56, 3, 5, 9, 3, 5, 5, 1, 4, 9};

Encore une fois, la lisibilité souffre. Une approche plus claire regroupe chaque dimension :

int test[2][3][4] = {
    {{3, 4, 2, 3}, {0, -3, 9, 11}, {23, 12, 23, 2}},
    {{13, 4, 56, 3}, {5, 9, 3, 5}, {5, 1, 4, 9}}
};

Remarquez que la première dimension contient deux blocs de 3 lignes, chacun avec quatre colonnes.

---

Exemple 1 : Tableau bidimensionnel

#include <iostream>
using namespace std;
int main() {
    int test[3][2] = {{2, -5}, {4, 0}, {9, 1}};
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 2; ++j) {
            cout << "test[" << i << "][" << j << "] = " << test[i][j] << endl;
        }
    }
    return 0;
}

Sortie

test[0][0] = 2
test[0][1] = -5
test[1][0] = 4
test[1][1] = 0
test[2][0] = 9
test[2][1] = 1

Cet extrait démontre une boucle for imbriquée qui itère d'abord sur les lignes, puis les colonnes, affichant chaque élément.

---

Exemple 2 : Saisie pour un tableau bidimensionnel

#include <iostream>
using namespace std;
int main() {
    int nombres[2][3];
    cout << "Entrez 6 nombres : " << endl;
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 3; ++j) {
            cin >> nombres[i][j];
        }
    }
    cout << "Les nombres sont : " << endl;
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 3; ++j) {
            cout << "nombres[" << i << "][" << j << "]: " << nombres[i][j] << endl;
        }
    }
    return 0;
}

Sortie

Entrez 6 nombres :
1 2 3 4 5 6
Les nombres sont :
nombres[0][0]: 1
nombres[0][1]: 2
nombres[0][2]: 3
nombres[1][0]: 4
nombres[1][1]: 5
nombres[1][2]: 6

Ici, deux boucles imbriquées collectent la saisie utilisateur et affichent ensuite les valeurs stockées.

---

Exemple 3 : Tableau tridimensionnel

#include <iostream>
using namespace std;
int main() {
    int test[2][3][2] = {
        {{1, 2}, {3, 4}, {5, 6}},
        {{7, 8}, {9, 10}, {11, 12}}
    };
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 3; ++j) {
            for (int k = 0; k < 2; ++k) {
                cout << "test[" << i << "][" << j << "][" << k << "] = " << test[i][j][k] << endl;
            }
        }
    }
    return 0;
}

Sortie

test[0][0][0] = 1
test[0][0][1] = 2
test[0][1][0] = 3
test[0][1][1] = 4
test[0][2][0] = 5
test[0][2][1] = 6
test[1][0][0] = 7
test[1][0][1] = 8
test[1][1][0] = 9
test[1][1][1] = 10
test[1][2][0] = 11
test[1][2][1] = 12

Boucler sur un tableau 3-D nécessite trois boucles imbriquées — chacune correspondant à une dimension. Ce pattern s'échelonne naturellement aux dimensions supérieures, bien que la complexité croisse rapidement.