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.

**L'allocation dynamique de mémoire** implique l'utilisation des opérateurs `new` et `delete`. Ces opérateurs permettent d'allouer de la mémoire pour des variables et des tableaux **à l'exécution**, offrant ainsi une plus grande flexibilité que l'allocation statique de mémoire.

* `new` : opérateur utilisé pour allouer dynamiquement de la mémoire pour un objet ou un tableau d'objets pendant l'exécution ;

* `delete` : opérateur utilisé pour désallouer la mémoire précédemment allouée avec l'opérateur `new`.


Un pointeur pointant vers une mémoire allouée dynamiquement est généralement stocké sur la pile, **mais** la mémoire à laquelle il fait référence est allouée sur le tas.

Remarque

Pour créer dynamiquement une variable entière, il faut utiliser un pointeur avec le mot-clé `new`.

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

Pour libérer la mémoire allouée dynamiquement, utiliser l'opérateur delete :

```
delete dynamicInteger;
```

Adopter la règle suivante : lors de l'utilisation de new pour allouer de la mémoire, toujours utiliser delete pour la libérer par la suite.

### Tableaux alloués dynamiquement

Pour allouer dynamiquement de la mémoire pour des tableaux, utiliser l'opérateur `new[]`, et pour libérer la mémoire de ces tableaux, utiliser l'opérateur `delete[]`.

L'oubli de supprimer la mémoire allouée dynamiquement peut entraîner des fuites de mémoire, où le programme conserve de la mémoire qui n'est plus utilisée.

#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

Libérez la puissance de la manipulation de la mémoire. Plongez au cœur des fondamentaux de la programmation avec ce cours complet conçu pour les débutants et ceux qui souhaitent renforcer leurs connaissances sur les pointeurs et les références en C++. La maîtrise de ces concepts essentiels est cruciale pour exploiter pleinement le potentiel de vos compétences en programmation.

Apprenez les bases des pointeurs de manière simple et accessible. Découvrez le fonctionnement des pointeurs, leur syntaxe et leurs applications pratiques à travers des exemples clairs et des explications faciles à suivre.

Découvrez comment les pointeurs, qui stockent des adresses mémoire, peuvent être manipulés à l'aide d'opérations arithmétiques. Navigation à travers les emplacements mémoire, accès efficace aux structures de données et optimisation du code pour la performance.

Découvrez le concept de références en tant qu'alias pour les variables et l'accès efficace à la mémoire. Comprenez comment les références contribuent à un code plus clair, une meilleure lisibilité et des performances accrues en évitant la duplication inutile des données.

Découvrez les principes et techniques liés à l'allocation et à la désallocation dynamique de la mémoire pendant l'exécution d'un programme. Compréhension des avantages et des défis de l'allocation dynamique de mémoire.

Allocation Dynamique

Tableaux alloués dynamiquement

Solution