Arrays aus der Funktion Zurückgeben

Ähnlich wie einfache Datentypen können Arrays als Funktionsresultate zurückgegeben werden.

Es gibt jedoch eine entscheidende Einschränkung: nur dynamische Arrays können aus Funktionen zurückgegeben werden. Diese Beschränkung ergibt sich aus dem lokalen Gültigkeitsbereich von Funktionen; statische Arrays, die innerhalb einer Funktion erstellt werden, sind nur innerhalb dieser Funktion zugänglich.

Wenn Sie versuchen, ein lokal erstelltes Array zurückzugeben, stoßen Sie auf eine Einschränkung aufgrund des Gültigkeitsbereichs der Funktion (Sie versuchen, eine Adresse von nicht existierenden Variablen zurückzugeben, was zu einem Fehler führt).

Rückgabe eines dynamischen Arrays

Warum können wir dynamische Arrays zurückgeben?
Im Gegensatz zu lokalen Variablen, die freigegeben werden, wenn eine Funktion beendet wird, ermöglicht dynamischer Speicher, der mit new[] zugewiesen wurde, dass Daten über den Gültigkeitsbereich der erstellenden Funktion hinaus bestehen bleiben. Dadurch können wir auf innerhalb der Funktion erstellte Variablen über ihre Adressen zugreifen.
Um ein dynamisches Array zurückzugeben, müssen wir die folgenden Typbezeichner in der Funktionssignatur verwenden:

dataType* für ein 1D-Array.
dataType** für ein 2D-Array.

Rückgabe eines 1D-Arrays

main


              12345678910111213141516171819
            
#include <iostream>

// Function to create and return a dynamic 1D array
int* createArray(const int size)
{
    int* arr = new int[size];
    for (int i = 0; i < size; ++i)
        arr[i] = i + 1; // Example initialization
    return arr;
}

int main()
{
    int size = 5;
    int* myArray = createArray(size);

    // Don't forget to delete the dynamically allocated memory
    delete[] myArray;
}

Die Funktion allokiert dynamisch Speicher für ein Integer-Array der angegebenen Größe. Sie initialisiert die Array-Elemente mit Werten von 1 bis zur size des Arrays. Die Funktion gibt einen Zeiger auf das erste Element des dynamisch allozierten Integer-Arrays zurück, der nun im main()-Block verwendet werden kann.

Rückgabe eines 2D-Arrays

main


              1234567891011121314151617181920212223242526272829303132333435
            
#include <iostream>

// Function to create and return a dynamic 2D array
int** createArray(const int rows, const int cols) {
    int** arr = new int*[rows];
    for (int i = 0; i < rows; ++i) {
        arr[i] = new int[cols];
        for (int j = 0; j < cols; ++j) {
            arr[i][j] = i * cols + j + 1; // Example initialization
        }
    }
    return arr;
}

int main() {
    int rows = 3;
    int cols = 2;
    int** myArray = createArray(rows, cols);
    
    // Use the returned 2D array
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << myArray[i][j] << " ";
        }
        std::cout << std::endl;
    }
    
    // Don't forget to delete the dynamically allocated memory
    for (int i = 0; i < rows; ++i) {
        delete[] myArray[i];
    }
    delete[] myArray;
    
    return 0;
}

Das Prinzip ist dasselbe wie bei der Rückgabe eines 1D-Arrays: Der einzige Unterschied besteht darin, dass wir einen Zeiger auf das Array von Zeigern zurückgeben müssen, indem wir den int** Typ-Spezifizierer verwenden, um das 2D-Array zurückzugeben.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 2