Allocation dynamique de mémoire en C++

Introduction

Dans ce laboratoire (lab), vous apprendrez à gérer l'allocation dynamique de mémoire en C++. Vous commencerez par allouer de la mémoire à l'aide de l'opérateur new, puis libérez la mémoire avec l'opérateur delete. Vous explorerez également la création de tableaux dynamiques, l'utilisation de pointeurs intelligents (smart pointers) tels que shared_ptr et unique_ptr, et la détection de fuites de mémoire. Ces compétences sont essentielles pour une gestion efficace de la mémoire en programmation C++.

Le laboratoire couvre les étapes clés suivantes : allocation de mémoire à l'aide de l'opérateur new, libération de mémoire avec l'opérateur delete, création de tableaux dynamiques avec new[], suppression de tableaux à l'aide de delete[], mise en œuvre du pointeur intelligent shared_ptr, utilisation de unique_ptr pour une propriété exclusive, détection de fuites de mémoire et gestion des échecs d'allocation de mémoire.

Skills Graph

Allouer de la mémoire à l'aide de l'opérateur new

Dans cette étape, vous apprendrez à utiliser l'opérateur new en C++ pour allouer dynamiquement de la mémoire à l'exécution. L'allocation dynamique de mémoire vous permet de créer des variables et des tableaux dont la taille est déterminée pendant l'exécution du programme, offrant plus de flexibilité par rapport à l'allocation statique de mémoire.

Ouvrez le WebIDE et créez un nouveau fichier appelé dynamic_memory.cpp dans le répertoire ~/project :

touch ~/project/dynamic_memory.cpp

Ajoutez le code suivant à dynamic_memory.cpp :

#include <iostream>

int main() {
    // Dynamically allocate an integer using new
    int* dynamicInteger = new int;

    // Assign a value to the dynamically allocated integer
    *dynamicInteger = 42;

    // Print the value of the dynamically allocated integer
    std::cout << "Dynamically allocated integer value: " << *dynamicInteger << std::endl;

    // Print the memory address of the dynamically allocated integer
    std::cout << "Memory address: " << dynamicInteger << std::endl;

    return 0;
}

Décortiquons les concepts clés :

1. int* dynamicInteger = new int; :

   • L'opérateur new alloue de la mémoire pour un entier
   • Renvoie un pointeur vers la mémoire allouée
   • Crée la variable sur le tas (heap), pas sur la pile (stack)

2. *dynamicInteger = 42; :

   • Utilise l'opérateur de déréférencement * pour assigner une valeur
   • Stocke la valeur 42 dans la mémoire allouée dynamiquement

Compilez et exécutez le programme :

g++ dynamic_memory.cpp -o dynamic_memory
./dynamic_memory

Exemple de sortie :

Dynamically allocated integer value: 42
Memory address: 0x55f4e8a042a0

Points clés concernant l'opérateur new :

• Alloue de la mémoire dynamiquement à l'exécution
• Renvoie un pointeur vers la mémoire allouée
• La mémoire est allouée sur le tas (heap)
• La taille peut être déterminée à l'exécution
• Permet une gestion de la mémoire plus flexible

Note : Dans les étapes suivantes, vous apprendrez à libérer correctement cette mémoire allouée dynamiquement pour éviter les fuites de mémoire.

Libérer de la mémoire avec l'opérateur delete

Dans cette étape, vous apprendrez à utiliser l'opérateur delete pour libérer correctement la mémoire allouée dynamiquement en C++. Ne pas libérer la mémoire peut entraîner des fuites de mémoire, qui peuvent causer des problèmes de performance dans votre programme.

Ouvrez le WebIDE et créez un nouveau fichier appelé memory_release.cpp dans le répertoire ~/project :

touch ~/project/memory_release.cpp

Ajoutez le code suivant à memory_release.cpp :

#include <iostream>

