Bibliothèque de gestion de la mémoire C++<new>
C++ est un langage de programmation puissant qui offre une riche bibliothèque standard pour aider les développeurs à écrire du code plus efficacement.
En C++,<new>C'est un fichier d'en-tête très important qui contient des fonctions et des types d'exception pour l'allocation dynamique de mémoire.
L'allocation dynamique de mémoire permet aux programmes de demander de la mémoire à l'exécution, ce qui est très utile lorsqu'on traite des structures de données de taille incertaine.
<new>Le fichier d'en-tête définit les composants clés suivants :
newOpérateur : utilisé pour l'allocation dynamique de mémoire.deleteOpérateur : utilisé pour libérer la mémoire allouée dynamiquement.nothrowOpérateur : utilisé pour ne pas lever d'exception lorsque l'allocation de mémoire échoue.std::bad_allocException : levée lorsque l'allocation de mémoire échoue.
Syntaxe
UtilisationnewOpérateurs
newOpérateur utilisé pour allouer de la mémoire sur le tas. Sa syntaxe de base est la suivante :
<code class="language-cpp">pointer new (type [, initializer]);</code>
pointerest un pointeur vers la mémoire allouée.typeest le type de l'objet à allouer.initializerest une expression d'initialisation facultative.
UtilisationdeleteOpérateurs
deleteL'opérateur est utilisé pour libérer de la mémoire précédemmentnewallouée. Sa syntaxe de base est la suivante :
<code class="language-cpp">delete pointer;</code>
pointerest utilisé précédemmentnewPointeur vers la mémoire allouée.
Exemple
Allocation dynamique d'un seul objet :
Exemple
#include <new> // inclure le fichier d'en-tête <new>
class MyClass {
public:
int value;
MyClass() : value(0) {}
};
int main() {
MyClass* myObject = new MyClass; // Allouer un objet MyClass
myObject->value = 10; // Utiliser l'opérateur point pour accéder aux membres
std::cout << "Value: " << myObject->value << std::endl;
delete myObject; // libérer la mémoire
return 0;
}
Résultat de sortie :
Value: 10
Tableau alloué dynamiquement :
Exemple
#include <new>
int main() {
int* myArray = new int[10]; // Allouer un tableau de 10 entiers
for (int i = 0; i < 10; ++i) {
myArray[i] = i * 2; // Initialiser le tableau
}
for (int i = 0; i < 10; ++i) {
std::cout << "Array[" << i << "]: " << myArray[i] << std::endl;
}
delete[] myArray; // Libérer la mémoire du tableau
return 0;
}
Résultat de sortie :
Array[0]: 0 Array[1]: 2 Array[2]: 4 Array[3]: 6 Array[4]: 8 Array[5]: 10 Array[6]: 12 Array[7]: 14 Array[8]: 16 Array[9]: 18
Utilisation de nothrow pour éviter les exceptions :
Exemple
#include <new>
int main() {
int* myArray = new(std::nothrow) int[10000000]; // Essayer d'allouer un grand tableau
if (!myArray) {
std::cout << "Échec de l'allocation mémoire." << std::endl;
} else {
std::cout << "Allocation de mémoire réussie." << std::endl;
delete[] myArray; // libérer la mémoire
}
return 0;
}
Résultat de sortie :
Memory allocation failed. // 或者 Memory allocation succeeded. 取决于系统内存情况
Gestion des exceptions
Lorsque l'allocation de mémoire avec l'opérateur new échoue, C++ lève une exception std::bad_alloc.
Les développeurs peuvent intercepter et gérer cette exception à l'aide d'un bloc try-catch.
Exemple
#include <new>
int main() {
try {
int* myArray = new int[10000000]; // Essayer d'allouer un grand tableau
std::cout << "Allocation de mémoire réussie." << std::endl;
delete[] myArray; // libérer la mémoire
} catch (const std::bad_alloc& e) {
std::cout << "Exception interceptée : " << e.what() << std::endl;
}
return 0;
}
Résultat de sortie :
Exception caught: std::bad_alloc // 如果内存分配失败autres extensions