Di­chia­ra­re e uti­liz­za­re gli array in C++

In C++, gli array bi­di­men­sio­na­li vengono uti­liz­za­ti per or­ga­niz­za­re i dati, e possono essere rap­pre­sen­ta­ti in forma tabellare. In ambito ma­te­ma­ti­co, e nello specifico nell’algebra lineare, gli array 2D offrono una struttura ottimale per la rap­pre­sen­ta­zio­ne di matrici.

Che cos’è esat­ta­men­te un array bi­di­men­sio­na­le in C++?

Un array 2D in C++ è una struttura di dati che permette di me­mo­riz­za­re elementi in una di­spo­si­zio­ne bi­di­men­sio­na­le in forma tabellare. A dif­fe­ren­za degli array mo­no­di­men­sio­na­li (o vettori), che con­ten­go­no solo una serie di elementi, gli array bi­di­men­sio­na­li (o matrici) or­ga­niz­za­no i dati in righe e colonne. Gli elementi di un array bi­di­men­sio­na­le sono definiti dalle loro posizioni, spe­ci­fi­ca­te dagli indici di riga e di colonna. Questa struttura rende più facile l’accesso e la ma­ni­po­la­zio­ne dei singoli punti di dati. Gli array 2D hanno una vasta gamma di ap­pli­ca­zio­ni, dai calcoli ma­te­ma­ti­ci con le matrici alla gestione dei dati sotto forma di raster.

Come si struttura un array bi­di­men­sio­na­le in C++

In C++, la sintassi per di­chia­ra­re un array bi­di­men­sio­na­le consiste nei seguenti elementi:

data_type arrayName[num_rows][num_cols];

• data_type: specifica il tipo di dati da me­mo­riz­za­re nelle celle dell’array bi­di­men­sio­na­le. Ad esempio, può essere int per i numeri interi e double per i numeri in virgola mobile o tipi di dati definiti dall’utente.
• arrayName: il nome che funge da iden­ti­fi­ca­to­re uti­liz­za­bi­le per accedere all’intero array.
• num_rows: specifica quante righe deve avere l’array bi­di­men­sio­na­le.
• num_cols: specifica il numero di colonne per ogni riga dell’array bi­di­men­sio­na­le.

Nell’esempio che segue, definiamo un array bi­di­men­sio­na­le chiamato matrix con 3 righe e 4 colonne, che cor­ri­spon­de a un totale di 12 elementi.

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

Come di­chia­ra­re un array bi­di­men­sio­na­le in C++

Possiamo creare un array bi­di­men­sio­na­le uti­liz­zan­do un ciclo for. Il ciclo esterno itera sulle righe, mentre il ciclo interno itera sulle colonne di ogni riga. L’istru­zio­ne std::cout << matrix[i][j] << " "; vi­sua­liz­za ogni elemento. Al termine di ogni riga, ne creiamo una nuova usando std::cout << std::endl; per for­mat­ta­re meglio l’output.

#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;
}

Gli elementi dell’array bi­di­men­sio­na­le vengono vi­sua­liz­za­ti riga per riga nell’output:

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

Esempi di ap­pli­ca­zio­ne per gli array bi­di­men­sio­na­li in C++

Se stai imparando il lin­guag­gio di pro­gram­ma­zio­ne C++, prima o poi ti capiterà di lavorare con gli array. Di seguito ti pre­sen­tia­mo alcune ap­pli­ca­zio­ni tipiche degli array bi­di­men­sio­na­li in C++.

Array bi­di­men­sio­na­li in C++ come input utente

Qui trovi un semplice esempio in C++ in cui non definiamo un array bi­di­men­sio­na­le con valori fissi, ma lo ela­bo­ria­mo come input dell’utente. In questo caso, chiediamo all’utente di inserire il numero di righe e colonne, seguito dagli elementi effettivi dell’array:

#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;
}

Se come input dell’utente vengono inserite 2 righe e 3 colonne e i valori 1, 2, 3, 4, 5, 6, l’array bi­di­men­sio­na­le si presenta nel modo seguente:

2D array:
1 2 3
4 5 6

Addizione di matrici con array bi­di­men­sio­na­li

Uti­liz­zan­do gli operatori C come + è possibile ag­giun­ge­re matrici con array bi­di­men­sio­na­li in C++ in maniera molto semplice.

#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;
}

Per prima cosa, vengono create le matrici 2x2 A e B, e la loro somma viene calcolata e vi­sua­liz­za­ta nella matrice ri­sul­tan­te. La funzione matrixAddition prende come argomenti le due matrici iniziali e la matrice ri­sul­tan­te ed esegue l’addizione. La funzione displayMatrix vi­sua­liz­za la somma delle matrici sulla console.

Si ottiene il seguente output:

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