int main() {
    // Dynamically allocate an integer
    int* dynamicInteger = new int;

    // Assign a value to the dynamically allocated integer
    *dynamicInteger = 42;

    // Print the value before releasing memory
    std::cout << "Value before release: " << *dynamicInteger << std::endl;

    // Release the dynamically allocated memory using delete
    delete dynamicInteger;

    // Set the pointer to nullptr after deletion
    dynamicInteger = nullptr;

    // Demonstrate safe pointer usage
    if (dynamicInteger == nullptr) {
        std::cout << "Memory has been successfully released" << std::endl;
    }

    return 0;
}

Points clés concernant l'opérateur delete :

1. delete dynamicInteger; :

   • Libère la mémoire précédemment allouée avec new
   • Prévient les fuites de mémoire
   • Rend la mémoire au système

2. dynamicInteger = nullptr; :

   • Met le pointeur à nullptr après la suppression
   • Aide à éviter l'utilisation accidentelle de mémoire libérée
   • Fournit une vérification de sécurité supplémentaire

Compilez et exécutez le programme :

g++ memory_release.cpp -o memory_release
./memory_release

Exemple de sortie :

Value before release: 42
Memory has been successfully released

Règles importantes de gestion de la mémoire :

• Utilisez toujours delete pour la mémoire allouée avec new
• Mettez les pointeurs à nullptr après la suppression
• N'utilisez jamais un pointeur après qu'il a été supprimé
• Chaque new devrait avoir un delete correspondant

Créer des tableaux dynamiques avec new[]

Dans cette étape, vous apprendrez à créer des tableaux dynamiques en utilisant l'opérateur new[] en C++. Les tableaux dynamiques vous permettent d'allouer de la mémoire pour plusieurs éléments à l'exécution, offrant plus de flexibilité que les tableaux statiques.

Ouvrez le WebIDE et créez un nouveau fichier appelé dynamic_array.cpp dans le répertoire ~/project :

touch ~/project/dynamic_array.cpp

Ajoutez le code suivant à dynamic_array.cpp :

#include <iostream>

int main() {
    // Declare the size of the dynamic array
    int arraySize = 5;

    // Create a dynamic integer array using new[]
    int* dynamicArray = new int[arraySize];

    // Initialize array elements
    for (int i = 0; i < arraySize; ++i) {
        dynamicArray[i] = i * 10;
    }

    // Print array elements
    std::cout << "Dynamic Array Contents:" << std::endl;
    for (int i = 0; i < arraySize; ++i) {
        std::cout << "Element " << i << ": " << dynamicArray[i] << std::endl;
    }

    return 0;
}

Points clés concernant les tableaux dynamiques :

1. int* dynamicArray = new int[arraySize]; :

   • Alloue de la mémoire pour un tableau d'entiers
   • arraySize détermine le nombre d'éléments
   • La mémoire est allouée sur le tas (heap)
   • La taille peut être déterminée à l'exécution

2. Initialisation et accès au tableau :

   • Utilisez l'indexation standard de tableau dynamicArray[i]
   • Peut être manipulé comme un tableau ordinaire
   • Permet un dimensionnement dynamique en fonction des conditions à l'exécution

Compilez et exécutez le programme :

g++ dynamic_array.cpp -o dynamic_array
./dynamic_array

Exemple de sortie :

Dynamic Array Contents:
Element 0: 0
Element 1: 10
Element 2: 20
Element 3: 30
Element 4: 40

Considérations importantes :

• Les tableaux dynamiques offrent une flexibilité dans l'allocation de mémoire
• La taille peut être déterminée à l'exécution
• N'oubliez pas d'utiliser new[] pour l'allocation et delete[] pour la désallocation
• Toujours faire correspondre les méthodes d'allocation et de désallocation

Supprimer des tableaux en utilisant delete[]

Dans cette étape, vous apprendrez à libérer correctement la mémoire allouée pour les tableaux dynamiques en utilisant l'opérateur delete[]. Une gestion appropriée de la mémoire est cruciale pour éviter les fuites de mémoire et garantir une utilisation efficace des ressources.

