C++ Gestion de la mémoire (new et delete)

Dans cet article, vous apprendrez à utiliser les opérations new et delete en C ++gère efficacement la mémoire.

tableaupeut être utilisé pour stocker plusieurs données de type homogène, mais l'utilisation d'un tableau comporte de graves inconvénients.

Lorsque vous déclarez un tableau, vous devez allouer de la mémoire, mais dans la plupart des cas, vous ne pouvez déterminer la mémoire exacte nécessaire qu'au moment de l'exécution.

Dans ce cas, la meilleure chose à faire est de déclarer un tableau avec la plus grande mémoire possible nécessaire (déclarer un tableau d'une taille prévue maximale possible).

Inconvénient : la mémoire non utilisée est gaspillée et ne peut pas être utilisée par d'autres programmes.

Pour éviter de gaspiller de la mémoire, vous pouvez dans C ++l'utilisation des opérateurs new et delete pour allouer dynamiquement la mémoire nécessaire au moment de l'exécution.

Exemple1：C ++gestion de la mémoire

c++Le programme stocke les notes des n étudiants et les affiche, où n est le nombre d'étudiants entré par l'utilisateur.

#include <iostream>
#include <cstring>
using namespace std;
int main()
{
　　　　int num;
　　　　cout << "Entrer le nombre total d'étudiants: ";
　　　　cin >> num;
　　　　float*　ptr;
　　　　
　　　　//　Nombre de nombres flottants alloués en mémoire
　　　　ptr = new float[num];
　　　　cout << "Entrer les notes des étudiants." << endl;
　　　　for (int i = 0; i < num;　++i)
　　　　{
　　　　　　　　cout << "étudiant" << i　+　1　<< " : ";
　　　　　　　　cin >>　*(ptr　+　i);
　　　　}
　　　　cout << "\nAfficher les notes des étudiants." << endl;
　　　　for (int i = 0; i < num;　++i) {
　　　　　　　　cout << "étudiant" << i　+　1　<< " : " <<　*(ptr　+　i) << endl;
　　　　}
　　　　//　La mémoire de ptr est libérée
　　　　delete [] ptr;
　　　　return 0;
}

Résultat de la sortie

Entrer le nombre total d'étudiants:　5
Entrer les notes des étudiants.
étudiant1:　295
étudiant2:　485
étudiant3:　650
étudiant4:　700
étudiant5:　540
Afficher les notes des étudiants.
étudiant1　:295
étudiant2　:485
étudiant3　:650
étudiant4　:700
étudiant5　:540

Dans ce programme, seule la mémoire nécessaire pour stocker num (par l'entrée utilisateur) des nombres flottants est déclarée dynamiquement.

l'opérateur new

ptr = new float[num];

L'expression dans le programme précédent renvoie un pointeur vers une partie de la mémoirepointeurqui contient exactement assez de mémoire pour容纳num des données de pointeur flottant.

l'opérateur delete

Après avoir alloué de la mémoire avec l'opérateur new, il doit être libéré à retourner au système d'exploitation.

Si le programme utilise new pour occuper une grande quantité de mémoire, le système peut s'effondrer en raison de la mémoire disponible, ce qui entraîne une épuisement de la mémoire.

L'expression suivante libère la mémoire et la restitue au système d'exploitation.

delete [] ptr;

Les crochets [] indiquent que l'array a été supprimé. Si vous devez supprimer un seul objet, vous n'avez pas besoin d'utiliser des crochets. Par exemple :

delete ptr;

Exemple2：C ++gestion de la mémoire

C ++中traiter le programme ci-dessus de manière orientée objet.

#include <iostream>
using namespace std;
class Test
{
private:
　　　　int num;
　　　　float　*ptr;
public:
　　　　Test()
　　　　{
　　　　　　　　cout << "Entrer le nombre total d'étudiants: ";
　　　　　　　　cin >> num;
　　　　　　　　
　　　　　　　　ptr = new float[num];
　　　　　　　　
　　　　　　　　cout << "Entrer les notes des étudiants." << endl;
　　　　　　　　for (int i = 0; i < num;　++i)
　　　　　　　　{
　　　　　　　　　　　　cout << "étudiant" << i　+　1　<< " : ";
　　　　　　　　　　　　cin >>　*(ptr　+　i);
　　　　　　　　}
　　　　}
　　　　
　　　　~Test() {
　　　　　　　　delete[] ptr;
　　　　}
　　　　void Display() {
　　　　　　　　cout << "\nAfficher les notes des étudiants." << endl;
　　　　　　　　for (int i = 0; i < num;　++i) {
　　　　　　　　　　　　cout << "étudiant" << i+1　<< " : " <<　*(ptr　+　i) << endl;
　　　　　　　　}
　　　　}
　　　　
};
int main() {
　　　　Test s;
　　　　s.Display();
　　　　return 0;
}

La sortie du programme est la même que celle du programme précédent.

Lors de la création de l'objet s, le constructeur est appelé et alloue de la mémoire pour num données en virgule flottante.

Le destructeur est appelé automatiquement lorsque l'objet est détruit, c'est-à-dire lorsque l'objet sort de portée.

　　　　~Test() {
　　　　　　　　delete[] ptr;
　　　　}

Ce destructeur exécute delete[] ptr; et renvoie la mémoire au système d'exploitation.