Zweidimensionales Array in C++

Tutorials

Einführung

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.

Initialisierung eines 2D-Arrays in C++

Also, wie initialisieren wir ein zweidimensionales Array in C++? Ganz einfach:

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

Wie Sie sehen können, initialisieren wir ein 2D-Array arr mit 4 Zeilen und 2 Spalten als Array von Arrays. Jedes Element des Arrays ist wiederum ein Array von Ganzzahlen.

Wir können auch ein 2D-Array auf folgende Weise initialisieren.

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

Auch in diesem Fall ist arr ein 2D-Array mit 4 Zeilen und 2 Spalten.

Drucken eines 2D-Arrays in C++

Wir haben die Initialisierung eines 2D-Arrays abgeschlossen, aber ohne es tatsächlich auszudrucken, können wir nicht bestätigen, dass es korrekt durchgeführt wurde.

Außerdem müssen wir in vielen Fällen ein resultierendes 2D-Array nach Durchführung einiger Operationen darauf drucken. Wie machen wir das?

Der folgende Code zeigt uns, wie wir das tun können.

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

Ausgabe:

Printing A 2D Array

In dem obigen Code,

  • Wir initialisieren zunächst ein 2D-Array, arr[4][2], mit bestimmten Werten,
  • Danach versuchen wir, das entsprechende Array mithilfe von zwei verschachtelten Schleifen zu drucken,
  • Die äußere Schleife durchläuft die Zeilen, während die innere Schleife die Spalten des 2D-Arrays durchläuft,
  • Für jede Iteration der äußeren Schleife erhöht sich i und führt uns zum nächsten 1D-Array. Außerdem durchläuft die innere Schleife jeweils das gesamte 1D-Array,
  • Und entsprechend drucken wir das einzelne Element arr[i][j].

Aufnahme von 2D-Array-Elementen als Benutzereingabe

Zuvor haben wir gesehen, wie wir ein 2D-Array mit vordefinierten Werten initialisieren können. Aber wir können es auch als Benutzereingabe machen. Schauen wir uns an, wie das geht

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

Ausgabe:

2D Array User Input

Für den obigen Code deklarieren wir ein 2×2 2D-Array s. Mithilfe von zwei verschachtelten Schleifen durchlaufen wir jedes Element des Arrays und nehmen die entsprechenden Benutzereingaben entgegen. Auf diese Weise wird das gesamte Array gefüllt, und wir drucken es aus, um die Ergebnisse zu sehen.

Matrixaddition mit zweidimensionalen Arrays in C++

Als Beispiel sehen wir uns an, wie wir 2D-Arrays verwenden können, um die Matrixaddition durchzuführen und das Ergebnis auszugeben.

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

Ausgabe:

Matrix Addition Using 2D Arrays

Hier,

  • nehmen wir zwei Matrizen m1 und m2 mit maximal 5 Zeilen und 5 Spalten. Und eine weitere Matrix m3, in der wir das Ergebnis speichern werden,
  • Als Benutzereingabe haben wir die Anzahl der Zeilen und Spalten für beide Matrizen genommen. Da wir eine Matrixaddition durchführen, sollte die Anzahl der Zeilen und Spalten für beide Matrizen gleich sein,
  • Danach nehmen wir beide Matrizen wieder mithilfe verschachtelter for-Schleifen als Benutzereingabe entgegen,
  • An diesem Punkt haben wir beide Matrizen m1 und m2,
  • dann durchlaufen wir die Matrix m3 mit zwei for-Schleifen und aktualisieren die entsprechenden Elemente m3[i][j] um den Wert von m1[i][j]+m2[i][j]. Auf diese Weise erhalten wir am Ende der äußeren for-Schleife unsere gewünschte Matrix,
  • Zuletzt geben wir die resultierende Matrix m3 aus.

Zeiger auf ein 2D-Array in C++

Wenn wir einen Zeiger auf einen Integer, einen Zeiger auf einen Float, einen Zeiger auf einen Char haben können, warum können wir dann nicht auch einen Zeiger auf ein Array haben? Das können wir sicherlich. Das folgende Programm zeigt, wie man ihn erstellt und verwendet.

#include<iostream>
using namespace std;
/* Verwendung eines Zeigers auf ein 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;
      } 
      
}

Ausgabe:

2D Array Pointer

Hier,

  • In dem obigen Code versuchen wir, ein 2D-Array unter Verwendung von Zeigern auszudrucken,
  • Wie wir zuvor getan haben, initialisieren wir zunächst das 2D-Array, s[5][2]. Und auch einen Zeiger (*p)[2], wobei p ein Zeiger ist, der die Adresse eines Arrays mit 2 Elementen speichert,
  • Wie wir bereits gesagt haben, können wir ein 2D-Array als Array von Arrays aufteilen. In diesem Fall ist also s tatsächlich ein Array mit 5 Elementen, die weiterhin tatsächlich Arrays mit 2 Elementen für jede Zeile sind.
  • Wir verwenden eine for-Schleife, um diese 5 Elemente des Arrays s zu durchlaufen. In jeder Iteration weisen wir p die Adresse von s[i] zu,
  • Des Weiteren druckt die innere Schleife die einzelnen Elemente des Arrays s[i] unter Verwendung des Zeigers p aus. Hier gibt uns (*p + j) die Adresse des einzelnen Elements s[i][j], sodass wir unter Verwendung von *(*p+j) auf den entsprechenden Wert zugreifen können.

Übergabe eines 2D-Arrays an eine Funktion

In diesem Abschnitt werden wir lernen, wie man ein 2D-Array an eine Funktion übergibt und auf die entsprechenden Elemente zugreift. Im folgenden Code übergeben wir das Array a an zwei Funktionen show() und print(), die das übergebene 2D-Array ausgeben.

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

Ausgabe:

Passing 2D Array To Functions

Hier,

  • in der Funktion show( ) haben wir q definiert, um ein Zeiger auf ein Array von 4 Ganzzahlen durch die Deklaration int (*q)[4] zu sein,
  • q holds the base address of the zeroth 1-D array
  • Diese Adresse wird dann an q zugewiesen, ein int-Zeiger, und dann werden mit diesem Zeiger alle Elemente des nullten 1D-Arrays zugegriffen.
  • Das nächste Mal durch die Schleife, wenn i den Wert 1 annimmt, holt der Ausdruck q+i die Adresse des ersten 1-D-Arrays. Dies liegt daran, dass q ein Zeiger auf das nullte 1-D-Array ist und das Hinzufügen von 1 dazu uns die Adresse des nächsten 1-D-Arrays geben würde. Diese Adresse wird erneut an q zugewiesen und unter Verwendung davon werden alle Elemente des nächsten 1-D-Arrays zugegriffen
  • In der zweiten Funktion print() sieht die Deklaration von q so aus: int q[][4],
  • Dies ist dasselbe wie int (*q )[4], wobei q ein Zeiger auf ein Array von 4 Ganzzahlen ist. Der einzige Vorteil besteht darin, dass wir jetzt den vertrauteren Ausdruck q[i][j] verwenden können, um auf Arrayelemente zuzugreifen. Wir hätten denselben Ausdruck auch in show() verwenden können, aber für ein besseres Verständnis der Verwendung von Zeigern verwenden wir Zeiger, um auf jedes Element zuzugreifen.

Schlussfolgerung

Also, in diesem Artikel haben wir zweidimensionale Arrays in C++ diskutiert, wie wir verschiedene Operationen durchführen können sowie deren Anwendung bei der Matrixaddition. Bei weiteren Fragen können Sie gerne die Kommentare nutzen.

Referenzen

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