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 mathématiques, notamment en algèbre linéaire, les tableaux 2D offrent une structure optimale pour la représentation de matrices.

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

Un tableau 2D en C++ est une structure de données permettant de stocker des éléments dans un arrangement bidimensionnel de type tableau. Contrairement aux tableaux unidimensionnels, qui ne contiennent 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 dimensions 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 individuels ainsi que leur manipulation. Les tableaux 2D trouvent de nombreuses applications, des calculs mathématiques 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’utilisateur.
• arrayName : le nom fait office d’identificateur permettant 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éfinissons un tableau 2D appelé matrice avec 3 lignes et 4 colonnes, ce qui correspond à 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’instruction 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’applications pour les tableaux bidimensionnels C++

Si vous apprenez le langage de programmation C++, vous travaillerez tôt ou tard avec des tableaux. Les termes anglais peuvent d’ailleurs vous être utiles : on parle ainsi souvent de two dimensional array in C++ ou de 2D array in C++ pour désigner un tableau 2D.

Ci-dessous, nous vous montrons des utilisations typiques des tableaux 2D en C++.

Array 2D en C++ comme entrée utilisateur

Voici un exemple simple en C++, dans lequel nous ne définissons pas un tableau 2D avec des valeurs fixées, mais le traitons comme une entrée utilisateur. Dans ce cas, nous demandons à l’utilisateur d’entrer le nombre de lignes et de colonnes, suivi des éléments du tableau proprement 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 représente les lignes et 3 les colonnes, colonnes, et que les valeurs 1, 2, 3, 4, 5, 6 sont passées en entrée utilisateur, 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érateurs C comme +, nous pouvons facilement additionner 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ésultante. La fonction matrixAddition prend les deux matrices de départ et la matrice résultante 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