Créer et utiliser un tableau (array) 2D en C++

Un tableau (ou array) 2D en C++ sert à organiser des données à la manière d’un tableau. Dans les domaines ma­thé­ma­tiques, notamment en algèbre linéaire, les tableaux 2D offrent une structure optimale pour la re­pré­sen­ta­tion de matrices.

2D Array en C++ : qu’est-ce que c’est ?

Un tableau 2D en C++ est une structure de données per­met­tant de stocker des éléments dans un ar­ran­ge­ment bi­di­men­sion­nel de type tableau. Con­trai­re­ment aux tableaux uni­di­men­sion­nels, qui ne con­tien­nent qu’une série d’éléments, un tableau 2D organise les données en lignes et en colonnes. Les éléments d’un tableau à deux di­men­sions sont définis par leurs positions, indiquées par des indices de lignes et de colonnes. Cette structure facilite l’accès aux points de données in­di­vi­duels ainsi que leur ma­ni­pu­la­tion. Les tableaux 2D trouvent de nom­breuses ap­pli­ca­tions, des calculs ma­thé­ma­tiques avec des matrices à la gestion de données sous forme de grille.

Structure d’un 2D Array en C++

En C++, la syntaxe pour déclarer un tableau 2D est la suivante :

data_type arrayName[num_rows][num_cols];

• data_type : cela indique quel type de données doit être stocké dans les cellules du tableau 2D. Cela peut être par exemple int pour les nombres entiers, double pour les nombres à virgule flottante ou encore des types de données définis par l’uti­li­sa­teur.
• arrayName : le nom fait office d’iden­ti­fi­ca­teur per­met­tant d’accéder à l’ensemble du tableau.
• num_rows : cet élément indique combien de lignes le tableau 2D doit avoir.
• num_cols : permet de définir le nombre de colonnes pour chaque ligne du tableau 2D.

Dans l’exemple ci-dessous, nous dé­fi­nis­sons un tableau 2D appelé matrice avec 3 lignes et 4 colonnes, ce qui cor­res­pond à un total de 12 éléments.

int matrix[3][4] = {{1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}};

Afficher un Array 2D en C++

Nous pouvons afficher un tableau 2D à l’aide d’une boucle. La boucle externe itère sur les lignes, tandis que la boucle interne passe par les colonnes de chaque ligne. L’ins­truc­tion std::cout << matrix[i][j] << " "; affiche chaque élément. Après chaque ligne, nous créons une nouvelle ligne par std::cout << std::endl; pour mieux formater la sortie.

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

Dans la sortie, les éléments du tableau 2D sont affichés ligne par ligne :

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

Exemples d’ap­pli­ca­tions pour les tableaux bi­di­men­sion­nels C++

Si vous apprenez le langage de pro­gram­ma­tion C++, vous tra­vail­le­rez tôt ou tard avec des tableaux. Les termes anglais peuvent d’ailleurs vous être utiles : on parle ainsi souvent de two di­men­sio­nal array in C++ ou de 2D array in C++ pour désigner un tableau 2D.

Ci-dessous, nous vous montrons des uti­li­sa­tions typiques des tableaux 2D en C++.

Array 2D en C++ comme entrée uti­li­sa­teur

Voici un exemple simple en C++, dans lequel nous ne dé­fi­nis­sons pas un tableau 2D avec des valeurs fixées, mais le traitons comme une entrée uti­li­sa­teur. Dans ce cas, nous demandons à l’uti­li­sa­teur d’entrer le nombre de lignes et de colonnes, suivi des éléments du tableau pro­pre­ment dit :

#include <iostream>
int main() {
    int numRows, numCols;
    std::cout << "Number of rows: ";
    std::cin >> numRows;
    std::cout << "Number of columns: ";
    std::cin >> numCols;
    int userArray[numRows][numCols];
    std::cout << "Please enter in elements:\n";
    for (int i = 0; i < numRows; ++i) {
        for (int j = 0; j < numCols; ++j) {
            std::cout << "Element [" << i << "][" << j << "]: ";
            std::cin >> userArray[i][j];
        }
    }
    std::cout << "2D array:\n";
    for (int i = 0; i < numRows; ++i) {
        for (int j = 0; j < numCols; ++j) {
            std::cout << userArray[i][j] << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

Si 2 re­pré­sente les lignes et 3 les colonnes, colonnes, et que les valeurs 1, 2, 3, 4, 5, 6 sont passées en entrée uti­li­sa­teur, alors le tableau 2D est le suivant :

2D array:
1 2 3
4 5 6

Addition de matrices avec des tableaux 2D

Grâce aux opé­ra­teurs C comme +, nous pouvons fa­ci­le­ment ad­di­tion­ner des matrices avec des tableaux 2D en C++.

#include <iostream>
const int numRows = 2;
const int numCols = 2;
void matrixAddition(int A[][numCols], int B[][numCols], int result[][numCols]) {
    for (int i = 0; i < numRows; ++i) {
        for (int j = 0; j < numCols; ++j) {
            result[i][j] = A[i][j] + B[i][j];
        }
    }
}
void displayMatrix(int matrix[][numCols]) {
    for (int i = 0; i < numRows; ++i) {
        for (int j = 0; j < numCols; ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
}
int main() {
    int matrixA[numRows][numCols] = {{1, 2}, {3, 4}};
    int matrixB[numRows][numCols] = {{5, 6}, {7, 8}};
    int resultMatrix[numRows][numCols];
    matrixAddition(matrixA, matrixB, resultMatrix);
    // Output of matrix A and B and their sum
    std::cout << "Matrix A:\n";
    displayMatrix(matrixA);
    std::cout << "\nMatrix B:\n";
    displayMatrix(matrixB);
    std::cout << "\nSum (A + B):\n";
    displayMatrix(resultMatrix);
    return 0;
}

Tout d’abord, nous créons les matrices 2x2 A et B, et leur somme est calculée et affichée dans la matrice ré­sul­tante. La fonction matrixAddition prend les deux matrices de départ et la matrice ré­sul­tante comme arguments et effectue l’addition. La fonction displayMatrix affiche la somme des matrices sur la console.

Nous obtenons en sortie :

Matrix A:
1 2
3 4
Matrix B:
5 6
7 8
Sum (A + B):
6 8
10 12