Tableau bidimensionnel en C++

Tutoriels

Introduction

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.

Initialisation d’un tableau à deux dimensions en C++

Alors, comment initialisons-nous un tableau à deux dimensions en C++ ? Aussi simple que cela :

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

Comme vous pouvez le voir, nous initialisons un tableau à deux dimensions arr, avec 4 lignes et 2 colonnes en tant que tableau de tableaux. Chaque élément du tableau est lui-même un tableau d’entiers.

Nous pouvons également initialiser un tableau à deux dimensions de la manière suivante.

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

Dans ce cas également, arr est un tableau à deux dimensions avec 4 lignes et 2 colonnes.

Impression d’un tableau à deux dimensions en C++

Nous avons terminé l’initialisation d’un tableau à deux dimensions, maintenant sans l’imprimer réellement, nous ne pouvons pas confirmer que cela a été fait correctement.

Aussi, dans de nombreux cas, nous pouvons avoir besoin d’imprimer un tableau à deux dimensions résultant après avoir effectué certaines opérations dessus. Comment faisons-nous cela ?

Le code ci-dessous nous montre comment nous pouvons le faire.

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

Sortie:

Printing A 2D Array

Dans le code ci-dessus,

  • Nous initialisons d’abord un tableau à deux dimensions, arr[4][2], avec certaines valeurs.
  • Ensuite, nous essayons d’imprimer le tableau correspondant en utilisant deux boucles for.
  • La boucle externe parcourt les lignes, tandis que la boucle interne parcourt les colonnes du tableau à deux dimensions.
  • Ainsi, à chaque itération de la boucle externe, i augmente et nous amène au prochain tableau à une dimension. De plus, la boucle interne parcourt tout le tableau à une dimension à la fois.
  • Et en conséquence, nous imprimons l’élément individuel arr[i][j].

Prendre les éléments du tableau à deux dimensions en tant qu’entrée utilisateur

Auparavant, nous avons vu comment nous pouvons initialiser un tableau à deux dimensions avec des valeurs prédéfinies. Mais nous pouvons également le faire avec une entrée utilisateur. Voyons comment

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

Sortie:

2D Array User Input

Pour le code ci-dessus, nous déclarons un tableau à deux dimensions 2X2 appelé s. En utilisant deux boucles for imbriquées, nous parcourons chaque élément du tableau et prenons les entrées utilisateur correspondantes. De cette manière, le tableau entier se remplit et nous l’imprimons pour voir les résultats.

Addition de matrices en utilisant des tableaux à deux dimensions en C++

À titre d’exemple, voyons comment nous pouvons utiliser des tableaux 2D pour effectuer une addition de matrices et afficher le résultat.

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

Sortie:

Matrix Addition Using 2D Arrays

Ici,

  • Nous prenons deux matrices m1 et m2 avec un maximum de 5 lignes et 5 colonnes. Et une autre matrice m3 dans laquelle nous allons stocker le résultat,
  • En tant qu’entrée utilisateur, nous avons pris le nombre de lignes et de colonnes pour les deux matrices. Puisque nous effectuons une addition de matrices, le nombre de lignes et de colonnes doit être le même pour les deux matrices,
  • Ensuite, nous prenons les deux matrices en tant qu’entrées utilisateur, en utilisant à nouveau des boucles for imbriquées,
  • À ce stade, nous avons les deux matrices m1 et m2,
  • puis nous parcourons la matrice m3, en utilisant deux boucles for et en mettant à jour les éléments respectifs m3[i][j] avec la valeur de m1[i][j]+m2[i][j]. De cette manière, à la fin de la boucle for externe, nous obtenons notre matrice souhaitée,
  • Enfin, nous imprimons la matrice résultante m3.

Pointeur vers un tableau 2D en C++

Si nous pouvons avoir un pointeur vers un entier, un pointeur vers un flottant, un pointeur vers un caractère, ne pouvons-nous pas avoir un pointeur vers un tableau ? Nous le pouvons certainement. Le programme suivant montre comment le construire et l’utiliser.

#include<iostream>
using namespace std;
/* Utilisation d'un pointeur vers un tableau */ 
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;
      } 
      
}

Sortie:

2D Array Pointer

Ici,

  • Dans le code ci-dessus, nous essayons d’imprimer un tableau 2D à l’aide de pointeurs,
  • Comme nous l’avons déjà fait, nous initialisons d’abord le tableau 2D, s[5][2]. Et aussi un pointeur (*p)[2], où p est un pointeur qui stocke l’adresse d’un tableau avec 2 éléments,
  • Comme nous l’avons déjà dit, nous pouvons décomposer un tableau 2D en un tableau de tableaux. Donc dans ce cas, s est en fait un tableau avec 5 éléments, qui sont eux-mêmes des tableaux avec 2 éléments pour chaque ligne.
  • Nous utilisons une boucle for pour parcourir ces 5 éléments du tableau, s. À chaque itération, nous attribuons p avec l’adresse de s[i],
  • De plus, la boucle interne imprime les éléments individuels du tableau s[i] en utilisant le pointeur p. Ici, (*p + j) nous donne l’adresse de l’élément individuel s[i][j], donc en utilisant *(*p+j) nous pouvons accéder à la valeur correspondante.

Passer un tableau 2D à une fonction

Dans cette section, nous allons apprendre comment passer un tableau 2D à n’importe quelle fonction et accéder aux éléments correspondants. Dans le code ci-dessous, nous passons le tableau a à deux fonctions show() et print() qui impriment le tableau 2D passé.

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

Sortie:

Passing 2D Array To Functions

Ici,

  • Dans la fonction show( ), nous avons défini q comme un pointeur vers un tableau de 4 entiers grâce à la déclaration int (*q)[4],
  • q holds the base address of the zeroth 1-D array
  • Cette adresse est ensuite assignée à q, un pointeur int, et ensuite en utilisant ce pointeur tous les éléments du premier tableau 1D sont accédés.
  • La prochaine fois que la boucle est exécutée lorsque i prend une valeur de 1, l’expression q+i récupère l’adresse du premier tableau 1-D. Cela est dû au fait que q est un pointeur vers le premier tableau 1-D et en ajoutant 1, nous obtenons l’adresse du prochain tableau 1-D. Cette adresse est à nouveau assignée à q et en utilisant cette adresse, tous les éléments du prochain tableau 1-D sont accédés.
  • Dans la deuxième fonction print(), la déclaration de q ressemble à ceci: int q[][4],
  • C’est la même chose que int (*q )[4], où q est un pointeur vers un tableau de 4 entiers. La seule différence est que nous pouvons maintenant utiliser l’expression plus familière q[i][j] pour accéder aux éléments du tableau. Nous aurions pu utiliser la même expression dans show() mais pour une meilleure compréhension de l’utilisation des pointeurs, nous utilisons des pointeurs pour accéder à chaque élément.

Conclusion

Ainsi, dans cet article, nous avons discuté des tableaux bidimensionnels en C++, de la façon dont nous pouvons effectuer diverses opérations ainsi que de leur application dans l’addition de matrices. Pour toute question supplémentaire, n’hésitez pas à utiliser les commentaires.

Références

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