C++ Dynamische Array‑Allocatie: Praktische Handleiding met Code‑Voorbeelden

Wat is een Dynamische Array?

Een dynamische array lijkt sterk op een gewone array, maar de grootte is wijzigbaar tijdens de uitvoering van het programma. Elementen van een dynamische array bezetten een aaneengesloten geheugenblok.

Eenmaal een array gecreëerd, kan de grootte niet meer veranderd worden. Een dynamische array is anders: het kan zijn grootte uitbreiden zelfs nadat het gevuld is.

Tijdens de creatie van een array wordt een vooraf bepaalde hoeveelheid geheugen toegekend. Dit is niet het geval bij een dynamische array, want die vergroot het geheugen met een bepaalde factor wanneer er behoefte is.

In deze C++ tutorial leer je:

• Wat is een dynamische array?
• Factoren die de prestaties van dynamische arrays beïnvloeden
• Het new-keyword
• Initialiseren van dynamisch toegewezen arrays
• Arrays resizen
• Dynamisch arrays verwijderen

Factoren die Prestaties Beïnvloeden

De initiële grootte van de array en de groeifactor bepalen de prestaties. Let op:

1. Als een array een kleine grootte en een kleine groeifactor heeft, zal het vaker geheugen heralloceren. Dit verlaagt de prestaties.
2. Als een array een grote grootte en een grote groeifactor heeft, zal het een groot ongebruikt geheugenstuk hebben. Hierdoor duren resize‑operaties langer. Dit verlaagt de prestaties.

Het new‑keyword

In C++ kunnen we een dynamische array maken met het new-keyword. Het aantal items dat moet worden toegewezen, wordt gespecificeerd tussen vierkante haken. De typenaam moet hiervoorafgaan. Het gevraagde aantal items wordt toegewezen.

Syntaxis:

Het new-keyword heeft de volgende syntaxis:

pointer_variabele = new data_type; 

De pointer_variabele is de naam van de pointer‑variabele.

De data_type moet een geldig C++ datatype zijn.

Het keyword retourneert vervolgens een pointer naar het eerste item. Na het maken van de dynamische array kunnen we het verwijderen met het delete-keyword.

Voorbeeld 1:

#include<iostream>
using namespace std;
int main() {
    int x, n;
    cout << "Enter the number of items:" << "\n";
    cin >>n;
    int *arr = new int(n);
    cout << "Enter " << n << " items" << endl;
    for (x = 0; x < n; x++) {
        cin >> arr[x];
    }
    cout << "You entered: ";
    for (x = 0; x < n; x++) {
        cout << arr[x] << " ";
    }
    return 0;
 } 

Output:

Hier is een screenshot van de code:

Code‑uitleg:

1. Include de iostream‑header voor gebruik van functies.
2. Include de std‑naamruimte om klassen zonder prefix te gebruiken.
3. Roep main() aan; programmeerlogica gaat in de body.
4. Declareer twee integer‑variabelen x en n.
5. Print prompt om de gebruiker n in te voeren.
6. Lees invoer en wijs toe aan n.
7. Declareer een array voor n integers en wijs toe aan pointer *arr.
8. Print bericht om n items in te voeren.
9. Gebruik een for‑lus met lusvariabele x om over invoer te itereren.
10. Lees elementen en sla op in array arr.
11. Einde for‑lus body.
12. Print tekst op console.
13. Gebruik for‑lus om over array‑elementen te itereren.
14. Print waarden van array arr.
15. Einde for‑lus body.
16. Programma retourneert waarde bij succes.
17. Einde main() body.

LET OP: In het bovenstaande voorbeeld mag de gebruiker elke grootte specificeren tijdens runtime. Dit betekent dat de array‑grootte tijdens runtime bepaald wordt.

Initialiseren van Dynamisch Toegewezen Arrays

Het is eenvoudig om een dynamische array te initialiseren op 0.

Syntaxis:

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

In de bovenstaande syntaxis duidt length het aantal elementen aan. Omdat we initialiseren op 0, laten we dit leeg.

We kunnen een dynamische array initialiseren met een initializer list. Laten we een voorbeeld maken dat dit demonstreert.

Voorbeeld 2:

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

Output:

Hier is een screenshot van de code:

Code‑uitleg:

1. Include iostream header.
2. Include std naamruimte.
3. Roep main() aan.
4. Declareer integer variabele x.
5. Declareer dynamische array array met initializer list (5 integers). Let op: geen =-operator tussen lengte en lijst.
6. Print tekst; endl betekent einde regel.
7. For‑lus over array‑elementen.
8. Print array‑inhoud.
9. Einde for‑lus.
10. Return 0 bij succes.
11. Einde main().

Arrays Resizen

De lengte van een dynamische array wordt tijdens allocatie bepaald.

C++ heeft echter geen ingebouwd mechanisme om een array te resizen na allocatie.

Je kunt dit oplossen door een nieuwe array dynamisch toe te wijzen, elementen te kopiëren, en de oude array te wissen.

Let op: deze techniek is foutgevoelig, probeer het te vermijden.

Dynamisch Arrays Verwijderen

Een dynamische array moet uit het geheugen verwijderd worden zodra het doel vervuld is. Het delete-statement helpt hierbij. Het vrijgemaakte geheugen kan dan voor andere data gebruikt worden. Zelfs als je niet verwijdert, wordt het automatisch vrijgegeven bij programma‑einde.

Let op:

Om een dynamische array te verwijderen, gebruik delete[] in plaats van delete. De [] instructeert de CPU om meerdere variabelen te wissen in plaats van één. Gebruik van delete in plaats van delete[] bij een dynamische array kan problemen veroorzaken: memory leaks, data corruptie, crashes, etc.

Voorbeeld 3:

#include<iostream>
using namespace std;
int main() {
    int x, n;
    cout << "How many numbers will you type?" << "\n";
    cin >>n;
    int *arr = new int(n);
    cout << "Enter " << n << " numbers" << endl;
    for (x = 0; x < n; x++) {
        cin >> arr[x];
    }
    cout << "You typed: ";
    for (x = 0; x < n; x++) {
        cout << arr[x] << " ";
    }
    cout << endl;
    delete [] arr;
    return 0;
 } 

Output:

Hier is een screenshot van de code:

Code‑uitleg:

1. Include iostream header.
2. Include std naamruimte.
3. Roep main() aan.
4. Declareer x en n als integers.
5. Print prompt voor aantal getallen.
6. Lees invoer naar n.
7. Declareer pointer *arr; array reserveert geheugen voor n integers.
8. Print prompt voor n getallen.
9. For‑lus met x over ingevoerde getallen.
10. Lees getallen en sla op in arr.
11. Einde for‑lus.
12. Print tekst.
13. For‑lus over arr inhoud.
14. Print array‑waarden.
15. Einde for‑lus.
16. Print lege regel.
17. Vrijgeef geheugen van arr.
18. Return 0 bij succes.
19. Einde main().

Samenvatting:

• Gewone arrays hebben vaste grootte; niet wijzigbaar na declaratie.
• Geheugengrootte bepaald tijdens compile‑tijd.
• Dynamische arrays: grootte wijzigbaar tijdens runtime.
• Grootte bepaald tijdens runtime.
• Gedeclareerd met new-keyword.
• Vierkante haken specificeren aantal items.
• Geheugen vrijgeven met delete-operator.
• Gebruik delete[] voor alle array‑elementen.
• delete zonder [] vrijgaveert maar één element.
• Geen ingebouwd mechanisme om C++ arrays te resizen.
• Bij initializer list geen =-operator gebruiken.