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.

Prima di esplorare perché l'allocazione dinamica sia necessaria, riepiloghiamo rapidamente le caratteristiche degli array statici e dinamici:

- **Dimensione Fissa**: una volta dichiarata, la dimensione di un array statico è fissa e non può essere modificata durante l'esecuzione;
- **Allocazione della Memoria in fase di Compilazione**: la memoria richiesta per un array statico viene allocata in fase di compilazione.

- **Ridimensionabili**: gli array dinamici consentono il ridimensionamento durante l'esecuzione, offrendo flessibilità per adattarsi ai requisiti variabili del programma;
- **Allocazione della memoria a runtime**: la memoria per gli array dinamici viene allocata durante l'esecuzione del programma.

### Le Limitazioni di un Approccio Statico

Si consideri il programma che richiede all'utente di inserire i punteggi delle prestazioni per ogni giorno **trascorso nel mese corrente**.

Purtroppo, non è possibile ottenere questo risultato utilizzando un **array statico**:

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8Y3RpbWU+CgppbnQgbWFpbigpIHsKICAgIHN0ZDo6dGltZV90IGN1cnJlbnRUaW1lID0gc3RkOjp0aW1lKG51bGxwdHIpOwogICAgaW50IGRheV9wYXNzZWQgPSBzdGQ6OmxvY2FsdGltZSgmY3VycmVudFRpbWUpLT50bV9tZGF5OwogICAgCiAgICBpbnQgYXJyW2RheV9wYXNzZWRdOwogICAgc3RkOjpjb3V0IDw8IGRheV9wYXNzZWQgPDwgc3RkOjplbmRsOyAKfQ==

Questo genererà un errore di compilazione perché <code>day_passed</code> **non è un'espressione costante** e dipende dal valore a runtime del giorno corrente del mese.

Nota

Quindi, invece di un array **statico**, è necessario utilizzare un array **allocato dinamicamente**.

#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

Sblocca il potere della manipolazione della memoria. Approfondisci i fondamenti della programmazione con questo corso completo pensato per principianti e per chi desidera rafforzare le proprie conoscenze su puntatori e riferimenti in C++. La padronanza di questi concetti essenziali è fondamentale per sfruttare appieno il potenziale delle competenze di programmazione.

Apprendere le basi dei puntatori in modo semplice e non eccessivamente complesso. Esplorazione del funzionamento dei puntatori, della loro sintassi e delle applicazioni pratiche tramite esempi chiari e spiegazioni facilmente comprensibili.

Esplorazione delle modalità con cui i puntatori, che memorizzano indirizzi di memoria, possono essere manipolati tramite operazioni aritmetiche. Navigazione tra le posizioni di memoria, accesso efficiente alle strutture dati e ottimizzazione delle prestazioni del codice.

Esplora il concetto di riferimenti come alias per variabili e accesso efficiente alla memoria dei dati. Analisi di come i riferimenti contribuiscano a un codice più pulito, una migliore leggibilità e prestazioni ottimizzate evitando duplicazioni di dati non necessarie.

Scopri i principi e le tecniche alla base dell'allocazione e della deallocazione dinamica della memoria durante l'esecuzione del programma. Comprendi i vantaggi e le sfide dell'allocazione dinamica della memoria.

Allocazione Dinamica dell'Array

Array Statico

Array Dinamici

Le Limitazioni di un Approccio Statico

Soluzione