Array-uri multidimensionale

Fiecare array are o caracteristică numită dimensionalitate. Numărul dimensiunilor corespunde cu numărul de perechi de paranteze pătrate. De exemplu:

int numbers[3];

În acest caz, array-ul numbers are o singură dimensiune (o pereche de paranteze pătrate), deci este un array unidimensional. Nu contează câte elemente conține acest array — în orice caz, poate fi reprezentat ca un șir de valori, fie pe rând, fie pe coloană.

Pe lângă array-urile unidimensionale, în C++ există și array-uri multidimensionale. Elementele acestor array-uri pot fi ele însele array-uri, iar acestea pot conține la rândul lor alte array-uri. De obicei, cele mai frecvente sunt array-urile bidimensionale și tridimensionale. De exemplu, definim un array bidimensional de numere:

int numbers[3][2];

Aici, array-ul numbers are două dimensiuni (două perechi de paranteze pătrate): prima dimensiune este 3, iar a doua este 2. Acest array conține trei elemente, fiecare dintre ele fiind un array de două elemente. Un array bidimensional poate fi reprezentat sub forma unui tabel, unde prima dimensiune reprezintă rândurile, iar a doua dimensiune coloanele.

În mod similar, se pot defini array-uri cu mai multe dimensiuni, de exemplu un array tridimensional:

int numbers[3][2][2];

Ca și în cazul general, un array multidimensional poate fi inițializat cu anumite valori, de exemplu cu zerouri:

int numbers[3][2] {};

De asemenea, putem inițializa toți elementele cu valori individuale. Astfel, array-ul numbers este compus din trei elemente (rânduri), fiecare reprezentând un array de două elemente (coloane). Putem inițializa acest array astfel:

int numbers[3][2] 
{ 
    {1, 2},     // primul rând
    {4, 5},     // al doilea rând
    {7, 8}      // al treilea rând
};

Acoladele imbricate definesc valorile pentru fiecare sub-array. Acest tip de array poate fi vizualizat și sub forma unui tabel.

Este posibilă și inițializarea doar a unor elemente:

int numbers[3][2] { {1, 2}, {}, {7} };

În acest caz, valorile sunt atribuite primelor elemente ale sub-array-urilor, iar celelalte elemente sunt inițializate cu zero.

Așa cum am văzut la array-urile unidimensionale, compilatorul poate deduce lungimea array-ului pe baza numărului de elemente. În cazul array-urilor multidimensionale, este posibilă și omiterea dimensiunii, dar doar a primei dimensiuni (prima pereche de paranteze pătrate):

int numbers[][2] { {1, 2}, {3, 4}, {5, 6} };

Accesarea elementelor

Pentru a accesa elementele unui array multidimensional, trebuie să folosim indici pentru fiecare dimensiune. Astfel, dacă avem un array bidimensional, trebuie să specificăm indicii pentru ambele dimensiuni:

#include <iostream>
  
int main()
{   
    int nums[3][2] 
    { 
        {1, 2}, 
        {3, 4}, 
        {5, 6} 
    };
    // obținem valoarea unui element
    int n = nums[1][0];     // al doilea rând, prima coloană
    std::cout << "n =" << n << std::endl;       // n = 3
 
    std::cout << "nums[2][1] = " << nums[2][1] << std::endl;   // nums[2][1] = 6 
    // modificăm valoarea unui element
    nums[2][1] = 123;       // al treilea rând, a doua coloană
    std::cout << "nums[2][1] = " << nums[2][1] << std::endl;   // nums[2][1] = 123 
}

Array-ul nums poate fi descompus după indici în felul următor:

nums[0][0] = 1     nums[0][1] = 2  
nums[1][0] = 3     nums[1][1] = 4  
nums[2][0] = 5     nums[2][1] = 6

Astfel, expresia nums[1][0] reprezintă accesarea primului element din al doilea sub-array. (adică, prima coloană a celui de-al doilea rând)

Parcurgerea unui array multidimensional

Să parcurgem un array bidimensional:

#include <iostream>
 
int main()
{
    const int rows = 3, columns = 2;
    int numbers[rows][columns]  { {1, 2}, {3, 4}, {5, 6} };
    for(int i=0; i < rows; i++)
    {
        for(int j=0; j < columns; j++)
        {
            std::cout << numbers[i] [j] << "\t";
        }
        std::cout << std::endl;
    }
}

De asemenea, pentru parcurgerea elementelor unui array multidimensional, se poate folosi o altă formă a buclei for, care este destinată special pentru parcurgerea secvențelor:

#include <iostream>
 
int main()
{
    const int rows = 3, columns = 2;
    int numbers[rows][columns]  { {1, 2}, {3, 4}, {5, 6} };
     
    for(auto &subnumbers : numbers)
    {
        for(int number : subnumbers)
        {
            std::cout << number << "\t";
        }
        std::cout << std::endl;
    }
}

Pentru parcurgerea array-urilor care fac parte dintr-un array multidimensional se folosesc referințe. Adică, în bucla exterioară for(auto &subnumbers : numbers) — &subnumbers reprezintă o referință la un sub-array din array. În bucla interioară for(int number : subnumbers) — din fiecare sub-array subnumbers obținem elementele individuale în variabila number și afișăm valoarea acesteia în consolă.