C++ Dynamische Array‑Allokation: Praktischer Leitfaden mit Code‑Beispielen

Was ist ein dynamisches Array?

Ein dynamisches Array ähnelt einem regulären Array, aber seine Größe ist zur Laufzeit veränderbar. Die Elemente belegen einen zusammenhängenden Speicherblock.

Einmal erstellt, kann die Größe eines normalen Arrays nicht mehr geändert werden. Ein dynamisches Array hingegen kann seine Größe erweitern, selbst nachdem es gefüllt wurde.

Bei der Erstellung eines normalen Arrays wird ein vorbestimmter Speicherbereich reserviert. Bei einem dynamischen Array wächst der Speicherbedarf bei Bedarf um einen bestimmten Faktor.

In diesem C++‑Tutorial lernen Sie:

• Was ein dynamisches Array ist
• Faktoren, die die Performance beeinflussen
• Das new‑Schlüsselwort
• Initialisierung dynamisch allokierter Arrays
• Arrays vergrößern (Resizing)
• Dynamische Arrays löschen

Performance‑Faktoren bei dynamischen Arrays

Die initiale Größe und der Wachstumsfaktor bestimmen die Performance. Beachten Sie:

1. Kleines Array mit kleinem Wachstumsfaktor → häufige Reallokationen → Performance‑Verlust.
2. Großes Array mit großem Wachstumsfaktor → viel ungenutzter Speicher → Resize‑Operationen dauern länger → Performance‑Verlust.

Das new‑Schlüsselwort

In C++ erstellt man ein dynamisches Array mit dem new‑Schlüsselwort. Die Anzahl der zu allokierenden Elemente wird in eckigen Klammern angegeben, dem Typnamen vorangestellt. Die angeforderte Anzahl an Elementen wird allokiert.

Syntax:

zeiger_variable = new datentyp[anzahl];

zeiger_variable ist der Name der Zeigervariablen.

datentyp muss ein gültiger C++‑Datentyp sein.

Das Schlüsselwort gibt einen Zeiger auf das erste Element zurück. Nach der Erstellung kann das dynamische Array mit delete wieder freigegeben werden.

Beispiel 1:

#include <iostream>
using namespace std;
int main() {
    int x, n;
    cout << "Anzahl der Elemente eingeben:" << "\n";
    cin >> n;
    int *arr = new int[n];
    cout << "Geben Sie " << n << " Elemente ein" << endl;
    for (x = 0; x < n; x++) {
        cin >> arr[x];
    }
    cout << "Sie haben eingegeben: ";
    for (x = 0; x < n; x++) {
        cout << arr[x] << " ";
    }
    return 0;
}

Ausgabe:

Screenshot des Codes:

Code‑Erklärung:

1. iostream Header einbinden.
2. std‑Namespace nutzen.
3. main() aufrufen; Programmlogik in den Funktionskörper.
4. Zwei Integer‑Variablen x und n deklarieren.
5. Aufforderung zur Eingabe von n ausgeben.
6. Benutzereingabe lesen und n zuweisen.
7. Dynamisches Array für n Integer anlegen, Zeiger *arr zuweisen.
8. Aufforderung zur Eingabe der n Elemente.
9. for‑Schleife mit Zählvariable x über die Eingaben iterieren.
10. Eingegebene Elemente in Array arr speichern.
11. Schleifenende.
12. Text ausgeben.
13. Zweite for‑Schleife über Array‑Elemente.
14. Array‑Inhalte auf Konsole ausgeben.
15. Schleifenende.
16. Programm gibt bei Erfolg Wert zurück.
17. Ende von main().

HINWEIS: Im obigen Beispiel darf der Benutzer zur Laufzeit eine beliebige Array‑Größe angeben – die Größe wird also zur Laufzeit bestimmt.

Initialisierung dynamisch allokierter Arrays

Ein dynamisches Array einfach mit 0 zu initialisieren:

Syntax:

int *array{ new int[laenge]{} };

In der obigen Syntax steht laenge für die Elementanzahl. Da wir mit 0 initialisieren, bleibt die Initialisierungsliste leer.

Man kann auch eine Initialisierungsliste verwenden. Hier ein Beispiel:

Beispiel 2:

