C++ Dynamisch Geheugen Beheersen: Stack vs. Heap Uitgelegd

Een goed begrip van hoe dynamisch geheugen in C++ werkt is essentieel om een vaardige C++-programmeur te worden. Het geheugen in je C++-programma is verdeeld in twee delen:

• De stack – Alle variabelen die binnen een functie worden gedeclareerd, reserveren geheugen op de stack.

• De heap – Dit is ongebruikt programma-geheugen dat dynamisch kan worden toegekend tijdens de uitvoering van het programma.

Vaak weet je van tevoren niet hoeveel geheugen je nodig hebt om bepaalde informatie in een variabele op te slaan, en de benodigde grootte pas tijdens runtime bekend.

Je kunt tijdens runtime geheugen op de heap toewijzen voor een variabele van een gegeven type met een speciale operator in C++ die het adres van de toegewezen ruimte retourneert. Deze operator heet de new-operator.

Als je dynamisch toegewezen geheugen niet meer nodig hebt, kun je de delete-operator gebruiken, die het geheugen vrijgeeft dat eerder door new was toegewezen.

De new- en delete-operatoren

De generieke syntaxis om met de new-operator dynamisch geheugen toe te wijzen voor elk datatype is:

new datatype;

Hierbij kan datatype elk ingebouwd datatype zijn (inclusief arrays) of elk door de gebruiker gedefinieerd type (klassen of structuren). Laten we beginnen met ingebouwde typen. Bijvoorbeeld: we definiëren een pointer naar double en vragen tijdens uitvoering geheugen aan:

double* pvalue = nullptr; // Pointer geïnitialiseerd met null
pvalue = new double;      // Geheugen aanvragen voor de variabele

De toewijzing kan mislukken als de vrije geheugenruimte op is. Het is dus goed om te controleren of new een nullpointer retourneert en passend te handelen:

double* pvalue = nullptr;
if (!(pvalue = new double)) {
    cout << "Fout: ontoereikend geheugen." << endl;
    exit(1);
}

De C-functie malloc() bestaat nog in C++, maar het wordt afgeraden om deze te gebruiken. Het grote voordeel van new boven malloc() is dat new niet alleen geheugen toewijst, maar ook objecten construëert – de kern van C++.

Op elk moment kun je, wanneer een dynamisch toegewezen variabele niet meer nodig is, het bezette geheugen vrijgeven met de delete-operator:

delete pvalue; // Geheugen vrijmaken waar pvalue naar wijst

Voorbeeld: new en delete in actie

#include <iostream>
using namespace std;

int main() {
    double* pvalue = nullptr;
    pvalue = new double;
    *pvalue = 29494.99;
    cout << "Waarde van pvalue: " << *pvalue << endl;
    delete pvalue;
    return 0;
}

De uitvoer:

Waarde van pvalue: 29495

Dynamische Geheugentoewijzing voor Arrays

Wil je geheugen voor een array van tekens (bijv. een string van 20 karakters), dan gebruik je dezelfde syntaxis:

char* pvalue = nullptr;
pvalue = new char[20]; // Geheugen voor 20 karakters

Om de array weer vrij te geven:

delete[] pvalue; // Array verwijderen

Voor multidimensionale arrays:

double** pvalue = nullptr;
pvalue = new double[3][4]; // 3x4 array

Het vrijgeven blijft hetzelfde:

delete[] pvalue;

Dynamische Geheugentoewijzing voor Objecten

Objecten verschillen niet van simpele datatypes. Hieronder een voorbeeld met een array van Box-objecten:

#include <iostream>
using namespace std;

class Box {
public:
    Box() { cout << "Constructor aangeroepen!" << endl; }
    ~Box() { cout << "Destructor aangeroepen!" << endl; }
};

int main() {
    Box* myBoxArray = new Box[4];
    delete[] myBoxArray;
    return 0;
}

Bij toewijzing van vier Box-objecten wordt de constructor vier keer aangeroepen, en bij verwijdering de destructor eveneens vier keer.

Constructor aangeroepen!
Constructor aangeroepen!
Constructor aangeroepen!
Constructor aangeroepen!
Destructor aangeroepen!
Destructor aangeroepen!
Destructor aangeroepen!
Destructor aangeroepen!