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.

Før vi undersøger, hvorfor dynamisk allokering er nødvendig, lad os hurtigt opsummere egenskaberne ved statiske og dynamiske arrays:

- **Fast størrelse**: Når et statisk array er erklæret, er størrelsen fast og kan ikke ændres under kørsel;
- **Hukommelsesallokering ved kompileringstidspunktet**: Den nødvendige hukommelse til et statisk array allokeres ved kompilering.

- **Kan ændres i størrelse**: dynamiske arrays muliggør ændring af størrelse under kørsel, hvilket giver fleksibilitet til at tilpasse sig ændrede programkrav;
- **Hukommelsesallokering under kørsel**: hukommelse til dynamiske arrays allokeres under programudførelse.

### Begrænsninger ved en statisk tilgang

Overvej programmet, der beder brugeren om at indtaste præstationsscore for hver dag **der er gået i den nuværende måned**.

Desværre kan dette ikke opnås ved brug af et **statisk array**:

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8Y3RpbWU+CgppbnQgbWFpbigpIHsKICAgIHN0ZDo6dGltZV90IGN1cnJlbnRUaW1lID0gc3RkOjp0aW1lKG51bGxwdHIpOwogICAgaW50IGRheV9wYXNzZWQgPSBzdGQ6OmxvY2FsdGltZSgmY3VycmVudFRpbWUpLT50bV9tZGF5OwogICAgCiAgICBpbnQgYXJyW2RheV9wYXNzZWRdOwogICAgc3RkOjpjb3V0IDw8IGRheV9wYXNzZWQgPDwgc3RkOjplbmRsOyAKfQ==

Dette vil give en kompileringsfejl, fordi <code>day_passed</code> **ikke er et konstant udtryk**; det afhænger af den aktuelle dags værdi på måneden under kørsel.

Bemærk

Så i stedet for et **statisk** array skal vi bruge et **dynamisk allokeret** array.

#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

Lås op for kraften ved hukommelsesmanipulation. Dyk ned i grundlæggende programmering med dette omfattende kursus, designet til begyndere og personer, der ønsker at styrke deres viden om pointers og referencer i C++. Beherskelse af disse essentielle begreber er afgørende for at udnytte det fulde potentiale af dine programmeringsevner.

Lær det grundlæggende om pointers på en enkel og overskuelig måde. Udforsk, hvordan pointers fungerer, deres syntaks og praktiske anvendelser gennem klare eksempler og letforståelige forklaringer.

Undersøg, hvordan pointere, der gemmer hukommelsesadresser, kan manipuleres ved hjælp af aritmetiske operationer. Lær at navigere gennem hukommelsesplaceringer, få effektiv adgang til datastrukturer og optimere kode for ydeevne.

Undersøg begrebet referencer som aliaser for variabler og hukommelseseffektiv adgang til data. Lær, hvordan referencer bidrager til mere overskuelig kode, forbedret læsbarhed og øget ydeevne ved at undgå unødvendig dataduplicering.

Opdag principperne og teknikkerne bag dynamisk tildeling og frigivelse af hukommelse under programudførelse. Forstå fordelene og udfordringerne ved dynamisk hukommelsesallokering.

Dynamisk Allokering af Arrayet

Statisk array

Dynamiske arrays

Begrænsninger ved en statisk tilgang

Løsning