Standard library header <new>

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

Standard library headers

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

 

This header is part of the dynamic memory management library, in particular provides low level memory management features.

Classes
bad_alloc	exception thrown when memory allocation fails (class)
bad_array_new_length (C++11)	exception thrown on allocation of array with invalid length (class)
nothrow_t	tag type used to select a non-throwing allocation function (class)
align_val_t (C++17)	type used to pass alignment to alignment-aware allocation and deallocation functions (enum)
destroying_delete_t (C++20)	tag type used to identify destroying-delete overloads of operator delete (class)
Types
new_handler	function pointer type of the new handler (typedef)
Constants
nothrow	an object of type nothrow_t used to select a non-throwing allocation function (constant)
destroying_delete (C++20)	an object of type std::destroying_delete_t used to select destroying-delete overloads of operator delete (constant)
hardware_destructive_interference_sizehardware_constructive_interference_size (C++17)	min offset to avoid false sharing max offset to promote true sharing (constant)
Functions
operator newoperator new[]	allocation functions (function)
operator deleteoperator delete[]	deallocation functions (function)
get_new_handler (C++11)	obtains the current new handler (function)
set_new_handler	registers a new handler (function)
launder (C++17)	pointer optimization barrier (function template)

Synopsis

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;