Summary  
This chapter explains how to allocate and free memory on the heap at runtime using C++’s new/delete and new[]/delete[] operators to manage dynamic memory safely and avoid leaks or dangling pointers.

General domain of usage  
Implementing dynamic data structures (e.g., resizable arrays or linked lists)

Get a clear, visual walkthrough of dynamic memory allocation in C++. This video covers how and why to use the `new` and `delete` operators, the correct way to allocate and release memory for single variables and arrays, and best practices to prevent memory leaks. See practical examples of pointers, dynamic arrays, and memory management strategies to help you write efficient, error-free C++ programs.

-- video metadata (use this info when making a video) -- Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 12 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally. If code is longer than 8 lines, move code output  blocks to second column. Avoid using programming language images in the videos.

**Dynamische geheugenallocatie** omvat het gebruik van de operatoren `new` en `delete`. Deze operatoren maken het mogelijk om geheugen voor variabelen en arrays **tijdens de uitvoering** toe te wijzen, wat meer flexibiliteit biedt dan statische geheugenallocatie.

* `new`: operator die wordt gebruikt om tijdens de uitvoering dynamisch geheugen toe te wijzen voor een object of een array van objecten;

* `delete`: operator die wordt gebruikt om geheugen vrij te geven dat eerder met de operator `new` is toegewezen.


Een pointer die verwijst naar dynamisch toegewezen geheugen wordt doorgaans op de stack opgeslagen, **maar** het geheugen waarnaar wordt verwezen, wordt op de heap toegewezen.

Opmerking

Om een integer-variabele dynamisch aan te maken, moet een pointer samen met het sleutelwoord `new` worden gebruikt.

```
int *dynamicInteger = new int;
```

Om het dynamisch toegewezen geheugen vrij te geven, gebruikt u de delete-operator:

```
delete dynamicInteger;
```

Maak er een regel van voor uzelf: wanneer u new gebruikt om geheugen toe te wijzen, gebruik dan altijd delete om het later vrij te geven.

### Dynamisch toegewezen arrays

Bij het dynamisch toewijzen van geheugen voor arrays gebruikt u de `new[]`-operator, en bij het vrijgeven van geheugen voor dynamisch toegewezen arrays gebruikt u de `delete[]`-operator.

Het niet verwijderen van dynamisch toegewezen geheugen kan leiden tot geheugenlekken, waarbij het programma geheugen vasthoudt dat niet langer wordt gebruikt.

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>


void fillRandomGrades(double* grades, int count);
double calculateAverage(double* grades, int count);

TEST_CASE("calculateAverage returns correct average for positive grades", "[calculateAverage]") {
    double grades[] = {80, 90, 70, 60, 99};
    int count = 5;

    double result = calculateAverage(grades, count);
    double expected = (80 + 90 + 70 + 60 + 99) / 5.0;

    REQUIRE(result == Approx(expected));
}

TEST_CASE("calculateAverage returns correct average for identical grades", "[calculateAverage]") {
    double grades[] = {75, 75, 75, 75};
    int count = 4;

    double result = calculateAverage(grades, count);
    double expected = 75;

    REQUIRE(result == Approx(expected));
}

TEST_CASE("calculateAverage handles single grade", "[calculateAverage]") {
    double grades[] = {88};
    int count = 1;

    double result = calculateAverage(grades, count);
    double expected = 88;

    REQUIRE(result == Approx(expected));
}

TEST_CASE("fillRandomGrades generates grades in range 60-100", "[fillRandomGrades]") {
    const int count = 100;
    double grades[count];

    fillRandomGrades(grades, count);

    for (int i = 0; i < count; ++i) {
        REQUIRE(grades[i] >= 60);
        REQUIRE(grades[i] <= 100);
    }
}

test.cpp

Ontgrendel de kracht van geheugenmanipulatie. Verdiep je in de fundamenten van programmeren met deze uitgebreide cursus, ontworpen voor beginners en voor iedereen die zijn kennis van pointers en referenties in C++ wil versterken. Het beheersen van deze essentiële concepten is cruciaal om het volledige potentieel van je programmeervaardigheden te benutten.

Leer de basisprincipes van pointers op een eenvoudige en overzichtelijke manier. Ontdek hoe pointers werken, hun syntaxis en praktische toepassingen aan de hand van duidelijke voorbeelden en heldere uitleg.

Ontdek hoe pointers, die geheugenadressen opslaan, gemanipuleerd kunnen worden met behulp van rekenkundige bewerkingen. Leer navigeren door geheugenlocaties, gegevensstructuren efficiënt benaderen en code optimaliseren voor prestaties.

Ontdek het concept van referenties als aliassen voor variabelen en geheugen-efficiënte toegang tot data. Leer hoe referenties bijdragen aan schonere code, verbeterde leesbaarheid en verhoogde prestaties door onnodige duplicatie van data te vermijden.

Ontdek de principes en technieken achter het dynamisch toewijzen en vrijgeven van geheugen tijdens de uitvoering van een programma. Begrijp de voordelen en uitdagingen van dynamische geheugentoewijzing.

Dynamische Toewijzing

Dynamisch toegewezen arrays

Oplossing