Array bidimensionale in C++

Tutorial

Introduzione

A two-dimensional array in C++ is the simplest form of a multi-dimensional array. It can be visualized as an array of arrays. The image below depicts a two-dimensional array.

2D Array Representation

A two-dimensional array is also called a matrix. It can be of any type like integer, character, float, etc. depending on the initialization. In the next section, we are going to discuss how we can initialize 2D arrays.

Inizializzazione di un array 2D in C++

Quindi, come inizializziamo un array bidimensionale in C++? Semplice come questo:

int arr[4][2] = {
{1234, 56},
{1212, 33},
{1434, 80},
{1312, 78}
} ;

Quindi, come puoi vedere, inizializziamo un array 2D arr, con 4 righe e 2 colonne come un array di array. Ogni elemento dell’array è ancora una volta un array di interi.

Possiamo anche inizializzare un array 2D nel seguente modo.

int arr[4][2] = {1234, 56, 1212, 33, 1434, 80, 1312, 78};

In questo caso anche, arr è un array 2D con 4 righe e 2 colonne.

Stampa di un array 2D in C++

Abbiamo finito di inizializzare un array 2D, ora senza stampare effettivamente lo stesso, non possiamo confermare che sia stato fatto correttamente.

Inoltre, in molti casi, potremmo avere bisogno di stampare un array 2D risultante dopo aver eseguito alcune operazioni su di esso. Come possiamo fare?

Il codice qui sotto ci mostra come possiamo farlo.

#include<iostream>
using namespace std; 
main( ) 
{  
	int arr[4][2] = {
		{ 10, 11 },
		{ 20, 21 },
		{ 30, 31 },
		{ 40, 41 }
		} ;
		
	int i,j;
	
	cout<<"Printing a 2D Array:\n";
	for(i=0;i<4;i++)
	{
		for(j=0;j<2;j++)
		{
			cout<<"\t"<<arr[i][j];
		}
		cout<<endl;
	}
}

Output:

Printing A 2D Array

Nel codice sopra,

  • Inizialmente inizializziamo un array bidimensionale, arr[4][2] con valori specifici.
  • Successivamente, proviamo a stampare l’array corrispondente utilizzando due cicli for.
  • Il ciclo esterno itera sulle righe, mentre quello interno itera sulle colonne dell’array bidimensionale.
  • Quindi, ad ogni iterazione del ciclo esterno, i aumenta e ci porta alla successiva array monodimensionale. Inoltre, il ciclo interno attraversa l’intero array monodimensionale in una volta sola.
  • E di conseguenza, stampiamo l’elemento individuale arr[i][j].

Prendere gli elementi dell’array bidimensionale come input dell’utente

In precedenza, abbiamo visto come possiamo inizializzare un array bidimensionale con valori predefiniti. Ma possiamo anche prenderlo come input dell’utente. Vediamo come

#include<iostream>
using namespace std; 
main( ) 
{  
      int  s[2][2];
      int  i, j;
      cout<<"\n2D Array Input:\n";
	  for(i=0;i<2;i++)
	  {
	  	for(j=0;j<2;j++)
	  	{
	  		cout<<"\ns["<<i<<"]["<<j<<"]=  ";
	  		cin>>s[i][j];
		}
	  } 
	  
	  cout<<"\nThe 2-D Array is:\n";
      for(i=0;i<2;i++)
	  {
	  	for(j=0;j<2;j++)
	  	{
	  		cout<<"\t"<<s[i][j];
		}
		cout<<endl;
	  } 
}

Output:

2D Array User Input

Per il codice sopra, dichiariamo un array bidimensionale 2X2 chiamato s. Utilizzando due cicli for nidificati, attraversiamo ogni elemento dell’array e prendiamo gli input dell’utente corrispondenti. In questo modo, l’intero array viene riempito e lo stampiamo per vedere i risultati.

Addizione di matrici utilizzando array bidimensionali in C++

Come esempio vediamo come possiamo utilizzare gli array bidimensionali per eseguire l’addizione di matrici e stampare il risultato.

#include<iostream>
using namespace std; 
main() 
{  
      int  m1[5][5], m2[5][5], m3[5][5];
      int  i, j, r, c;
      
      cout<<"Enter the no.of rows of the matrices to be added(max 5):";
      cin>>r;
      cout<<"Enter the no.of columns of the matrices to be added(max 5):";
      cin>>c;
      
      cout<<"\n1st Matrix Input:\n";
	  for(i=0;i<r;i++)
	  {
	  	for(j=0;j<c;j++)
	  	{
	  		cout<<"\nmatrix1["<<i<<"]["<<j<<"]=  ";
	  		cin>>m1[i][j];
		}
	  } 
	  
	  cout<<"\n2nd Matrix Input:\n";
	  for(i=0;i<r;i++)
	  {
	  	for(j=0;j<c;j++)
	  	{
	  		cout<<"\nmatrix2["<<i<<"]["<<j<<"]=  ";
	  		cin>>m2[i][j];
		}
	  } 
	  
	  cout<<"\nAdding Matrices...\n";
	  
	  for(i=0;i<r;i++)
	  {
	  	for(j=0;j<c;j++)
	  	{
	  		m3[i][j]=m1[i][j]+m2[i][j];
		}
	  } 
	  
	  cout<<"\nThe resultant Matrix is:\n";

	  for(i=0;i<r;i++)
	  {
	  	for(j=0;j<c;j++)
	  	{
	  		cout<<"\t"<<m3[i][j];
		}
		cout<<endl;
	  } 
	  
}

