Allocation Dynamique de Mémoire

Il existe deux types de mémoire disponibles : pile et tas. La mémoire de la pile est limitée en taille et convient bien aux petites variables de courte durée qui ne sont pas nécessaires au-delà de leur portée. Lorsqu'une variable stockée sur la pile sort de sa portée, elle est automatiquement détruite.

stack_allocated


              12
            
// Creates an integer variable on the stack
int stack_int = 42;

Cependant, lorsque vous avez besoin de mémoire qui persiste plus longtemps que sa portée, ou qui nécessite plus d'espace, vous vous tournez vers le tas. Le tas est un réservoir de mémoire beaucoup plus grand où votre programme peut demander de la mémoire à l'exécution. Cela se fait généralement en utilisant le mot-clé new :

heap_allocated


              12
            
// create an integer on the heap
int* heap_int = new int;

La chose délicate à propos de la mémoire du tas est qu'elle n'est pas libérée automatiquement. C'est la responsabilité du développeur de la désallouer lorsqu'il a terminé. Pour chaque new, il doit y avoir un delete correspondant.

free_pointer


              12
            
// Explicitly deletes the integer on the heap
delete heap_int;

Fuites de mémoire

Lorsque vous introduisez des pointeurs dans votre code, vous entrez dans le domaine de la gestion manuelle de la mémoire. La gestion manuelle de la mémoire nécessite de libérer la mémoire lorsqu'elle n'est plus nécessaire. Cela peut entraîner des pièges courants : fuites de mémoire et pointeurs pendants.

Les fuites de mémoire se produisent généralement lorsque vous oubliez de désallouer la mémoire. Cette mémoire reste réservée, ce qui fait que votre programme perd de la mémoire au fil du temps.

memory_leak


              12345
            
running = true
while (running)
{
    int* p_int = new int;
}

Pointeurs pendants

Les pointeurs pendants se produisent lorsqu'un pointeur continue de pointer vers une mémoire qui a été désallouée. C'est comme avoir une carte au trésor qui vous mène à un endroit (adresse mémoire) où le trésor (données) a déjà été pris (détruit).

main


              12345678910111213
            
#include <iostream>

int main()
{
    int* ptr = new int; // dynamically allocate an integer

    *ptr = 42; // assign a value to the allocated memory
    std::cout << *ptr << std::endl; // This will output 42

    delete ptr; // deallocate the memory

    std::cout << *ptr << std::endl; // ptr is a dangling pointer!
}

Essayer d'accéder à un pointeur après avoir appelé delete dessus, ce qui désalloue la mémoire à laquelle il pointait. Après la suppression, le pointeur devient un pointeur suspendu, car il contient toujours l'adresse d'une mémoire qui n'existe plus.

Accéder à un pointeur suspendu peut entraîner un comportement imprévisible ou même des plantages, car la mémoire à laquelle il pointe n'est plus valide.

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 2