Gestion de la mémoire C++ :création et suppression

Gestion de la mémoire C++ :nouveau et supprimé

Dans ce didacticiel, nous allons apprendre à gérer efficacement la mémoire en C++ en utilisant les opérations new et delete à l'aide d'exemples.

C++ nous permet d'allouer la mémoire d'une variable ou d'un tableau en temps d'exécution. C'est ce qu'on appelle l'allocation de mémoire dynamique.

Dans d'autres langages de programmation comme Java et Python, le compilateur gère automatiquement les mémoires allouées aux variables. Mais ce n'est pas le cas en C++.

En C++, nous devons désallouer manuellement la mémoire allouée dynamiquement une fois que nous n'avons plus besoin de la variable.

Nous pouvons allouer puis désallouer de la mémoire dynamiquement en utilisant le new et delete opérateurs respectivement.

Nouvel opérateur C++

Le new L'opérateur alloue de la mémoire à une variable. Par exemple,

// declare an int pointer
int* pointVar;

// dynamically allocate memory
// using the new keyword 
pointVar = new int;

// assign value to allocated memory
*pointVar = 45;

Ici, nous avons dynamiquement alloué de la mémoire pour un int variable utilisant le new opérateur.

Notez que nous avons utilisé le pointeur pointVar pour allouer dynamiquement la mémoire. C'est parce que le new l'opérateur renvoie l'adresse de l'emplacement mémoire.

Dans le cas d'un tableau, le new renvoie l'adresse du premier élément du tableau.

De l'exemple ci-dessus, nous pouvons voir que la syntaxe pour utiliser le new l'opérateur est

pointerVariable = new dataType;

supprimer l'opérateur

Une fois que nous n'avons plus besoin d'utiliser une variable que nous avons déclarée dynamiquement, nous pouvons désallouer la mémoire occupée par la variable.

Pour cela, le delete l'opérateur est utilisé. Il renvoie la mémoire au système d'exploitation. C'est ce qu'on appelle la désallocation de mémoire .

La syntaxe de cet opérateur est

delete pointerVariable;

Considérez le code :

// declare an int pointer
int* pointVar;

// dynamically allocate memory
// for an int variable 
pointVar = new int;

// assign value to the variable memory
*pointVar = 45;

// print the value stored in memory
cout << *pointVar; // Output: 45

// deallocate the memory
delete pointVar;

Ici, nous avons dynamiquement alloué de la mémoire pour un int variable utilisant le pointeur pointVar .

Après avoir imprimé le contenu de pointVar , nous avons désalloué la mémoire en utilisant delete .

Remarque :Si le programme utilise une grande quantité de mémoire indésirable en utilisant new , le système peut tomber en panne car il n'y aura pas de mémoire disponible pour le système d'exploitation. Dans ce cas, le delete l'opérateur peut aider le système à se bloquer.

Exemple 1 :Allocation dynamique de mémoire C++

#include <iostream>
using namespace std;

int main() {
    // declare an int pointer
    int* pointInt;

    // declare a float pointer
    float* pointFloat;

    // dynamically allocate memory
    pointInt = new int;
    pointFloat = new float;

    // assigning value to the memory
    *pointInt = 45;
    *pointFloat = 45.45f;

    cout << *pointInt << endl;
    cout << *pointFloat << endl;

    // deallocate the memory
    delete pointInt;
    delete pointFloat;

    return 0;
}

Sortie

45
45.45

Dans ce programme, nous avons alloué dynamiquement de la mémoire à deux variables de int et float les types. Après leur avoir attribué des valeurs et les avoir imprimées, nous désallouons enfin les mémoires à l'aide du code

delete pointInt;
delete pointFloat;

Remarque : L'allocation de mémoire dynamique peut rendre la gestion de la mémoire plus efficace.

Surtout pour les tableaux, où la plupart du temps, nous ne connaissons pas la taille du tableau avant le moment de l'exécution.

Exemple 2 :Opérateur C++ new et delete pour les tableaux

// C++ Program to store GPA of n number of students and display it
// where n is the number of students entered by the user

#include <iostream>
using namespace std;

int main() {
    int num;
    cout << "Enter total number of students: ";
    cin >> num;
    float* ptr;
    
    // memory allocation of num number of floats
    ptr = new float[num];

    cout << "Enter GPA of students." << endl;
    for (int i = 0; i < num; ++i) {
        cout << "Student" << i + 1 << ": ";
        cin >> *(ptr + i);
    }

    cout << "\nDisplaying GPA of students." << endl;
    for (int i = 0; i < num; ++i) {
        cout << "Student" << i + 1 << " :" << *(ptr + i) << endl;
    }

    // ptr memory is released
    delete[] ptr;

    return 0;
}

Sortie

Enter total number of students: 4
Enter GPA of students.
Student1: 3.6
Student2: 3.1
Student3: 3.9
Student4: 2.9

Displaying GPA of students.
Student1 :3.6
Student2 :3.1
Student3 :3.9
Student4 :2.9

Dans ce programme, nous avons demandé à l'utilisateur d'entrer le nombre d'étudiants et de le stocker dans le num variables.

Ensuite, nous avons alloué dynamiquement la mémoire pour le float tableau utilisant nouveau .

Nous entrons des données dans le tableau (et les imprimons plus tard) en utilisant la notation de pointeur.

Une fois que nous n'avons plus besoin du tableau, nous libérons la mémoire du tableau en utilisant le code delete[] ptr; .

Remarquez l'utilisation de [] après delete . Nous utilisons les crochets [] pour indiquer que la désallocation mémoire est celle d'un tableau.

Exemple 3 :Opérateur C++ new et delete pour les objets

#include <iostream>
using namespace std;

class Student {
    int age;

   public:

    // constructor initializes age to 12
    Student() : age(12) {}

    void getAge() {
        cout << "Age = " << age << endl;
    }
};

int main() {

    // dynamically declare Student object
    Student* ptr = new Student();

    // call getAge() function
    ptr->getAge();

    // ptr memory is released
    delete ptr;

    return 0;
}

Sortie

Age = 12

Dans ce programme, nous avons créé un Student classe qui a une variable privée age .

Nous avons initialisé âge à 12 dans le constructeur par défaut Student() et imprimez sa valeur avec la fonction getAge() .

En main() , nous avons créé un Student objet utilisant le new opérateur et utilisez le pointeur ptr pointer vers son adresse.

Au moment où l'objet est créé, le Student() le constructeur initialise age à 12 .

On appelle alors le getAge() fonction en utilisant le code :

ptr->getAge();

Remarquez l'opérateur fléché -> . Cet opérateur est utilisé pour accéder aux membres de la classe à l'aide de pointeurs.

Appel C++ par référence :utilisation de pointeurs [avec exemples] Héritage C++

Langue C