Standard library header <new>

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Standard Library header files

Language Support
<cstddef> <limits> <climits>	<cfloat> <cstdint> <new>	<typeinfo> <exception> <initializer_list>	<csignal> <csetjmp> <cstdarg>
Diagnostics
<stdexcept>	<cassert>	<cerrno>	<system_error>
General utilities
<utility> <memory> <memory_resource> <scoped_allocator>	<tuple> <optional> <any> <variant>	<bitset> <functional> <type_traits> <ratio>	<chrono> <ctime> <typeindex> <cstdlib>
Strings
<string> <string_view>	<cctype> <cwctype>	<cwchar> <cuchar>	<cstring>
Localization
<locale>	<codecvt>	<clocale>
Containers
<array> <deque> <vector>	<forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
Iterators
<iterator>
Algorithms
<algorithm>	<execution_policy>
Numerics
<complex> <random>	<valarray> <numeric>	<cfenv> <cmath>
Input/Output
<iosfwd> <iostream> <ios>	<streambuf> <istream> <ostream>	<iomanip> <sstream> <fstream>	<filesystem> <cstdio> <cinttypes>
Regular expressions
<regex>
Thread support
<thread> <atomic>	<mutex> <shared_mutex>	<condition_variable> <future>
C compatibility
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath>

 

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

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)
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 an non-throwing allocation function (class)
align_val_t (C++17)	type used to pass alignment to alignment-aware allocation and deallocation functions (class)
Types
new_handler	function pointer type of the new handler (typedef)
Objects
nothrow	an object of type nothrow_t used to select an non-throwing allocation function (constant)
hardware_destructive_interference_sizehardware_constructive_interference_size (C++17)	min offset to avoid false sharing max offset to promote true sharing (constant)

Synopsis

namespace std {
  class bad_alloc;
  class bad_array_new_length;
  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;
  template <class T> constexpr T* launder(T* p) noexcept;
  static constexpr size_t
    hardware_destructive_interference_size = /*implementation-defined*/ ;
  static constexpr size_t
    hardware_constructive_interference_size = /*implementation-defined*/ ;
}
 
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;
void* operator new (std::size_t size, void* ptr) noexcept;
void* operator new[](std::size_t size, void* ptr) noexcept;
void operator delete (void* ptr, void*) noexcept;
void operator delete[](void* ptr, void*) noexcept;