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.

Antes de explorar por qué es necesaria la asignación dinámica, repasemos rápidamente las características de los arreglos estáticos y dinámicos:

- **Tamaño fijo**: una vez declarado, el tamaño de un arreglo estático es fijo y no puede cambiarse durante la ejecución;
- **Asignación de memoria en tiempo de compilación**: la memoria requerida para un arreglo estático se asigna en tiempo de compilación.

- **Redimensionable**: los arreglos dinámicos permiten cambiar su tamaño durante la ejecución, proporcionando flexibilidad para adaptarse a los requisitos cambiantes del programa;
- **Asignación de memoria en tiempo de ejecución**: la memoria para los arreglos dinámicos se asigna durante la ejecución del programa.

### Las limitaciones de un enfoque estático

Considere el programa que solicita al usuario que ingrese las puntuaciones de rendimiento para cada día **que ha transcurrido en el mes actual**.

Desafortunadamente, no podemos lograr esto utilizando un **arreglo estático**:

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8Y3RpbWU+CgppbnQgbWFpbigpIHsKICAgIHN0ZDo6dGltZV90IGN1cnJlbnRUaW1lID0gc3RkOjp0aW1lKG51bGxwdHIpOwogICAgaW50IGRheV9wYXNzZWQgPSBzdGQ6OmxvY2FsdGltZSgmY3VycmVudFRpbWUpLT50bV9tZGF5OwogICAgCiAgICBpbnQgYXJyW2RheV9wYXNzZWRdOwogICAgc3RkOjpjb3V0IDw8IGRheV9wYXNzZWQgPDwgc3RkOjplbmRsOyAKfQ==

Esto generará un error de compilación porque <code>day_passed</code> **no es una expresión constante**, depende del valor en tiempo de ejecución del día actual del mes.

Nota

Por lo tanto, en lugar de un arreglo **estático** debemos utilizar un arreglo **asignado dinámicamente**.

#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

Desbloquea el poder de la manipulación de memoria. Profundiza en los fundamentos de la programación con este curso integral diseñado para principiantes y personas que buscan fortalecer sus conocimientos sobre punteros y referencias en C++. Dominar estos conceptos esenciales es crucial para aprovechar al máximo el potencial de tus habilidades de programación.

Aprenda los conceptos básicos de los punteros de manera sencilla y sin complicaciones. Explore cómo funcionan los punteros, su sintaxis y aplicaciones prácticas a través de ejemplos claros y explicaciones fáciles de seguir.

Explora cómo los punteros, que almacenan direcciones de memoria, pueden ser manipulados mediante operaciones aritméticas. Aprende a navegar por ubicaciones de memoria, acceder a estructuras de datos de manera eficiente y optimizar el código para mejorar el rendimiento.

Explora el concepto de referencias como alias para variables y el acceso eficiente a los datos en memoria. Aprende cómo las referencias contribuyen a un código más limpio, mejor legibilidad y mayor rendimiento al evitar la duplicación innecesaria de datos.

Descubra los principios y técnicas detrás de la asignación y liberación de memoria de forma dinámica durante la ejecución de un programa. Comprenda las ventajas y desafíos de la asignación dinámica de memoria.

Asignación Dinámica de Arreglos

Arreglo Estático

Arreglos dinámicos

Las limitaciones de un enfoque estático

Solución