Namensräume
Varianten
Aktionen

Header der Standardbibliothek <new>

Aus cppreference.com
< cpp‎ | header
 
 
Headerdateien der Standardbibliothek
Language Support
<tr class="t-nv"><td colspan="5">
</td></tr>
<cfloat>
<cstdint>
<new>
<typeinfo>
<tr class="t-nv"><td colspan="5">
</td></tr>
<source_location>
<exception>
<initializer_list>    
<compare>
<tr class="t-nv"><td colspan="5">
</td></tr>
<coroutine>
<csignal>
<csetjmp>
<cstdarg>
Concepts
<concepts>
Diagnostics
General utilities
Strings
<tr class="t-nv"><td colspan="5">
</td></tr>
<charconv>
<format>
<tr class="t-nv"><td colspan="5">
</td></tr>
<cctype>
<cwctype>
<tr class="t-nv"><td colspan="5">
</td></tr>
<cwchar>
<cuchar>
Localization
Containers
Iterators
<iterator>
Ranges
<ranges>
Algorithms
Numerics
Input/Output
<tr class="t-nv"><td colspan="5">
</td></tr>
<istream>
<ostream>
<iostream>
<tr class="t-nv"><td colspan="5">
</td></tr>
<cstdio>
<cinttypes>
<strstream>
Regular expressions
<regex>
Filesystem support
<filesystem>
Thread support
<tr class="t-nv"><td colspan="5">
</td></tr>
<stop_token>
<semaphore>
<tr class="t-nv"><td colspan="5">
</td></tr>
<latch>
<barrier>
C compatibility
 

Diese Headerdatei ist Teil der Bibilothek zur dynamischen Speicherverwaltung, die insbesondere Funktionen zur machinennahen Speicherverwaltung beinhaltet.

Inhaltsverzeichnis

Klassen

Ausnahme bei Fehlschlag der Speicherzuweisung
(Klasse) [edit]
Ausnahme bei ungültiger Arraylänge bei der Zuweisung
(Klasse) [edit]
Marker, um eine Allokationsfunktion auszuwählen, die keine Ausnahmen auslöst
(Klasse) [edit]
Typ, um Alignment an Allokations- und Deallokationsfunktionen zu übergeben, die dieses berücksichtigen
(enum) [edit]
Marker, um destroying-delete Überladungen von delete zu identifizieren
(Klasse) [edit]

Typen

Typ des Funktionszeiger für new
(typedef) [edit]

Konstanten

ein Objekt vom Typ nothrow_t zur Verwendung bei der Auswahl einer Allokationsfunktion, die keine Ausnahmen auslöst.
(konstanten) [edit]
minimaler Offset, um falsches Teilen zu vermeiden
maximaler Offset, um richtiges Teilen zu begünstigen
(konstanten) [edit]

Funktionen

Speicheranforderungsfunktion
(Funktion) [edit]
Speicherfreigabefunktion
(Funktion) [edit]
gibt den aktuellen Funktionszeiger auf die Allokationsfunktion zurück
(Funktion) [edit]
registriert einen neuen Funktionszeiger auf die Allokationsfunktion
(Funktion) [edit]
(C++17)
Optimisierungsschranke für Zeiger
(Funktions-Template) [edit]

[Bearbeiten] Inhaltsübersicht

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> [[nodiscard]] 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
[[nodiscard]] void* operator new(std::size_t size);
[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment);
[[nodiscard]] void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
[[nodiscard]] 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;
 
[[nodiscard]] void* operator new[](std::size_t size);
[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment);
[[nodiscard]] void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
[[nodiscard]] 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;
 
[[nodiscard]] void* operator new  (std::size_t size, void* ptr) noexcept;
[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;
void  operator delete  (void* ptr, void*) noexcept;
void  operator delete[](void* ptr, void*) noexcept;