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

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

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

Dans d'autres langages de programmation tels que 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 après que nous n'ayons plus besoin de la variable.

Nous pouvons allouer puis désallouer de la mémoire dynamiquement en utilisant respectivement les opérateurs newet delete.

Nouvel opérateur C ++

L' newopé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 alloué dynamiquement de la mémoire pour une intvariable à l'aide de l' newopérateur.

Notez que nous avons utilisé le pointeur pointVar pour allouer dynamiquement la mémoire. Cela est dû au fait que l' newopérateur renvoie l'adresse de l'emplacement mémoire.

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

De l'exemple ci-dessus, nous pouvons voir que la syntaxe d'utilisation de l' newopé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, l' deleteopérateur est utilisé. Il renvoie la mémoire au système d'exploitation. C'est ce qu'on appelle la désallocation de la 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 alloué dynamiquement de la mémoire pour une intvariable à l'aide du 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 new, le système peut se bloquer car il n'y aura pas de mémoire disponible pour le système d'exploitation. Dans ce cas, l' deleteopérateur peut aider le système à éviter une panne.

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

 #include 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, pointFloat; return 0; )

Production

 45 45,45

Dans ce programme, nous avons alloué dynamiquement de la mémoire à deux variables de intet floattypes. 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, 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 l'exécution.

Exemple 2: C ++ nouveau et supprimer un opérateur 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 #include using namespace std; int main() ( int num; cout <> 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 <> *(ptr + i); ) cout << "Displaying 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; )

Production

Entrez le nombre total d'étudiants: 4 Entrez GPA d'étudiants. Student1: 3.6 Student2: 3.1 Student3: 3.9 Student4: 2.9 Affichage de la moyenne des étudiants. Étudiant1: 3,6 Étudiant2: 3,1 Étudiant3: 3,9 Étudiant4: 2,9

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

Ensuite, nous avons alloué la mémoire dynamiquement pour le floattableau en utilisant new.

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

Une fois que nous n'avons plus besoin du tableau, nous désallouons la mémoire du tableau à l'aide du code delete () ptr;.

Notez l'utilisation de ()after delete. Nous utilisons les crochets ()pour indiquer que la désallocation de la mémoire est celle d'un tableau.

Exemple 3: Opérateur C ++ nouveau et supprimer pour les objets

 #include using namespace std; class Student ( int age; public: // constructor initializes age to 12 Student() : age(12) () void getAge() ( cout << "Age = " << age

Output

 Age = 12

In this program, we have created a Student class that has a private variable age.

We have initialized age to 12 in the default constructor Student() and print its value with the function getAge().

In main(), we have created a Student object using the new operator and use the pointer ptr to point to its address.

The moment the object is created, the Student() constructor initializes age to 12.

We then call the getAge() function using the code:

 ptr->getAge();

Notice the arrow operator ->. This operator is used to access class members using pointers.

Articles intéressants...