Zweidimensionales Array in C++

Einführung

Ein zweidimensionales Array in C++ ist die einfachste Form eines mehrdimensionalen Arrays. Es kann als ein Array von Arrays visualisiert werden. Das folgende Bild zeigt ein zweidimensionales Array.

Ein zweidimensionales Array wird auch als Matrix bezeichnet. Es kann jeden Typ haben, wie Ganzzahl, Zeichen, Gleitkommazahlen, usw., abhängig von der Initialisierung. Im nächsten Abschnitt werden wir besprechen, wie wir zweidimensionale Arrays initialisieren können.

Initialisieren eines 2D-Arrays in C++

Wie initialisieren wir also ein zweidimensionales Array in C++? So einfach wie das:

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

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

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

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

Ein 2D-Array in C++ ausgeben

Wir haben nun ein 2D-Array initialisiert, aber ohne es tatsächlich auszugeben, können wir nicht bestätigen, dass dies korrekt erfolgt ist.

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

Der folgende Code zeigt uns, wie wir das machen 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;
        }
    }

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 Schleifen auszugeben,
• Die äußere Schleife durchläuft die Zeilen, während die innere Schleife die Spalten des 2D-Arrays durchläuft,
• Also erhöht sich bei jeder Iteration der äußeren Schleife der Wert von i und führt uns zur nächsten 1D-Array. Ebenso durchläuft die innere Schleife das gesamte 1D-Array,
• Und entsprechend geben wir das einzelne Element arr[ i ][ j ] aus.

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 für Benutzereingaben verwenden. 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;
        } 
    }

Für den obigen Code deklarieren wir ein 2X2 2D-Array s. Mit 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 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;
        } 
        
    }

Hierbei:

• 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 verwendet. Da wir eine Matrixaddition durchführen, sollten die Anzahl der Zeilen und Spalten für beide Matrizen gleich sein,
• Danach nehmen wir beide Matrizen als Benutzereingaben an, wieder mit verschachtelten Schleifen,
• Jetzt haben wir sowohl die Matrizen m1 als auch m2,
• Dann durchlaufen wir die Matrix m3 mithilfe von zwei 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 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 eine ganze Zahl, einen Zeiger auf eine Fließkommazahl oder einen Zeiger auf einen Buchstaben haben können, können wir dann nicht auch einen Zeiger auf ein Array haben? Sicherlich können wir das. Das folgende Programm zeigt, wie man es erstellt und verwendet:

#include<iostream>
    using namespace std;
    /* Usage of pointer to an 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;
        } 
        
    }

Hierbei:

• versuchen wir in dem oben gezeigten Code, ein 2D-Array mithilfe von Zeigern auszugeben,
• Wie zuvor, initialisieren wir zuerst 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 bereits erwähnt, können wir ein 2D-Array als ein Array von Arrays aufteilen. In diesem Fall ist s tatsächlich ein Array mit 5 Elementen, die wiederum tatsächlich Arrays mit jeweils 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,
• Weiterhin gibt die innere For-Schleife die einzelnen Elemente des Arrays s[i] mithilfe des Zeigers p aus. Hier gibt uns (*p + j) die Adresse des einzelnen Elements s[i][j], sodass wir über *(*p+j) auf den entsprechenden Wert zugreifen können.

Übergabe eines 2D-Arrays an eine Funktion

In diesem Abschnitt lernen wir, wie man ein 2D-Array an eine beliebige 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;
    } 

Hierbei:

• haben wir in der Funktion show() q als Zeiger auf ein Array aus 4 ganzen Zahlen definiert, indem wir int (*q)[4] deklarieren,
• q hält die Basisadresse des nullten 1D-Arrays,
• Diese Adresse wird dann q zugewiesen, einem int-Zeiger, und mit diesem Zeiger werden alle Elemente des nullten 1D-Arrays abgerufen,
• Wenn i beim nächsten Durchlauf den Wert 1 annimmt, holt der Ausdruck q+i die Adresse des ersten 1D-Arrays. Dies liegt daran, dass q ein Zeiger auf das nullte 1D-Array ist und das Hinzufügen von 1 dazu uns die Adresse des nächsten 1D-Arrays gibt. Diese Adresse wird erneut q zugewiesen, und mit ihr werden alle Elemente des nächsten 1D-Arrays abgerufen,
• In der zweiten Funktion print() sieht die Deklaration von q so aus: int q[][4],
• Dies entspricht int (*q )[4], wobei q ein Zeiger auf ein Array aus 4 ganzen Zahlen ist. Der einzige Vorteil besteht darin, dass wir jetzt den vertrauteren Ausdruck q[i][j] verwenden können, um auf Array-Elemente 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.

Fazit

In diesem Artikel haben wir also zweidimensionale Arrays in C++ diskutiert, wie wir verschiedene Operationen durchführen können und deren Anwendung bei der Matrixaddition.