Namespaces
Variants

    Standard library header <new>

    From fr.cppreference.net
    C++
    Standard library headers

    Cet en-tête fait partie de la bibliothèque de gestion de mémoire dynamique et fournit en particulier des fonctionnalités de gestion de mémoire bas niveau .

    Sommaire

    Classes

    		exception levée lorsque l'allocation de mémoire échoue
    (classe)
    (C++11)
    		exception levée lors de l'allocation d'un tableau avec une longueur invalide
    (classe)
    (C++17)
    		type utilisé pour passer l'alignement aux fonctions d'allocation et de désallocation prenant en compte l'alignement
    (enum)

    Types

    		type de pointeur de fonction du gestionnaire de nouvelle allocation
    (typedef)

    Tags

    		un tag utilisé pour sélectionner une fonction d'allocation non levante
    (tag)
    (C++20)
    		un tag utilisé pour sélectionner les surcharges de suppression destructrice de operator delete
    (tag)

    Constantes

    (C++17)
    		décalage minimal pour éviter le faux partage
    décalage maximal pour favoriser le vrai partage
    (constante)

    Fonctions

    		fonctions d'allocation
    (fonction)
    		fonctions de désallocation
    (fonction)
    (C++11)
    		obtient le gestionnaire de nouvelle allocation actuel
    (fonction)
    		enregistre un nouveau gestionnaire
    (fonction)
    (C++17)
    		barrière d'optimisation de pointeur
    (modèle de fonction)

    Synopsis

    // all freestanding
namespace std {
  // storage allocation errors
  class bad_alloc;
  class bad_array_new_length;

  struct destroying_delete_t
  {
    explicit destroying_delete_t() = default;
  };
  inline constexpr destroying_delete_t destroying_delete{};

  // global operator new control
  enum class align_val_t : size_t
  {
  };

  struct nothrow_t
  {
    explicit nothrow_t() = default;
  };
  extern const nothrow_t nothrow;

  using new_handler = void (*)();
  new_handler get_new_handler() noexcept;
  new_handler set_new_handler(new_handler new_p) noexcept;

  // pointer optimization barrier
  template<class T> constexpr T* launder(T* p) noexcept;

  // hardware interference size
  inline constexpr size_t hardware_destructive_interference_size =
    /* implementation-defined */;
  inline constexpr size_t hardware_constructive_interference_size =
    /* implementation-defined */;
}

// storage allocation and deallocation
void*
operator new(std::size_t size);
void*
operator new(std::size_t size, std::align_val_t alignment);
void*
operator new(std::size_t size, const std::nothrow_t&) noexcept;
void*
operator new(std::size_t size,
             std::align_val_t alignment,
             const std::nothrow_t&) noexcept;

void
operator delete(void* ptr) noexcept;
void
operator delete(void* ptr, std::size_t size) noexcept;
void
operator delete(void* ptr, std::align_val_t alignment) noexcept;
void
operator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
void
operator delete(void* ptr, const std::nothrow_t&) noexcept;
void
operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;

void*
operator new[](std::size_t size);
void*
operator new[](std::size_t size, std::align_val_t alignment);
void*
operator new[](std::size_t size, const std::nothrow_t&) noexcept;
void*
operator new[](std::size_t size,
               std::align_val_t alignment,
               const std::nothrow_t&) noexcept;

void
operator delete[](void* ptr) noexcept;
void
operator delete[](void* ptr, std::size_t size) noexcept;
void
operator delete[](void* ptr, std::align_val_t alignment) noexcept;
void
operator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
void
operator delete[](void* ptr, const std::nothrow_t&) noexcept;
void
operator delete[](void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;

constexpr void*
operator new(std::size_t size, void* ptr) noexcept;
constexpr void*
operator new[](std::size_t size, void* ptr) noexcept;
constexpr void
operator delete(void* ptr, void*) noexcept;
constexpr void
operator delete[](void* ptr, void*) noexcept;