Output:

Matrix Addition Using 2D Arrays

Qui,

  • prendiamo due matrici m1 e m2 con un massimo di 5 righe e 5 colonne. E un’altra matrice m3 in cui memorizzeremo il risultato,
  • Come input utente, prendiamo il numero di righe e colonne per entrambe le matrici. Poiché stiamo eseguendo l’addizione di matrici, il numero di righe e colonne deve essere lo stesso per entrambe le matrici,
  • Dopo di che, prendiamo entrambe le matrici come input utente, di nuovo usando cicli for nidificati,
  • A questo punto, abbiamo entrambe le matrici m1 e m2,
  • poi attraversiamo la matrice m3, usando due cicli for e aggiorniamo gli elementi corrispondenti m3[i][j] con il valore di m1[i][j]+m2[i][j]. In questo modo, alla fine del ciclo for esterno, otteniamo la nostra matrice desiderata,
  • Infine, stampiamo la matrice risultante m3.

Puntatore a un array bidimensionale in C++

Se possiamo avere un puntatore a un intero, un puntatore a un float, un puntatore a un char, allora non possiamo avere un puntatore a un array? Certamente possiamo. Il programma seguente mostra come costruirlo e usarlo.

#include<iostream>
using namespace std;
/* Utilizzo di un puntatore a un array */ 
main( ) 
{  
      int  s[5][2] = {
           {1, 2},
           {1, 2},
           {1, 2},
           {1, 2}
           } ;
           
      int (*p)[2] ;
      int  i, j;
      for (i = 0 ; i <= 3 ; i++)
      {
      		p=&s[i];
      		cout<<"Row"<<i<<":";
            for (j = 0; j <= 1; j++)
                cout<<"\t"<<*(*p+j);
            cout<<endl;
      } 
      
}

Output:

2D Array Pointer

Ecco,

  • Nel codice sopra, cerchiamo di stampare una matrice 2D usando puntatori,
  • Come abbiamo fatto in precedenza, inizializziamo prima la matrice 2D, s[5][2]. E anche un puntatore (*p)[2], dove p è un puntatore che memorizza l’indirizzo di un array con 2 elementi,
  • Come abbiamo già detto, possiamo scomporre una matrice 2D come un array di array. Quindi in questo caso, s è effettivamente un array con 5 elementi, che sono ulteriormente array con 2 elementi per ogni riga.
  • Utilizziamo un ciclo for per attraversare questi 5 elementi dell’array, s. Per ogni iterazione, assegnamo p con l’indirizzo di s[i],
  • Inoltre, il ciclo for interno stampa gli elementi individuali dell’array s[i] usando il puntatore p. Qui, (*p + j) ci dà l’indirizzo dell’elemento individuale s[i][j], quindi usando *(*p+j) possiamo accedere al valore corrispondente.

Passaggio di una matrice 2D a una funzione

In questa sezione, impareremo come passare una matrice 2D a qualsiasi funzione e accedere agli elementi corrispondenti. Nel codice seguente, passiamo l’array a, a due funzioni show() e print() che stampa la matrice 2D passata.

#include<iostream>
using namespace std;   
 
void show(int (*q)[4], int  row, int  col)
{
	int  i, j ;
	for(i=0;i<row;i++)
	{
		for(j=0;j<col;j++)
    		cout<<"\t"<<*(*(q + i)+j); 
		cout<<"\n";
	}  
    cout<<"\n";
} 
 
void print(int  q[][4], int row, int col)
{
    int  i, j; 
    for(i=0;i<row;i++)
    {   
	 for(j=0;j<col;j++)
   	    	cout<<"\t"<<q[i][j];
   	 cout<<"\n";
	}
   cout<<"\n";
}
 
int main() 
{
  int  a[3][4] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21} ; 
 
  show (a, 3, 4);
  print (a, 3, 4);
  return 0;
}

Output:

Passing 2D Array To Functions

Qui,

  • Nella funzione show( ) abbiamo definito q come un puntatore a un array di 4 interi attraverso la dichiarazione int (*q)[4],
  • q holds the base address of the zeroth 1-D array
  • Questo indirizzo viene quindi assegnato a q, un puntatore a int, e quindi utilizzando questo puntatore vengono accessi tutti gli elementi del primo array 1D.
  • La prossima volta che il ciclo viene eseguito e i assume un valore 1, l’espressione q+i recupera l’indirizzo del primo array 1-D. Questo perché q è un puntatore al primo array 1-D e aggiungendo 1 ad esso otterremmo l’indirizzo del prossimo array 1-D. Questo indirizzo viene nuovamente assegnato a q e utilizzandolo vengono accessi tutti gli elementi del prossimo array 1-D
  • Nella seconda funzione print(), la dichiarazione di q appare così: int q[][4] ,
  • Questo è lo stesso di int (*q )[4], dove q è un puntatore a un array di 4 interi. L’unico vantaggio è che ora possiamo utilizzare l’espressione più familiare q[i][j] per accedere agli elementi dell’array. Avremmo potuto utilizzare la stessa espressione anche in show(), ma per una migliore comprensione dell’uso dei puntatori, utilizziamo i puntatori per accedere a ciascun elemento.

Conclusion

Quindi, in questo articolo, abbiamo discusso degli array bidimensionali in C++, come possiamo eseguire varie operazioni e la loro applicazione nell’addizione di matrici. Per ulteriori domande, sentiti libero di utilizzare i commenti.

Riferimenti

Source:
https://www.digitalocean.com/community/tutorials/two-dimensional-array-in-c-plus-plus