Summary  
This chapter introduces dynamic array allocation in C++, explaining how to use pointers with new and delete to allocate and deallocate arrays at runtime for flexible sizing.  

General domain of usage  
Reading files when the number of data items isn’t known in advance.

This video introduces dynamic allocation of arrays in C++. You will learn the difference between static and dynamic arrays, including their characteristics and limitations. The instructor demonstrates why static arrays are insufficient for flexible, runtime-sized data, and how dynamic arrays—allocated with pointers—solve these challenges. Real-world scenarios, such as user-driven data sizes and adaptive memory management, are covered to help you understand when and why to use dynamic arrays in your 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.

Voordat we bespreken waarom dynamische toewijzing noodzakelijk is, herhalen we kort de kenmerken van statische en dynamische arrays:

- **Vaste grootte**: eenmaal gedeclareerd, is de grootte van een statische array vast en kan deze tijdens de uitvoering niet worden gewijzigd;
- **Geheugentoewijzing tijdens compilatie**: het geheugen dat nodig is voor een statische array wordt tijdens de compilatie toegewezen.

- **Aanpasbaar formaat**: dynamische arrays kunnen tijdens de uitvoering van het programma van grootte veranderen, waardoor flexibiliteit ontstaat om aan veranderende programmavereisten te voldoen;
- **Geheugentoewijzing tijdens uitvoering**: geheugen voor dynamische arrays wordt toegewezen tijdens de uitvoering van het programma.

### De beperkingen van een statische benadering

Beschouw het programma dat de gebruiker vraagt om prestatiescores in te voeren voor elke dag **die is verstreken in de huidige maand**.

Helaas kunnen we dit niet bereiken met een **statische array**:

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8Y3RpbWU+CgppbnQgbWFpbigpIHsKICAgIHN0ZDo6dGltZV90IGN1cnJlbnRUaW1lID0gc3RkOjp0aW1lKG51bGxwdHIpOwogICAgaW50IGRheV9wYXNzZWQgPSBzdGQ6OmxvY2FsdGltZSgmY3VycmVudFRpbWUpLT50bV9tZGF5OwogICAgCiAgICBpbnQgYXJyW2RheV9wYXNzZWRdOwogICAgc3RkOjpjb3V0IDw8IGRheV9wYXNzZWQgPDwgc3RkOjplbmRsOyAKfQ==

Dit zal een compilatiefout genereren omdat <code>day_passed</code> **geen constante expressie is**; het hangt af van de runtime-waarde van de huidige dag van de maand.

Opmerking

In plaats van een **statische** array moet een **dynamisch gealloceerde** array worden gebruikt.

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

void analyzeTemperatures(double* temps, int hours);

TEST_CASE("Input={10, 20, 30, 40, 50}, Min=10, Max=50, Avg=30", "[analyzeTemperatures]") {
    double temps[5] = {10, 20, 30, 40, 50};

    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    analyzeTemperatures(temps, 5);

    std::cout.rdbuf(oldCout);

    std::string output = oss.str();

    REQUIRE(output.find("Minimum temperature: 10") != std::string::npos);
    REQUIRE(output.find("Maximum temperature: 50") != std::string::npos);
    REQUIRE(output.find("Average temperature: 30") != std::string::npos);
}

TEST_CASE("Input={25, 25, 25}, Min=25, Max=25, Avg=25", "[analyzeTemperatures]") {
    double temps[3] = {25, 25, 25};

    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    analyzeTemperatures(temps, 3);

    std::cout.rdbuf(oldCout);

    std::string output = oss.str();

    REQUIRE(output.find("Minimum temperature: 25") != std::string::npos);
    REQUIRE(output.find("Maximum temperature: 25") != std::string::npos);
    REQUIRE(output.find("Average temperature: 25") != std::string::npos);
}

TEST_CASE("Input={-5, -10, -3, -7}, Min=-10, Max=-3, Avg=-6.25", "[analyzeTemperatures]") {
    double temps[4] = {-5, -10, -3, -7};

    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    analyzeTemperatures(temps, 4);

    std::cout.rdbuf(oldCout);

    std::string output = oss.str();

    REQUIRE(output.find("Minimum temperature: -10") != std::string::npos);
    REQUIRE(output.find("Maximum temperature: -3") != std::string::npos);
    REQUIRE(output.find("Average temperature: -6.25") != std::string::npos);
}

TEST_CASE("Input={25}, Min=25, Max=25, Avg=25", "[analyzeTemperatures]") {
    double temps[1] = {25};

    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    analyzeTemperatures(temps, 1);

    std::cout.rdbuf(oldCout);

    std::string output = oss.str();

    REQUIRE(output.find("Minimum temperature: 25") != std::string::npos);
    REQUIRE(output.find("Maximum temperature: 25") != std::string::npos);
    REQUIRE(output.find("Average temperature: 25") != std::string::npos);
}

TEST_CASE("Input={15.2,14.8,14.5,14.3,14,14.1,15,16.5,18,19.5,21,22.2,23,23.5,23.8,23.4,22.8,21.5,20,18.5,17.2,16,15.5,15}, Min=14, Max=23.8, Avg=18.1", "[analyzeTemperatures]") {
    double temps[24] = {
        15.2, 14.8, 14.5, 14.3, 14, 14.1,
        15, 16.5, 18, 19.5, 21, 22.2,
        23, 23.5, 23.8, 23.4, 22.8, 21.5,
        20, 18.5, 17.2, 16, 15.5, 15
    };

    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    analyzeTemperatures(temps, 24);

    std::cout.rdbuf(oldCout);

    std::string output = oss.str();

    REQUIRE(output.find("Minimum temperature: 14.00") != std::string::npos);
    REQUIRE(output.find("Maximum temperature: 23.80") != std::string::npos);
    REQUIRE(output.find("Average temperature: 18.30") != std::string::npos);
}

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 van de Array

Statische array

Dynamische arrays

De beperkingen van een statische benadering

Oplossing