Namespaces
Variants

Standard library header <new>

From 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 .

Table des matières

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 

// tous autonomes
namespace std {
  // erreurs d'allocation de mémoire
  class bad_alloc;
  class bad_array_new_length;
  struct destroying_delete_t
  {
    explicit destroying_delete_t() = default;
  };
  inline constexpr destroying_delete_t destroying_delete{};
  // contrôle global de l'opérateur new
  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;
  // barrière d'optimisation de pointeur
  template<class T> constexpr T* launder(T* p) noexcept;
  // taille d'interférence matérielle
  inline constexpr size_t hardware_destructive_interference_size =
    /* défini par l'implémentation */;
  inline constexpr size_t hardware_constructive_interference_size =
    /* défini par l'implémentation */;
}
// allocation et désallocation de mémoire
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;
void
operator delete(void* ptr, void*) noexcept;
void
operator delete[](void* ptr, void*) noexcept;

Classe std::bad_alloc 

namespace std {
  class bad_alloc : public exception
  {
  public:
    // voir la description pour la spécification des fonctions membres spéciales
    constexpr const char* what() const noexcept override;
  };
}

Classe std::bad_array_new_length 

namespace std {
  class bad_array_new_length : public bad_alloc
  {
  public:
    // voir la description pour la spécification des fonctions membres spéciales
    constexpr const char* what() const noexcept override;
  };
}