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 <iostream>
#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 <iostream>
#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 <iostream>
#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 <iostream>
#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