Header der Standardbibliothek <new>

 

C++

Sprache

Concepts

Utilities-Bibliothek

Strings Bibliothek

Container-Bibliothek

Algorithmen-Bibliothek

Iteratoren Bibliothek

Numerik-Bibliothek

Input / Output-Bibliothek

Lokalisierungen Bibliothek

Reguläre Ausdrücke Bibliothek (C++11)

Atomare Operationen Bibliothek (C++11)

Thread Support-Bibliothek (C++11)

 

Headerdateien der Standardbibliothek

Language Support
<cstddef> <cstdlib> <version> <limits> <climits>	<cfloat> <cstdint> <new> <typeinfo>	<source_location> <exception> <initializer_list>     <compare>	<coroutine> <csignal> <csetjmp> <cstdarg>
Concepts
<concepts>
Diagnostics
<stdexcept>	<cassert>	<cerrno>	<system_error>
General utilities
<utility> <memory> <memory_resource> <scoped_allocator>	<bitset> <tuple> <optional> <any>	<variant> <type_traits> <ratio> <chrono>	<typeindex> <functional> <stacktrace> <ctime>
Strings
<string> <string_view> <cstring>	<charconv> <format>	<cctype> <cwctype>	<cwchar> <cuchar>
Localization
<locale>	<codecvt>	<clocale>
Containers
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
Iterators
<iterator>
Ranges
<ranges>
Algorithms
<algorithm>	<execution>
Numerics
<complex> <random>	<valarray> <numeric>	<bit> <numbers>	<cfenv> <cmath>
Input/Output
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <spanstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
Regular expressions
<regex>
Filesystem support
<filesystem>
Thread support
<thread> <atomic> <mutex>	<shared_mutex> <condition_variable>     <future>	<stop_token> <semaphore>	<latch> <barrier>
C compatibility
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath> <stdatomic.h>

 

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

Klassen
bad_alloc	Ausnahme bei Fehlschlag der Speicherzuweisung (Klasse)
bad_array_new_length (C++11)	Ausnahme bei ungültiger Arraylänge bei der Zuweisung (Klasse)
nothrow_t	Marker, um eine Allokationsfunktion auszuwählen, die keine Ausnahmen auslöst (Klasse)
align_val_t (C++17)	Typ, um Alignment an Allokations- und Deallokationsfunktionen zu übergeben, die dieses berücksichtigen (enum)
destroying_delete_t (C++20)	Marker, um destroying-delete Überladungen von delete zu identifizieren (Klasse)
Typen
new_handler	Typ des Funktionszeiger für new (typedef)
Konstanten
nothrow	ein Objekt vom Typ nothrow_t zur Verwendung bei der Auswahl einer Allokationsfunktion, die keine Ausnahmen auslöst. (konstanten)
hardware_destructive_interference_size hardware_constructive_interference_size (C++17)	minimaler Offset, um falsches Teilen zu vermeiden maximaler Offset, um richtiges Teilen zu begünstigen (konstanten)
Funktionen
operator new operator new[]	Speicheranforderungsfunktion (Funktion)
operator delete operator delete[]	Speicherfreigabefunktion (Funktion)
get_new_handler (C++11)	gibt den aktuellen Funktionszeiger auf die Allokationsfunktion zurück (Funktion)
set_new_handler	registriert einen neuen Funktionszeiger auf die Allokationsfunktion (Funktion)
launder (C++17)	Optimisierungsschranke für Zeiger (Funktions-Template)

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;