Lernen Rückgabe von Arrays aus der Funktion | Spezifikation von Funktionsrückgabewerten

Swipe um das Menü anzuzeigen

Es gibt eine entscheidende Einschränkung: Nur dynamische Arrays können von Funktionen zurückgegeben werden. Diese Einschrä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 versucht wird, ein lokal erstelltes Array zurückzugeben, tritt eine Einschränkung aufgrund des Funktionsbereichs auf (es wird versucht, die Adresse von nicht existierenden Variablen zurückzugeben, was zu einem Fehler führt).

Rückgabe eines dynamischen Arrays

Im Gegensatz zu lokalen Variablen, die beim Verlassen einer Funktion freigegeben werden, ermöglicht dynamisch mit new[] reservierter Speicher, dass Daten über den Gültigkeitsbereich der Funktion hinaus bestehen bleiben, in der sie erstellt wurden. Dadurch können Variablen, die innerhalb der Funktion erstellt wurden, über ihre Adressen angesprochen werden.

Um ein dynamisches Array zurückzugeben, müssen in der Funktionssignatur folgende Typspezifizierer verwendet werden:

dataType* für ein eindimensionales Array.
dataType** für ein zweidimensionales Array.

main.cpp


              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 reserviert 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 reservierten Integer-Arrays zurück, der nun im main()-Block verwendet werden kann.

main.cpp


              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 entspricht dem Rückgabewert eines 1D-Arrays: Der einzige Unterschied besteht darin, dass ein Zeiger auf das Array von Zeigern mit dem Typenspezifizierer int** zurückgegeben werden muss, um das 2D-Array zurückzugeben.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 2

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Abschnitt 3. Kapitel 2