Ouvrez le WebIDE et créez un nouveau fichier appelé delete_array.cpp dans le répertoire ~/project :

touch ~/project/delete_array.cpp

Ajoutez le code suivant à delete_array.cpp :

#include <iostream>

int main() {
    // Declare the size of the dynamic array
    int arraySize = 5;

    // Create a dynamic integer array using new[]
    int* dynamicArray = new int[arraySize];

    // Initialize array elements
    for (int i = 0; i < arraySize; ++i) {
        dynamicArray[i] = i * 10;
    }

    // Print array elements before deletion
    std::cout << "Array Contents Before Deletion:" << std::endl;
    for (int i = 0; i < arraySize; ++i) {
        std::cout << "Element " << i << ": " << dynamicArray[i] << std::endl;
    }

    // Release the dynamically allocated array using delete[]
    delete[] dynamicArray;

    // Set the pointer to nullptr after deletion
    dynamicArray = nullptr;

    // Demonstrate safe pointer usage
    if (dynamicArray == nullptr) {
        std::cout << "Dynamic array has been successfully deleted" << std::endl;
    }

    return 0;
}

Points clés concernant la suppression de tableaux dynamiques :

1. delete[] dynamicArray; :

   • Libère correctement la mémoire pour l'ensemble du tableau
   • Il faut utiliser delete[] pour les tableaux alloués avec new[]
   • Prévient les fuites de mémoire
   • Appelle le destructeur pour chaque élément du tableau

2. dynamicArray = nullptr; :

   • Met le pointeur à nullptr après la suppression
   • Empêche l'accès accidentel à la mémoire libérée
   • Fournit une vérification de sécurité supplémentaire

Compilez et exécutez le programme :

g++ delete_array.cpp -o delete_array
./delete_array

Exemple de sortie :

Array Contents Before Deletion:
Element 0: 0
Element 1: 10
Element 2: 20
Element 3: 30
Element 4: 40
Dynamic array has been successfully deleted

Règles importantes de gestion de la mémoire :

• Utilisez toujours delete[] pour les tableaux alloués avec new[]
• Ne mélangez jamais delete et delete[]
• Mettez les pointeurs à nullptr après la suppression
• Chaque new[] devrait avoir un delete[] correspondant

Implémenter le pointeur intelligent shared_ptr

Dans cette étape, vous allez apprendre à utiliser shared_ptr, un pointeur intelligent de la bibliothèque standard C++ qui offre une gestion automatique de la mémoire et un comptage des références. Les pointeurs intelligents aident à prévenir les fuites de mémoire et simplifient la gestion de la mémoire.

Ouvrez le WebIDE et créez un nouveau fichier appelé shared_pointer.cpp dans le répertoire ~/project :

touch ~/project/shared_pointer.cpp

Ajoutez le code suivant à shared_pointer.cpp :

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int value) : data(value) {
        std::cout << "Constructor called. Value: " << data << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called. Value: " << data << std::endl;
    }

    int getData() const { return data; }

private:
    int data;
};

int main() {
    // Create a shared_ptr to MyClass
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>(42);

    // Create another shared_ptr pointing to the same object
    std::shared_ptr<MyClass> ptr2 = ptr1;

    // Print reference count
    std::cout << "Reference Count: " << ptr1.use_count() << std::endl;

    // Access object through shared_ptr
    std::cout << "Data from ptr1: " << ptr1->getData() << std::endl;
    std::cout << "Data from ptr2: " << ptr2->getData() << std::endl;

    // Pointers will automatically free memory when they go out of scope
    return 0;
}

Points clés concernant shared_ptr :

1. std::make_shared<MyClass>(42) :

   • Crée un pointeur partagé avec une allocation dynamique de mémoire
   • Initialise l'objet avec un argument du constructeur
   • Plus efficace que la création séparée de new et de shared_ptr

2. ptr1.use_count() :

   • Renvoie le nombre d'instances de shared_ptr pointant vers le même objet
   • Aide à suivre le compteur de références de l'objet

