Dichiarare e utilizzare gli array in C++

In C++, gli array bidimensionali vengono utilizzati per organizzare i dati, e possono essere rappresentati in forma tabellare. In ambito matematico, e nello specifico nell’algebra lineare, gli array 2D offrono una struttura ottimale per la rappresentazione di matrici.

Che cos’è esattamente un array bidimensionale in C++?

Un array 2D in C++ è una struttura di dati che permette di memorizzare elementi in una disposizione bidimensionale in forma tabellare. A differenza degli array monodimensionali (o vettori), che contengono solo una serie di elementi, gli array bidimensionali (o matrici) organizzano i dati in righe e colonne. Gli elementi di un array bidimensionale sono definiti dalle loro posizioni, specificate dagli indici di riga e di colonna. Questa struttura rende più facile l’accesso e la manipolazione dei singoli punti di dati. Gli array 2D hanno una vasta gamma di applicazioni, dai calcoli matematici con le matrici alla gestione dei dati sotto forma di raster.

Come si struttura un array bidimensionale in C++

In C++, la sintassi per dichiarare un array bidimensionale consiste nei seguenti elementi:

data_type arrayName[num_rows][num_cols];

• data_type: specifica il tipo di dati da memorizzare nelle celle dell’array bidimensionale. 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 identificatore utilizzabile per accedere all’intero array.
• num_rows: specifica quante righe deve avere l’array bidimensionale.
• num_cols: specifica il numero di colonne per ogni riga dell’array bidimensionale.

Nell’esempio che segue, definiamo un array bidimensionale chiamato matrix con 3 righe e 4 colonne, che corrisponde a un totale di 12 elementi.

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

Come dichiarare un array bidimensionale in C++

Possiamo creare un array bidimensionale utilizzando un ciclo for. Il ciclo esterno itera sulle righe, mentre il ciclo interno itera sulle colonne di ogni riga. L’istruzione std::cout << matrix[i][j] << " "; visualizza ogni elemento. Al termine di ogni riga, ne creiamo una nuova usando std::cout << std::endl; per formattare 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 bidimensionale vengono visualizzati riga per riga nell’output:

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

Esempi di applicazione per gli array bidimensionali in C++

Se stai imparando il linguaggio di programmazione C++, prima o poi ti capiterà di lavorare con gli array. Di seguito ti presentiamo alcune applicazioni tipiche degli array bidimensionali in C++.

Array bidimensionali in C++ come input utente

Qui trovi un semplice esempio in C++ in cui non definiamo un array bidimensionale con valori fissi, ma lo elaboriamo 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 bidimensionale si presenta nel modo seguente:

2D array:
1 2 3
4 5 6

Addizione di matrici con array bidimensionali

Utilizzando gli operatori C come + è possibile aggiungere matrici con array bidimensionali 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 visualizzata nella matrice risultante. La funzione matrixAddition prende come argomenti le due matrici iniziali e la matrice risultante ed esegue l’addizione. La funzione displayMatrix visualizza 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