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

Wie bei einfachen Datentypen können auch Arrays als Funktionsrückgabewerte verwendet werden.

Es gibt jedoch 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 Funktions-Gültigkeitsbereichs auf (es wird versucht, die 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 beim Verlassen einer Funktion freigegeben werden, bleibt dynamisch mit new[] reservierter Speicher auch nach dem Verlassen des Funktionsbereichs erhalten. Dadurch können wir auf innerhalb der Funktion erstellte Variablen über deren Adressen zugreifen.
Um ein dynamisches Array zurückzugeben, müssen in der Funktionssignatur folgende Typspezifizierer verwendet werden:

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

Rückgabe eines 1D-Arrays

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 weist dynamisch Speicher für ein Integer-Array der angegebenen Größe zu. 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 zugewiesenen Integer-Arrays zurück, der nun im main()-Block verwendet werden kann.

Rückgabe eines 2D-Arrays

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 ist dasselbe wie bei der Rückgabe eines 1D-Arrays: Der einzige Unterschied besteht darin, dass wir einen Zeiger auf das Array von Zeigern mit dem Typenspezifizierer int** zurückgeben müssen, 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

Suggested prompts:

Can you give an example of a function that returns a dynamic 1D array?

What happens if I try to return a static array from a function?

Can you explain how to properly free the memory of a returned dynamic array?

Awesome!

Completion rate improved to 5

Swipe um das Menü anzuzeigen

Wie bei einfachen Datentypen können auch Arrays als Funktionsrückgabewerte verwendet werden.

Rückgabe eines dynamischen Arrays

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

Rückgabe eines 1D-Arrays

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

Rückgabe eines 2D-Arrays

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

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 2