3. Gestion automatique de la mémoire :

   • La mémoire est automatiquement libérée lorsqu'aucun shared_ptr ne référence l'objet
   • Prévient les erreurs de gestion manuelle de la mémoire

Compilez et exécutez le programme :

g++ -std=c++11 shared_pointer.cpp -o shared_pointer
./shared_pointer

Exemple de sortie :

Constructor called. Value: 42
Reference Count: 2
Data from ptr1: 42
Data from ptr2: 42
Destructor called. Value: 42

Caractéristiques importantes de shared_ptr :

• Gestion automatique de la mémoire
• Comptage des références
• Prévention des fuites de mémoire
• Comptage des références sûr pour les threads

Utiliser unique_ptr pour une propriété exclusive

Dans cette étape, vous allez apprendre à utiliser unique_ptr, un pointeur intelligent qui offre une propriété exclusive des ressources allouées dynamiquement. Contrairement à shared_ptr, unique_ptr garantit qu'un seul pointeur peut posséder la ressource à la fois.

Ouvrez le WebIDE et créez un nouveau fichier appelé unique_pointer.cpp dans le répertoire ~/project :

touch ~/project/unique_pointer.cpp

Ajoutez le code suivant à unique_pointer.cpp :

#include <iostream>
#include <memory>

class Resource {
public:
    Resource(int value) : data(value) {
        std::cout << "Resource created. Value: " << data << std::endl;
    }

    ~Resource() {
        std::cout << "Resource destroyed. Value: " << data << std::endl;
    }

    int getData() const { return data; }

private:
    int data;
};

void processResource(std::unique_ptr<Resource> resource) {
    std::cout << "Processing resource with value: " << resource->getData() << std::endl;
    // Resource will be automatically deleted when function ends
}

int main() {
    // Create a unique_ptr
    std::unique_ptr<Resource> ptr1 = std::make_unique<Resource>(42);

    // Print resource data
    std::cout << "Resource value: " << ptr1->getData() << std::endl;

    // Transfer ownership using std::move
    std::unique_ptr<Resource> ptr2 = std::move(ptr1);

    // ptr1 is now nullptr
    if (ptr1 == nullptr) {
        std::cout << "ptr1 is now null after moving ownership" << std::endl;
    }

    // Pass unique_ptr to a function (ownership is transferred)
    processResource(std::move(ptr2));

    return 0;
}

Points clés concernant unique_ptr :

1. std::make_unique<Resource>(42) :

   • Crée un pointeur unique avec une allocation dynamique de mémoire
   • Garantit la propriété exclusive de la ressource

2. std::move(ptr1) :

   • Transfère la propriété de la ressource
   • Le pointeur d'origine devient nullptr
   • Empêche plusieurs pointeurs de posséder la même ressource

3. Gestion automatique de la mémoire :

   • La ressource est automatiquement supprimée lorsque le unique_ptr sort de portée
   • Aucune gestion manuelle de la mémoire n'est requise

Compilez et exécutez le programme :

g++ -std=c++14 unique_pointer.cpp -o unique_pointer
./unique_pointer

Exemple de sortie :

Resource created. Value: 42
Resource value: 42
ptr1 is now null after moving ownership
Processing resource with value: 42
Resource destroyed. Value: 42

Caractéristiques importantes de unique_ptr :

• Propriété exclusive
• Gestion automatique de la mémoire
• Ne peut pas être copié, seulement déplacé
• Prévention des fuites de ressources

Vérifier les fuites de mémoire

Dans cette étape, vous allez apprendre à détecter et à prévenir les fuites de mémoire en C++ en utilisant Valgrind, un outil puissant de débogage mémoire. Les fuites de mémoire se produisent lorsque la mémoire allouée dynamiquement n'est pas correctement libérée, ce qui fait que votre programme consomme de plus en plus de mémoire.

Tout d'abord, installez Valgrind dans le terminal :

