# Standard library header <new>

> C++ Atlas: `cppatlas.com/w/cpp/header/new` | Source: https://en.cppreference.com/w/cpp/header/new | Domain: Standard headers | Standards: C++11, C++17, C++20

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

## Official Specification Summary (cppreference)

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)
- `align_val_t` (C++17): type used to pass alignment to alignment-aware allocation and deallocation functions (enum)

**Types**

- `new_handler`: function pointer type of the new handler (typedef)

**Tags**

- `nothrow`, `nothrow_t`: a tag used to select a non-throwing *allocation function* (tag)
- `destroying_delete` (C++20), `destroying_delete_t`: a tag used to select destroying-delete overloads of `operator delete` (tag)

**Constants**

- `hardware_destructive_interference_size` (C++17), `hardware_constructive_interference_size`: min offset to avoid false sharing max offset to promote true sharing (constant)

**Functions**

- `operator new`, `operator new[]`: allocation functions (function)
- `operator delete`, `operator 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

```cpp
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> 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
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;
```

---
Attribution: content from https://en.cppreference.com/w/cpp/header/new (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.