#include <iostream>
using namespace std;
int main(void) {
    int x;
    int *array{ new int[5]{ 10, 7, 15, 3, 11 } };
    cout << "Array‑Elemente: " << endl;
    for (x = 0; x < 5; x++) {
        cout << array[x] << endl;
    }
    return 0;
}

Ausgabe:

Screenshot des Codes:

Code‑Erklärung:

1. iostream Header einbinden.
2. std‑Namespace nutzen.
3. main() aufrufen.
4. Integer‑Variable x deklarieren.
5. Dynamisches Array array mit Initialisierungsliste deklarieren (5 Integer). Beachten Sie: kein = zwischen Länge und Liste.
6. Text ausgeben; endl bedeutet Zeilenende.
7. for‑Schleife über Array‑Elemente.
8. Array‑Inhalte auf Konsole ausgeben.
9. Schleifenende.
10. Programm gibt bei Erfolg Wert zurück.
11. Ende von main().

Arrays vergrößern (Resizing)

Die Länge eines dynamischen Arrays wird bei der Allokation festgelegt. C++ bietet keinen eingebauten Mechanismus, um ein Array nach der Allokation zu vergrößern.

Man kann dies umgehen, indem man ein neues Array allokiert, die Elemente kopiert und das alte Array löscht. Hinweis: Diese Technik ist fehleranfällig – vermeiden Sie sie wenn möglich.

Dynamische Arrays löschen

Ein dynamisches Array sollte nach Erfüllung seines Zwecks aus dem Speicher freigegeben werden. Der delete‑Befehl bewirkt dies. Der freigegebene Speicher kann dann für andere Daten genutzt werden. Auch ohne explizites delete wird der Speicher beim Programmende automatisch freigegeben.

Wichtig:

Zum Löschen eines dynamischen Arrays muss delete[] verwendet werden, nicht delete. Die eckigen Klammern weisen die CPU an, mehrere Variablen (das gesamte Array) zu löschen. Die Verwendung von delete statt delete[] kann zu Speicherlecks, Datenkorruption, Abstürzen etc. führen.

Beispiel 3:

#include <iostream>
using namespace std;
int main() {
    int x, n;
    cout << "Wie viele Zahlen werden Sie eingeben?" << "\n";
    cin >> n;
    int *arr = new int[n];
    cout << "Geben Sie " << n << " Zahlen ein" << endl;
    for (x = 0; x < n; x++) {
        cin >> arr[x];
    }
    cout << "Sie haben eingegeben: ";
    for (x = 0; x < n; x++) {
        cout << arr[x] << " ";
    }
    cout << endl;
    delete [] arr;
    return 0;
}

Ausgabe:

Screenshot des Codes:

Code‑Erklärung:

1. iostream Header einbinden.
2. std‑Namespace nutzen.
3. main() aufrufen.
4. Zwei Integer‑Variablen x, n deklarieren.
5. Aufforderung zur Eingabe der Anzahl Zahlen.
6. Benutzereingabe lesen → n.
7. Zeiger *arr für Array mit n Integer allokieren.
8. Aufforderung zur Eingabe der n Zahlen.
9. for‑Schleife mit Zählvariable x über Eingaben.
10. Eingelesene Zahlen in arr speichern.
11. Schleifenende.
12. Text ausgeben.
13. Zweite for‑Schleife über Array‑Inhalte.
14. Array‑Werte auf Konsole ausgeben.
15. Schleifenende.
16. Leere Zeile ausgeben.
17. Speicher von arr freigeben (delete [] arr).
18. Programm gibt bei Erfolg Wert zurück.
19. Ende von main().

Zusammenfassung:

• Reguläre Arrays haben feste Größe; nach Deklaration nicht änderbar.
• Bei regulären Arrays wird Speicher zur Compile‑Zeit festgelegt.
• Dynamische Arrays: Größe zur Laufzeit änderbar.
• Dynamische Arrays in C++ mit new deklarieren.
• Eckige Klammern für Anzahl der Elemente angeben.
• Nach Nutzung Speicher mit delete freigeben.
• delete[] für gesamten Array‑Speicher; delete nur für einzelnes Element.
• Kein eingebauter Resize‑Mechanismus für C++‑Arrays.
• Initialisierung per Initialisierungsliste ohne =‑Operator.