sudo apt update
sudo apt install -y valgrind

Créez un exemple de fuite de mémoire dans le WebIDE en créant le fichier memory_leak.cpp dans le répertoire ~/project :

touch ~/project/memory_leak.cpp

Ajoutez le code suivant à memory_leak.cpp :

#include <iostream>

class Resource {
public:
    Resource(int value) : data(value) {
        std::cout << "Resource created: " << data << std::endl;
    }

    ~Resource() {
        std::cout << "Resource destroyed: " << data << std::endl;
    }

private:
    int data;
};

void createMemoryLeak() {
    // This creates a memory leak because the resource is not deleted
    Resource* leak = new Resource(42);
    // Missing: delete leak;
}

int main() {
    // Simulate multiple memory leaks
    for (int i = 0; i < 3; ++i) {
        createMemoryLeak();
    }

    return 0;
}

Compilez le programme avec des symboles de débogage :

g++ -g memory_leak.cpp -o memory_leak

Exécutez Valgrind pour détecter les fuites de mémoire :

valgrind --leak-check=full./memory_leak

Exemple de sortie de Valgrind :

==1988== Memcheck, a memory error detector
==1988== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==1988== Using Valgrind-3.18.1 and LibVEX; rerun with -h for copyright info
==1988== Command:./memory_leak
==1988==
Resource created: 42
Resource created: 42
Resource created: 42
==1988==
==1988== HEAP SUMMARY:
==1988==     in use at exit: 12 bytes in 3 blocks
==1988==   total heap usage: 5 allocs, 2 frees, 73,740 bytes allocated
==1988==
==1988== 12 bytes in 3 blocks are definitely lost in loss record 1 of 1
==1988==    at 0x4849013: operator new(unsigned long) (in /usr/libexec/valgrind/vgpreload_memcheck-amd64-linux.so)
==1988==    by 0x109241: createMemoryLeak() (memory_leak.cpp:19)
==1988==    by 0x109299: main (memory_leak.cpp:26)
==1988==
==1988== LEAK SUMMARY:
==1988==    definitely lost: 12 bytes in 3 blocks
==1988==    indirectly lost: 0 bytes in 0 blocks
==1988==      possibly lost: 0 bytes in 0 blocks
==1988==    still reachable: 0 bytes in 0 blocks
==1988==         suppressed: 0 bytes in 0 blocks
==1988==
==1988== For lists of detected and suppressed errors, rerun with: -s
==1988== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

Comme vous pouvez le voir, Valgrind a détecté une fuite de mémoire de 12 octets répartis sur 3 blocs. L'objet Resource créé dans createMemoryLeak() n'a pas été supprimé, ce qui a entraîné la fuite de mémoire.

Pour corriger la fuite de mémoire, modifiez le code pour supprimer correctement les ressources :

void createMemoryLeak() {
    // Properly delete the dynamically allocated resource
    Resource* leak = new Resource(42);
    delete leak;  // Add this line to prevent memory leak
}

Compilez et exécutez le programme à nouveau avec Valgrind pour vérifier que la fuite de mémoire est corrigée :

g++ -g memory_leak.cpp -o memory_leak
valgrind --leak-check=full./memory_leak

==2347== Memcheck, a memory error detector
==2347== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==2347== Using Valgrind-3.18.1 and LibVEX; rerun with -h for copyright info
==2347== Command:./memory_leak
==2347==
Resource created: 42
Resource destroyed: 42
Resource created: 42
Resource destroyed: 42
Resource created: 42
Resource destroyed: 42
==2347==
==2347== HEAP SUMMARY:
==2347==     in use at exit: 0 bytes in 0 blocks
==2347==   total heap usage: 5 allocs, 5 frees, 73,740 bytes allocated
==2347==
==2347== All heap blocks were freed -- no leaks are possible
==2347==
==2347== For lists of detected and suppressed errors, rerun with: -s
==2347== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Points clés concernant les fuites de mémoire :

