Arrays an Funktionen in C++ übergeben: Ein praktischer Leitfaden

Arrays an Funktionen in C++ übergeben

Dieser Leitfaden erklärt, wie man ein- und mehrdimensionale Arrays an Funktionen in C++ übergibt, mit echten Code-Beispielen.

In C++ können Arrays als Funktionsargumente übergeben werden, und Sie können sie sogar indirekt über Zeiger zurückgeben. Das Verständnis der Mechanik hinter dem Array-Zerfall zu Zeigern und der Auswirkung auf Speicher und Leistung ist essenziell für effizienten Code.

---

Syntax für das Übergeben von Arrays als Funktionsparameter

Die Deklaration für eine Funktion, die ein Array akzeptiert, sieht so aus:

returnType functionName(dataType arrayName[arraySize])
{
    // function body
}

Beispiel:

int total(int marks[5])
{
    // implementation
}

Hier ist marks ein int-Array mit fünf Elementen. Beim Funktionsaufruf wird nur der Arrayname (ein Zeiger auf das erste Element) übergeben.

---

Beispiel 1: Eindimensionales Array an eine Funktion übergeben

#include <iostream>
using namespace std;

// Funktion deklarieren, um Noten anzuzeigen
void display(int m[5])
{
    cout << "Displaying marks:" << endl;
    for (int i = 0; i < 5; ++i)
    {
        cout << "Student " << i + 1 << ": " << m[i] << endl;
    }
}

int main()
{
    int marks[5] = {88, 76, 90, 61, 69};
    display(marks); // Array über Namen übergeben
    return 0;
}

Ausgabe

Displaying marks:
Student 1: 88
Student 2: 76
Student 3: 90
Student 4: 61
Student 5: 69

Wichtige Punkte:

1. Der Aufruf display(marks); übergibt die Adresse von marks[0].
2. Innerhalb der Funktion wird int m[5] als int* m; behandelt und zeigt auf denselben Speicher.
3. Das Modifizieren von m[i] ändert das ursprüngliche marks-Array, was Pass-by-Reference-Semantik veranschaulicht.

---

Mehrdimensionales Array an eine Funktion übergeben

Für 2-D-Arrays müssen Sie die Spaltenanzahl (die Größe der zweiten Dimension) angeben, damit der Compiler Element-Offsets berechnen kann.

Beispiel 2: Zweidimensionales Array an eine Funktion übergeben

#include <iostream>
using namespace std;

void display(int n[][2])
{
    cout << "Displaying values:" << endl;
    for (int i = 0; i < 3; ++i)
    {
        for (int j = 0; j < 2; ++j)
        {
            cout << "num[" << i << "][" << j << "]: " << n[i][j] << endl;
        }
    }
}

int main()
{
    int num[3][2] = {{3, 4}, {9, 5}, {7, 1}};
    display(num);
    return 0;
}

Ausgabe

Displaying values:
num[0][0]: 3
num[0][1]: 4
num[1][0]: 9
num[1][1]: 5
num[2][0]: 7
num[2][1]: 1

Hinweise:

• Die Zeilenanzahl (3) ist optional, da der Compiler sie aus der Array-Definition ableiten kann.
• Die Angabe der Spaltengröße ([][2]) ist zwingend für korrekte Zeigerarithmetik.

Höherdimensionale Arrays folgen derselben Regel: Die Größe aller Dimensionen außer der ersten muss angegeben werden.

---

Ein Array von einer Funktion zurückgeben

Funktionen können kein ganzes Array direkt zurückgeben. Stattdessen geben sie einen Zeiger auf das erste Element zurück, der auf ein statisch allokiertes Array, ein dynamisches Array oder ein temporäres Objekt verweisen kann. Vorsicht ist geboten, um keine Zeiger auf lokale (Stack-)Arrays zurückzugeben, was zu hängenden Referenzen führen würde.

Beispiel (statisches Array):

int* getArray()
{
    static int arr[5] = {1, 2, 3, 4, 5};
    return arr; // Zeiger auf erstes Element
}

Für dynamische Allokation erwägen Sie die Rückgabe eines std::vector<T> für Sicherheit und automatisches Speichermanagement.

Weiterführende Literatur zum sicheren Array-Handling in C++ wird für Produktionscode empfohlen.