# 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:

```c++
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.

```c++
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.

```c++
#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:

```c++
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++](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/imparare-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:

```c++
#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:

```c++
2D array:
1 2 3
4 5 6
```

### Addizione di matrici con array bidimensionali

Utilizzando gli [operatori C](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/operatori-c/) come `+` è possibile aggiungere matrici con array bidimensionali in C++ in maniera molto semplice.

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

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:

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


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/array-bidimensionali-2d-in-c-plus-plus/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/array-bidimensionali-2d-in-c-plus-plus/) for AI/LLM consumption.