• Toujours utiliser delete pour libérer la mémoire allouée dynamiquement
• Utiliser des pointeurs intelligents comme unique_ptr et shared_ptr
• Utiliser Valgrind pour détecter les fuites de mémoire
• Compiler avec le flag -g pour obtenir de meilleures informations de débogage

Gérer les échecs d'allocation mémoire

Dans cette étape, vous allez apprendre à gérer les échecs d'allocation mémoire en C++. Lorsque l'allocation dynamique de mémoire échoue, l'opérateur new lance une exception std::bad_alloc, que vous pouvez capturer et gérer de manière appropriée.

Ouvrez le WebIDE et créez un nouveau fichier appelé memory_allocation.cpp dans le répertoire ~/project :

touch ~/project/memory_allocation.cpp

Ajoutez le code suivant à memory_allocation.cpp :

#include <iostream>
#include <new>
#include <limits>

void demonstrateMemoryAllocation() {
    try {
        // Attempt to allocate a large amount of memory
        const size_t largeSize = 1000000000000; // 1 trillion integers
        int* largeArray = new int[largeSize];

        // This line will not be reached if allocation fails
        std::cout << "Memory allocation successful" << std::endl;

        // Clean up allocated memory
        delete[] largeArray;
    }
    catch (const std::bad_alloc& e) {
        // Handle memory allocation failure
        std::cerr << "Memory allocation failed: " << e.what() << std::endl;
    }
}

void safeMemoryAllocation() {
    // Use std::nothrow to prevent exception throwing
    int* safeArray = new(std::nothrow) int[1000000];

    if (safeArray == nullptr) {
        std::cerr << "Memory allocation failed silently" << std::endl;
        return;
    }

    // Use the allocated memory
    std::cout << "Safe memory allocation successful" << std::endl;

    // Clean up allocated memory
    delete[] safeArray;
}

int main() {
    std::cout << "Demonstrating memory allocation failure handling:" << std::endl;

    // Method 1: Using exception handling
    demonstrateMemoryAllocation();

    // Method 2: Using std::nothrow
    safeMemoryAllocation();

    return 0;
}

Points clés concernant la gestion des échecs d'allocation mémoire :

1. Gestion des exceptions avec std::bad_alloc :

   • Le bloc try-catch capture les exceptions d'allocation mémoire
   • Fournit des informations d'erreur détaillées
   • Empêche le plantage du programme

2. Allocation avec std::nothrow :

   • Empêche le lancement d'exceptions
   • Renvoie nullptr en cas d'échec d'allocation
   • Permet une gestion silencieuse des échecs

Compilez et exécutez le programme :

g++ memory_allocation.cpp -o memory_allocation
./memory_allocation

Exemple de sortie :

Demonstrating memory allocation failure handling:
Memory allocation failed: std::bad_alloc
Safe memory allocation successful

Stratégies importantes d'allocation mémoire :

• Vérifiez toujours les échecs d'allocation
• Utilisez la gestion des exceptions ou std::nothrow
• Implémentez des mécanismes de secours
• Évitez d'allouer des blocs de mémoire extrêmement volumineux

Résumé

Dans ce laboratoire, vous apprendrez à gérer l'allocation dynamique de mémoire en C++. Tout d'abord, vous apprendrez à utiliser l'opérateur new pour allouer dynamiquement de la mémoire à l'exécution, ce qui permet une gestion de la mémoire plus flexible par rapport à l'allocation statique. Ensuite, vous apprendrez à libérer correctement cette mémoire allouée dynamiquement en utilisant l'opérateur delete pour éviter les fuites de mémoire. De plus, vous explorerez la création de tableaux dynamiques avec new[] et leur suppression avec delete[]. Le laboratoire couvre également l'utilisation de pointeurs intelligents, tels que shared_ptr et unique_ptr, pour simplifier la gestion de la mémoire et éviter les pièges courants. Enfin, vous apprendrez des techniques pour vérifier et gérer les échecs d'allocation mémoire.