Dynamisches Array als Argument der Funktion Übergeben

In C++ ist ein dynamisches Array ein Array, dessen Größe während der Laufzeit geändert werden kann. Im Gegensatz zu statischen Arrays, bei denen die Größe zur Kompilierungszeit festgelegt ist, ermöglichen dynamische Arrays Ihnen, zur Laufzeit Speicher für das Array zu reservieren und es nach Bedarf zu vergrößern oder zu verkleinern.

Betrachten wir, wie man eindimensionale und zweidimensionale dynamische Arrays als Funktionsargumente übergibt.

Übergabe eines eindimensionalen Arrays

In C++ können Sie ein eindimensionales dynamisches Array an eine Funktion übergeben, indem Sie einen Zeiger auf das Array zusammen mit der Arraygröße als separaten Parameter übermitteln. Da Arrays beim Übergeben an Funktionen in Zeiger zerfallen, können Sie einen Zeiger auf das erste Element des Arrays übergeben. So können Sie es machen:

main


              123456789101112131415161718192021222324252627
            
#include <iostream>

// Function that takes a dynamic array and its size as parameters
void processArray(int* arr, const int size) 
{
    // Access elements of the array using the pointer and the size
    for (int i = 0; i < size; ++i)
        std::cout << arr[i] << " "; // cout instead of std::cout
    
    std::cout << std::endl; // endl instead of std::endl
}

int main() 
{
    // Dynamic array allocation
    int size = 5;
    int* dynamicArray = new int[size];
    
    // Initializing the dynamic array
    for (int i = 0; i < size; ++i)
        dynamicArray[i] = i * 2;
    
    // Passing the dynamic array to the function
    processArray(dynamicArray, size);
    // Deallocate the dynamic array to prevent memory leaks
    delete[] dynamicArray;
}

In diesem Beispiel ist processArray() eine Funktion, die ein dynamisches Integer-Array (unter Verwendung des Typspezifikators int*) und dessen Größe als Parameter nimmt. Ein dynamisches Array der Größe 5 wird in der main() Funktion erstellt und initialisiert. Anschließend wird die Funktion processArray() aufgerufen, wobei das dynamische Array über seinen Namen und seine Größe als Argumente übergeben wird.

Übergabe eines 2-dimensionalen Arrays

Beim Umgang mit einem dynamischen 2-dimensionalen Array (ein Array von Zeigern, bei dem jeder Zeiger auf ein Array von Elementen zeigt) können Sie es zusammen mit den Dimensionen als Zeiger auf einen Zeiger an eine Funktion übergeben. So können Sie das tun:

main


              1234567891011121314151617181920212223242526272829303132333435
            
#include <iostream>

// Function to fill a dynamic 2D array with values
void fillDynamic2DArray(int** arr, const int rows, const int cols) {
    // Fill the array with values (for demonstration purposes)
    for (int i = 0; i < rows; ++i)
        for (int j = 0; j < cols; ++j)
            arr[i][j] = i * cols + j; // You can modify this line to fill the array as desired

    // Print the filled array
    std::cout << "Filled Dynamic 2D Array:" << std::endl;
    for (int i = 0; i < rows; ++i)
        for (int j = 0; j < cols; ++j)
            std::cout << arr[i][j] << " ";
        std::cout << std::endl;
}

int main()
{
    int rows = 3;
    int cols = 4;

    // Allocate a dynamic 2D array in the main function
    int** dynamic2DArray = new int*[rows];
    for (int i = 0; i < rows; ++i)
        dynamic2DArray[i] = new int[cols];

    // Call the function to fill and print the dynamic 2D array
    fillDynamic2DArray(dynamic2DArray, rows, cols);

    // Deallocate the dynamic 2D array
    for (int i = 0; i < rows; ++i)
        delete[] dynamic2DArray[i];
    delete[] dynamic2DArray;
}

In diesem Beispiel nimmt die fillDynamic2DArray() Funktion ein dynamisch alloziertes 2D-Array als Eingabe (unter Verwendung des int** Typ-Spezifikators) zusammen mit seinen Dimensionen und füllt es mit Werten. Wir verwenden den Namen des Arrays, um es als Argument zu übergeben.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 5