Standard library header - cppreference.com (original) (raw)

This header is part of the dynamic memory management library.

[edit] Synopsis

#include   namespace std { // pointer Traits template struct pointer_traits; // freestanding template struct pointer_traits<T*>; // freestanding   // pointer conversion template constexpr T* to_address(T* p) noexcept; // freestanding template constexpr auto to_address(const Ptr& p) noexcept; // freestanding   // pointer alignment void* align(size_t alignment, size_t size, void*& ptr, size_t& space); // freestanding template<size_t N, class T> constexpr T* assume_aligned(T* ptr); // freestanding template<size_t Alignment, class T> bool is_sufficiently_aligned(T* ptr);   // explicit lifetime management template T* start_lifetime_as(void* p) noexcept; // freestanding template const T* start_lifetime_as(const void* p) noexcept; // freestanding template volatile T* start_lifetime_as(volatile void* p) noexcept; // freestanding template const volatile T* start_lifetime_as(const volatile void* p) noexcept; // freestanding template T* start_lifetime_as_array(void* p, size_t n) noexcept; // freestanding template const T* start_lifetime_as_array(const void* p, size_t n) noexcept; // freestanding template volatile T* start_lifetime_as_array(volatile void* p, size_t n) noexcept; // freestanding template const volatile T* start_lifetime_as_array(const volatile void* p, // freestanding size_t n) noexcept; template T* trivially_relocate(T* first, T* last, T* result); // freestanding template constexpr T* relocate(T* first, T* last, T* result); // freestanding   // allocator argument tag struct allocator_arg_t { explicit allocator_arg_t() = default; }; // freestanding inline constexpr allocator_arg_t allocator_arg{}; // freestanding   // uses_allocator template<class T, class Alloc> struct uses_allocator; // freestanding   // uses_allocator template<class T, class Alloc> constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value; // freestanding   // uses-allocator construction template<class T, class Alloc, class... Args> constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding Args&&... args) noexcept; template<class T, class Alloc, class Tuple1, class Tuple2> constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding piecewise_construct_t, Tuple1&& x, Tuple2&& y) noexcept; template<class T, class Alloc> constexpr auto uses_allocator_construction_args( const Alloc& alloc) noexcept; // freestanding template<class T, class Alloc, class U, class V> constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding U&& u, V&& v) noexcept; template<class T, class Alloc, class U, class V> constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding pair<U, V>& pr) noexcept; template<class T, class Alloc, class U, class V> constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding const pair<U, V>& pr) noexcept; template<class T, class Alloc, class U, class V> constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding pair<U, V>&& pr) noexcept; template<class T, class Alloc, class U, class V> constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding const pair<U, V>&& pr) noexcept; template<class T, class Alloc, /pair-like*/ P> constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding P&& p) noexcept; template<class T, class Alloc, class U> constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding U&& u) noexcept; template<class T, class Alloc, class... Args> constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args); // freestanding template<class T, class Alloc, class... Args> constexpr T uninitialized_construct_using_allocator(T* p, // freestanding const Alloc& alloc, Args&&... args);   // allocator Traits template struct allocator_traits; // freestanding   template<class Pointer, class SizeType = size_t> struct allocation_result { // freestanding Pointer ptr; SizeType count; };   // the default allocator template class allocator; template<class T, class U> constexpr bool operator==(const allocator&, const allocator&) noexcept;   // addressof template constexpr T* addressof(T& r) noexcept; // freestanding template const T* addressof(const T&&) = delete; // freestanding   // specialized algorithms // special memory concepts template concept no-throw-input-iterator = /* see description /; // exposition-only template concept no-throw-forward-iterator = / see description /; // exposition-only template<class S, class I> concept no-throw-sentinel-for = / see description /; // exposition-only template concept no-throw-input-range = / see description /; // exposition-only template concept no-throw-forward-range = / see description /; // exposition-only   template constexpr void uninitialized_default_construct(NoThrowForwardIter first, // freestanding NoThrowForwardIter last); template<class ExecutionPolicy, class NoThrowForwardIter> void uninitialized_default_construct(ExecutionPolicy&& exec, // freestanding-deleted, NoThrowForwardIter first, NoThrowForwardIter last); template<class NoThrowForwardIter, class Size> constexpr NoThrowForwardIter uninitialized_default_construct_n(NoThrowForwardIter first, Size n); // freestanding template<class ExecutionPolicy, class NoThrowForwardIter, class Size> NoThrowForwardIter uninitialized_default_construct_n( ExecutionPolicy&& exec, // freestanding-deleted, NoThrowForwardIter first, Size n);   namespace ranges { template<no-throw-forward-iterator I, no-throw-sentinel-for S> requires default_initializable<iter_value_t> constexpr I uninitialized_default_construct(I first, S last); // freestanding template<no-throw-forward-range R> requires default_initializable<range_value_t> constexpr borrowed_iterator_t uninitialized_default_construct( R&& r); // freestanding   template<no-throw-forward-iterator I> requires default_initializable<iter_value_t> constexpr I uninitialized_default_construct_n(I first, // freestanding iter_difference_t n); }   template constexpr void uninitialized_value_construct(NoThrowForwardIter first, // freestanding NoThrowForwardIter last); template<class ExecutionPolicy, class NoThrowForwardIter> void uninitialized_value_construct(ExecutionPolicy&& exec, // freestanding-deleted, NoThrowForwardIter first, NoThrowForwardIter last); template<class NoThrowForwardIter, class Size> constexpr NoThrowForwardIter uninitialized_value_construct_n(NoThrowForwardIter first, Size n); // freestanding template<class ExecutionPolicy, class NoThrowForwardIter, class Size> NoThrowForwardIter uninitialized_value_construct_n( ExecutionPolicy&& exec, // freestanding-deleted, NoThrowForwardIter first, Size n);   namespace ranges { template<no-throw-forward-iterator I, no-throw-sentinel-for S> requires default_initializable<iter_value_t> constexpr I uninitialized_value_construct(I first, S last); // freestanding template<no-throw-forward-range R> requires default_initializable<range_value_t> constexpr borrowed_iterator_t uninitialized_value_construct(R&& r); // freestanding   template<no-throw-forward-iterator I> requires default_initializable<iter_value_t> constexpr I uninitialized_value_construct_n(I first, // freestanding iter_difference_t n); }   template<class InputIter, class NoThrowForwardIter> constexpr NoThrowForwardIter uninitialized_copy(InputIter first, // freestanding InputIter last, NoThrowForwardIter result); template<class ExecutionPolicy, class ForwardIter, class NoThrowForwardIter> NoThrowForwardIter uninitialized_copy(ExecutionPolicy&& exec, // freestanding-deleted, ForwardIter first, ForwardIter last, NoThrowForwardIter result); template<class InputIter, class Size, class NoThrowForwardIter> constexpr NoThrowForwardIter uninitialized_copy_n(InputIter first, // freestanding Size n, NoThrowForwardIter result); template<class ExecutionPolicy, class ForwardIter, class Size, class NoThrowForwardIter> NoThrowForwardIter uninitialized_copy_n(ExecutionPolicy&& exec, // freestanding-deleted, ForwardIter first, Size n, NoThrowForwardIter result);   namespace ranges { template<class I, class O> using uninitialized_copy_result = in_out_result<I, O>; // freestanding template<input_iterator I, sentinel_for S1, no-throw-forward-iterator O, no-throw-sentinel-for S2> requires constructible_from<iter_value_t, iter_reference_t> constexpr uninitialized_copy_result<I, O> uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast); // freestanding template<input_range IR, no-throw-forward-range OR> requires constructible_from<range_value_t, range_reference_t> constexpr uninitialized_copy_result<borrowed_iterator_t, borrowed_iterator_t> uninitialized_copy(IR&& in_range, OR&& out_range); // freestanding   template<class I, class O> using uninitialized_copy_n_result = in_out_result<I, O>; // freestanding template<input_iterator I, no-throw-forward-iterator O, no-throw-sentinel-for S> requires constructible_from<iter_value_t, iter_reference_t> constexpr uninitialized_copy_n_result<I, O> uninitialized_copy_n( I ifirst, iter_difference_t n, // freestanding O ofirst, S olast); }   template<class InputIter, class NoThrowForwardIter> constexpr NoThrowForwardIter uninitialized_move(InputIter first, // freestanding InputIter last, NoThrowForwardIter result); template<class ExecutionPolicy, class ForwardIter, class NoThrowForwardIter> NoThrowForwardIter uninitialized_move(ExecutionPolicy&& exec, // freestanding-deleted, ForwardIter first, ForwardIter last, NoThrowForwardIter result); template<class InputIter, class Size, class NoThrowForwardIter> constexpr pair<InputIter, NoThrowForwardIter> uninitialized_move_n( InputIter first, Size n, // freestanding NoThrowForwardIter result); template<class ExecutionPolicy, class ForwardIter, class Size, class NoThrowForwardIter> pair<ForwardIter, NoThrowForwardIter> uninitialized_move_n( ExecutionPolicy&& exec, // freestanding-deleted, ForwardIter first, Size n, NoThrowForwardIter result);   namespace ranges { template<class I, class O> using uninitialized_move_result = in_out_result<I, O>; // freestanding template<input_iterator I, sentinel_for S1, no-throw-forward-iterator O, no-throw-sentinel-for S2> requires constructible_from<iter_value_t, iter_rvalue_reference_t> constexpr uninitialized_move_result<I, O> uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast); // freestanding template<input_range IR, no-throw-forward-range OR> requires constructible_from<range_value_t, range_rvalue_reference_t> constexpr uninitialized_move_result<borrowed_iterator_t, borrowed_iterator_t> uninitialized_move(IR&& in_range, OR&& out_range); // freestanding   template<class I, class O> using uninitialized_move_n_result = in_out_result<I, O>; // freestanding template<input_iterator I, no-throw-forward-iterator O, no-throw-sentinel-for S> requires constructible_from<iter_value_t, iter_rvalue_reference_t> constexpr uninitialized_move_n_result<I, O> uninitialized_move_n( I ifirst, iter_difference_t n, // freestanding O ofirst, S olast); }   template<class NoThrowForwardIter, class T> constexpr void uninitialized_fill(NoThrowForwardIter first, // freestanding NoThrowForwardIter last, const T& x); template<class ExecutionPolicy, class NoThrowForwardIter, class T> void uninitialized_fill(ExecutionPolicy&& exec, // freestanding-deleted, NoThrowForwardIter first, NoThrowForwardIter last, const T& x); template<class NoThrowForwardIter, class Size, class T> constexpr NoThrowForwardIter uninitialized_fill_n(NoThrowForwardIter first, Size n, const T& x); // freestanding template<class ExecutionPolicy, class NoThrowForwardIter, class Size, class T> NoThrowForwardIter uninitialized_fill_n(ExecutionPolicy&& exec, // freestanding-deleted, NoThrowForwardIter first, Size n, const T& x);   namespace ranges { template<no-throw-forward-iterator I, no-throw-sentinel-for S, class T> requires constructible_from<iter_value_t, const T&> constexpr I uninitialized_fill(I first, S last, const T& x); // freestanding template<no-throw-forward-range R, class T> requires constructible_from<range_value_t, const T&> constexpr borrowed_iterator_t uninitialized_fill(R&& r, const T& x); // freestanding   template<no-throw-forward-iterator I, class T> requires constructible_from<iter_value_t, const T&> constexpr I uninitialized_fill_n(I first, // freestanding iter_difference_t n, const T& x); }   // construct_at template<class T, class... Args> constexpr T construct_at(T* location, Args&&... args); // freestanding   namespace ranges { template<class T, class... Args> constexpr T* construct_at(T* location, Args&&... args); // freestanding }   // destroy template constexpr void destroy_at(T* location); // freestanding template constexpr void destroy(NoThrowForwardIter first, // freestanding NoThrowForwardIter last); template<class ExecutionPolicy, class NoThrowForwardIter> void destroy(ExecutionPolicy&& exec, // freestanding-deleted, NoThrowForwardIter first, NoThrowForwardIter last); template<class NoThrowForwardIter, class Size> constexpr NoThrowForwardIter destroy_n(NoThrowForwardIter first, // freestanding Size n); template<class ExecutionPolicy, class NoThrowForwardIter, class Size> NoThrowForwardIter destroy_n(ExecutionPolicy&& exec, // freestanding-deleted, NoThrowForwardIter first, Size n);   namespace ranges { template constexpr void destroy_at(T* location) noexcept; // freestanding   template<no-throw-input-iterator I, no-throw-sentinel-for S> requires destructible<iter_value_t> constexpr I destroy(I first, S last) noexcept; // freestanding template<no-throw-input-range R> requires destructible<range_value_t> constexpr borrowed_iterator_t destroy(R&& r) noexcept; // freestanding   template<no-throw-input-iterator I> requires destructible<iter_value_t> constexpr I destroy_n(I first, iter_difference_t n) noexcept; // freestanding }   // class template unique_ptr template struct default_delete; // freestanding template struct default_delete<T[]>; // freestanding template<class T, class D = default_delete> class unique_ptr; // freestanding template<class T, class D> class unique_ptr<T[], D>; // freestanding   template<class T, class... Args> constexpr unique_ptr make_unique(Args&&... args); // T is not array template constexpr unique_ptr make_unique(size_t n); // T is U[] template<class T, class... Args> /* unspecified / make_unique(Args&&...) = delete; // T is U[N]   template constexpr unique_ptr make_unique_for_overwrite(); // T is not array template constexpr unique_ptr make_unique_for_overwrite(size_t n); // T is U[] template<class T, class... Args> / unspecified / make_unique_for_overwrite(Args&&...) = delete; // T is U[N]   template<class T, class D> constexpr void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept; // freestanding   template<class T1, class D1, class T2, class D2> constexpr bool operator==(const unique_ptr<T1, D1>& x, // freestanding const unique_ptr<T2, D2>& y); template<class T1, class D1, class T2, class D2> bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); // freestanding template<class T1, class D1, class T2, class D2> bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); // freestanding template<class T1, class D1, class T2, class D2> bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); // freestanding template<class T1, class D1, class T2, class D2> bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); // freestanding template<class T1, class D1, class T2, class D2> requires three_way_comparable_with<typename unique_ptr<T1, D1>::pointer, typename unique_ptr<T2, D2>::pointer> compare_three_way_result_t<typename unique_ptr<T1, D1>::pointer, typename unique_ptr<T2, D2>::pointer> operator<=>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); // freestanding   template<class T, class D> constexpr bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept; // freestanding template<class T, class D> constexpr bool operator<(const unique_ptr<T, D>& x, nullptr_t); // freestanding template<class T, class D> constexpr bool operator<(nullptr_t, const unique_ptr<T, D>& y); // freestanding template<class T, class D> constexpr bool operator>(const unique_ptr<T, D>& x, nullptr_t); // freestanding template<class T, class D> constexpr bool operator>(nullptr_t, const unique_ptr<T, D>& y); // freestanding template<class T, class D> constexpr bool operator<=(const unique_ptr<T, D>& x, nullptr_t); // freestanding template<class T, class D> constexpr bool operator<=(nullptr_t, const unique_ptr<T, D>& y); // freestanding template<class T, class D> constexpr bool operator>=(const unique_ptr<T, D>& x, nullptr_t); // freestanding template<class T, class D> constexpr bool operator>=(nullptr_t, const unique_ptr<T, D>& y); // freestanding template<class T, class D> requires three_way_comparable<typename unique_ptr<T, D>::pointer> constexpr compare_three_way_result_t<typename unique_ptr<T, D>::pointer> operator<=>( const unique_ptr<T, D>& x, nullptr_t); // freestanding   template<class E, class T, class Y, class D> basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const unique_ptr<Y, D>& p);   // class bad_weak_ptr class bad_weak_ptr;   // class template shared_ptr template class shared_ptr;   // shared_ptr creation template<class T, class... Args> shared_ptr make_shared(Args&&... args); // T is not array template<class T, class A, class... Args> shared_ptr allocate_shared(const A& a, Args&&... args); // T is not array   template shared_ptr make_shared(size_t N); // T is U[] template<class T, class A> shared_ptr allocate_shared(const A& a, size_t N); // T is U[]   template shared_ptr make_shared(); // T is U[N] template<class T, class A> shared_ptr allocate_shared(const A& a); // T is U[N]   template shared_ptr make_shared(size_t N, const remove_extent_t& u); // T is U[] template<class T, class A> shared_ptr allocate_shared(const A& a, size_t N, const remove_extent_t& u); // T is U[]   template shared_ptr make_shared(const remove_extent_t& u); // T is U[N] template<class T, class A> shared_ptr allocate_shared(const A& a, const remove_extent_t& u); // T is U[N]   template shared_ptr make_shared_for_overwrite(); // T is not U[] template<class T, class A> shared_ptr allocate_shared_for_overwrite(const A& a); // T is not U[]   template shared_ptr make_shared_for_overwrite(size_t N); // T is U[] template<class T, class A> shared_ptr allocate_shared_for_overwrite(const A& a, size_t N); // T is U[]   // shared_ptr comparisons template<class T, class U> bool operator==(const shared_ptr& a, const shared_ptr& b) noexcept; template<class T, class U> strong_ordering operator<=>(const shared_ptr& a, const shared_ptr& b) noexcept;   template bool operator==(const shared_ptr& x, nullptr_t) noexcept; template strong_ordering operator<=>(const shared_ptr& x, nullptr_t) noexcept;   // shared_ptr specialized algorithms template void swap(shared_ptr& a, shared_ptr& b) noexcept;   // shared_ptr casts template<class T, class U> shared_ptr static_pointer_cast(const shared_ptr& r) noexcept; template<class T, class U> shared_ptr static_pointer_cast(shared_ptr&& r) noexcept; template<class T, class U> shared_ptr dynamic_pointer_cast(const shared_ptr& r) noexcept; template<class T, class U> shared_ptr dynamic_pointer_cast(shared_ptr&& r) noexcept; template<class T, class U> shared_ptr const_pointer_cast(const shared_ptr& r) noexcept; template<class T, class U> shared_ptr const_pointer_cast(shared_ptr&& r) noexcept; template<class T, class U> shared_ptr reinterpret_pointer_cast(const shared_ptr& r) noexcept; template<class T, class U> shared_ptr reinterpret_pointer_cast(shared_ptr&& r) noexcept;   // shared_ptr get_deleter template<class D, class T> D get_deleter(const shared_ptr& p) noexcept;   // shared_ptr I/O template<class E, class T, class Y> basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr& p);   // class template weak_ptr template class weak_ptr;   // weak_ptr specialized algorithms template void swap(weak_ptr& a, weak_ptr& b) noexcept;   // class template owner_less template struct owner_less;   // struct owner_hash struct owner_hash;   // struct owner_equal struct owner_equal;   // class template enable_shared_from_this template class enable_shared_from_this;   // hash support template struct hash; // freestanding template<class T, class D> struct hash<unique_ptr<T, D>>; // freestanding template struct hash<shared_ptr>;   // atomic smart pointers template struct atomic; // freestanding template struct atomic<shared_ptr>; template struct atomic<weak_ptr>;   // class template out_ptr_t template<class Smart, class Pointer, class... Args> class out_ptr_t; // freestanding   // function template out_ptr template<class Pointer = void, class Smart, class... Args> auto out_ptr(Smart& s, Args&&... args); // freestanding   // class template inout_ptr_t template<class Smart, class Pointer, class... Args> class inout_ptr_t; // freestanding   // function template inout_ptr template<class Pointer = void, class Smart, class... Args> auto inout_ptr(Smart& s, Args&&... args); // freestanding   // class template indirect template<class T, class Allocator = allocator> class indirect;   // hash support template<class T, class Alloc> struct hash<indirect<T, Alloc>>;   // class template polymorphic template<class T, class Allocator = allocator> class polymorphic;   namespace pmr { template using indirect = indirect<T, polymorphic_allocator>; template using polymorphic = polymorphic<T, polymorphic_allocator>; } }

[edit] Helper concepts

Note: These names are only for exposition, they are not part of the interface.

[edit] Class template std::pointer_traits

namespace std { template struct pointer_traits { /* see description /; };   template struct pointer_traits<T*> { using pointer = T; using element_type = T; using difference_type = ptrdiff_t;   template using rebind = U*;   static constexpr pointer pointer_to(/* see description */ r) noexcept; }; }

[edit] Class std::allocator_arg_t

namespace std { struct allocator_arg_t { explicit allocator_arg_t() = default; }; inline constexpr allocator_arg_t allocator_arg{}; }

[edit] Class template std::allocator_traits

namespace std { template struct allocator_traits { using allocator_type = Alloc;   using value_type = typename Alloc::value_type;   using pointer = /* see description /; using const_pointer = / see description /; using void_pointer = / see description /; using const_void_pointer = / see description /;   using difference_type = / see description /; using size_type = / see description /;   using propagate_on_container_copy_assignment = / see description /; using propagate_on_container_move_assignment = / see description /; using propagate_on_container_swap = / see description /; using is_always_equal = / see description /;   template using rebind_alloc = / see description /; template using rebind_traits = allocator_traits<rebind_alloc>;   static constexpr pointer allocate(Alloc& a, size_type n); static constexpr pointer allocate(Alloc& a, size_type n, const_void_pointer hint); static constexpr allocation_result<pointer, size_type> allocate_at_least(Alloc& a, size_type n);   static constexpr void deallocate(Alloc& a, pointer p, size_type n);   template<class T, class... Args> static constexpr void construct(Alloc& a, T p, Args&&... args);   template static constexpr void destroy(Alloc& a, T* p);   static constexpr size_type max_size(const Alloc& a) noexcept;   static constexpr Alloc select_on_container_copy_construction(const Alloc& rhs); }; }

[edit] Class template std::allocator

namespace std { template class allocator { public: using value_type = T; using size_type = size_t; using difference_type = ptrdiff_t; using propagate_on_container_move_assignment = true_type;   constexpr allocator() noexcept; constexpr allocator(const allocator&) noexcept; template constexpr allocator(const allocator&) noexcept; constexpr ~allocator(); constexpr allocator& operator=(const allocator&) = default;   constexpr T* allocate(size_t n); constexpr allocation_result<T*> allocate_at_least(size_t n); constexpr void deallocate(T* p, size_t n); }; }

[edit] Class template std::default_delete

namespace std { template struct default_delete { constexpr default_delete() noexcept = default; template constexpr default_delete(const default_delete&) noexcept; constexpr void operator()(T*) const; };   template struct default_delete<T[]> { constexpr default_delete() noexcept = default; template constexpr default_delete(const default_delete<U[]>&) noexcept; template constexpr void operator()(U* ptr) const; }; }

[edit] Class template std::unique_ptr

namespace std { template<class T, class D = default_delete> class unique_ptr { public: using pointer = /* see description /; using element_type = T; using deleter_type = D;   // constructors constexpr unique_ptr() noexcept; constexpr explicit unique_ptr(type_identity_t p) noexcept; constexpr unique_ptr(type_identity_t p, / see description / d1) noexcept; constexpr unique_ptr(type_identity_t p, / see description / d2) noexcept; constexpr unique_ptr(unique_ptr&& u) noexcept; constexpr unique_ptr(nullptr_t) noexcept; template<class U, class E> constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept;   // destructor constexpr ~unique_ptr();   // assignment constexpr unique_ptr& operator=(unique_ptr&& u) noexcept; template<class U, class E> constexpr unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept; constexpr unique_ptr& operator=(nullptr_t) noexcept;   // observers constexpr add_lvalue_reference_t operator() const noexcept(/* see description /); constexpr pointer operator->() const noexcept; constexpr pointer get() const noexcept; constexpr deleter_type& get_deleter() noexcept; constexpr const deleter_type& get_deleter() const noexcept; constexpr explicit operator bool() const noexcept;   // modifiers constexpr pointer release() noexcept; constexpr void reset(pointer p = pointer()) noexcept; constexpr void swap(unique_ptr& u) noexcept;   // disable copy from lvalue unique_ptr(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete; };   template<class T, class D> class unique_ptr<T[], D> { public: using pointer = / see description /; using element_type = T; using deleter_type = D;   // constructors constexpr unique_ptr() noexcept; template constexpr explicit unique_ptr(U p) noexcept; template constexpr unique_ptr(U p, / see description / d) noexcept; template constexpr unique_ptr(U p, / see description */ d) noexcept; constexpr unique_ptr(unique_ptr&& u) noexcept; template<class U, class E> constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept; constexpr unique_ptr(nullptr_t) noexcept;   // destructor constexpr ~unique_ptr();   // assignment constexpr unique_ptr& operator=(unique_ptr&& u) noexcept; template<class U, class E> constexpr unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept; constexpr unique_ptr& operator=(nullptr_t) noexcept;   // observers constexpr T& operator[](size_t i) const; constexpr pointer get() const noexcept; constexpr deleter_type& get_deleter() noexcept; constexpr const deleter_type& get_deleter() const noexcept; constexpr explicit operator bool() const noexcept;   // modifiers constexpr pointer release() noexcept; template constexpr void reset(U p) noexcept; constexpr void reset(nullptr_t = nullptr) noexcept; constexpr void swap(unique_ptr& u) noexcept;   // disable copy from lvalue unique_ptr(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete; }; }

[edit] Class std::bad_weak_ptr

namespace std { class bad_weak_ptr : public exception { public: // for the specification of the special member functions const char* what() const noexcept override; }; }

[edit] Class template std::shared_ptr

namespace std { template class shared_ptr { public: using element_type = remove_extent_t; using weak_type = weak_ptr;   // constructors constexpr shared_ptr() noexcept; constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { } template explicit shared_ptr(Y* p); template<class Y, class D> shared_ptr(Y* p, D d); template<class Y, class D, class A> shared_ptr(Y* p, D d, A a); template shared_ptr(nullptr_t p, D d); template<class D, class A> shared_ptr(nullptr_t p, D d, A a); template shared_ptr(const shared_ptr& r, element_type* p) noexcept; template shared_ptr(shared_ptr&& r, element_type* p) noexcept; shared_ptr(const shared_ptr& r) noexcept; template shared_ptr(const shared_ptr& r) noexcept; shared_ptr(shared_ptr&& r) noexcept; template shared_ptr(shared_ptr&& r) noexcept; template explicit shared_ptr(const weak_ptr& r); template<class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);   // destructor ~shared_ptr();   // assignment shared_ptr& operator=(const shared_ptr& r) noexcept; template shared_ptr& operator=(const shared_ptr& r) noexcept; shared_ptr& operator=(shared_ptr&& r) noexcept; template shared_ptr& operator=(shared_ptr&& r) noexcept; template<class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);   // modifiers void swap(shared_ptr& r) noexcept; void reset() noexcept; template void reset(Y* p); template<class Y, class D> void reset(Y* p, D d); template<class Y, class D, class A> void reset(Y* p, D d, A a);   // observers element_type* get() const noexcept; T& operator*() const noexcept; T* operator->() const noexcept; element_type& operator[](ptrdiff_t i) const; long use_count() const noexcept; explicit operator bool() const noexcept; template bool owner_before(const shared_ptr& b) const noexcept; template bool owner_before(const weak_ptr& b) const noexcept; size_t owner_hash() const noexcept; template bool owner_equal(const shared_ptr& b) const noexcept; template bool owner_equal(const weak_ptr& b) const noexcept; };   template shared_ptr(weak_ptr) -> shared_ptr; template<class T, class D> shared_ptr(unique_ptr<T, D>) -> shared_ptr; }

[edit] Class template std::weak_ptr

namespace std { template class weak_ptr { public: using element_type = remove_extent_t;   // constructors constexpr weak_ptr() noexcept; template weak_ptr(const shared_ptr& r) noexcept; weak_ptr(const weak_ptr& r) noexcept; template weak_ptr(const weak_ptr& r) noexcept; weak_ptr(weak_ptr&& r) noexcept; template weak_ptr(weak_ptr&& r) noexcept;   // destructor ~weak_ptr();   // assignment weak_ptr& operator=(const weak_ptr& r) noexcept; template weak_ptr& operator=(const weak_ptr& r) noexcept; template weak_ptr& operator=(const shared_ptr& r) noexcept; weak_ptr& operator=(weak_ptr&& r) noexcept; template weak_ptr& operator=(weak_ptr&& r) noexcept;   // modifiers void swap(weak_ptr& r) noexcept; void reset() noexcept;   // observers long use_count() const noexcept; bool expired() const noexcept; shared_ptr lock() const noexcept; template bool owner_before(const shared_ptr& b) const noexcept; template bool owner_before(const weak_ptr& b) const noexcept; size_t owner_hash() const noexcept; template bool owner_equal(const shared_ptr& b) const noexcept; template bool owner_equal(const weak_ptr& b) const noexcept; };   template weak_ptr(shared_ptr) -> weak_ptr; }

[edit] Class template std::owner_less

namespace std { template struct owner_less;   template struct owner_less<shared_ptr> { bool operator()(const shared_ptr&, const shared_ptr&) const noexcept; bool operator()(const shared_ptr&, const weak_ptr&) const noexcept; bool operator()(const weak_ptr&, const shared_ptr&) const noexcept; };   template struct owner_less<weak_ptr> { bool operator()(const weak_ptr&, const weak_ptr&) const noexcept; bool operator()(const shared_ptr&, const weak_ptr&) const noexcept; bool operator()(const weak_ptr&, const shared_ptr&) const noexcept; };   template<> struct owner_less { template<class T, class U> bool operator()(const shared_ptr&, const shared_ptr&) const noexcept; template<class T, class U> bool operator()(const shared_ptr&, const weak_ptr&) const noexcept; template<class T, class U> bool operator()(const weak_ptr&, const shared_ptr&) const noexcept; template<class T, class U> bool operator()(const weak_ptr&, const weak_ptr&) const noexcept;   using is_transparent = /* unspecified */; }; }

[edit] Class std::owner_hash

namespace std { struct owner_hash { template size_t operator()(const shared_ptr&) const noexcept;   template size_t operator()(const weak_ptr&) const noexcept;   using is_transparent = /* unspecified */; }; }

[edit] Class std::owner_equal

namespace std { struct owner_equal { template<class T, class U> bool operator()(const shared_ptr&, const shared_ptr&) const noexcept; template<class T, class U> bool operator()(const shared_ptr&, const weak_ptr&) const noexcept; template<class T, class U> bool operator()(const weak_ptr&, const shared_ptr&) const noexcept; template<class T, class U> bool operator()(const weak_ptr&, const weak_ptr&) const noexcept;   using is_transparent = /* unspecified */; }; }

[edit] Class template std::enable_shared_from_this

namespace std { template class enable_shared_from_this { protected: constexpr enable_shared_from_this() noexcept; enable_shared_from_this(const enable_shared_from_this&) noexcept; enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept; ~enable_shared_from_this();   public: shared_ptr shared_from_this(); shared_ptr shared_from_this() const; weak_ptr weak_from_this() noexcept; weak_ptr weak_from_this() const noexcept;   private: mutable weak_ptr /weak-this/; // exposition-only }; }

[edit] Class template std::atomic's specialization for std::shared_ptr

namespace std { template struct atomic<shared_ptr> { using value_type = shared_ptr; static constexpr bool is_always_lock_free = /* implementation-defined */;   bool is_lock_free() const noexcept; void store(shared_ptr desired, memory_order order = memory_order::seq_cst) noexcept; shared_ptr load(memory_order order = memory_order::seq_cst) const noexcept; operator shared_ptr() const noexcept;   shared_ptr exchange(shared_ptr desired, memory_order order = memory_order::seq_cst) noexcept;   bool compare_exchange_weak(shared_ptr& expected, shared_ptr desired, memory_order success, memory_order failure) noexcept; bool compare_exchange_strong(shared_ptr& expected, shared_ptr desired, memory_order success, memory_order failure) noexcept;   bool compare_exchange_weak(shared_ptr& expected, shared_ptr desired, memory_order order = memory_order::seq_cst) noexcept; bool compare_exchange_strong(shared_ptr& expected, shared_ptr desired, memory_order order = memory_order::seq_cst) noexcept;   constexpr atomic() noexcept = default; atomic(shared_ptr desired) noexcept; atomic(const atomic&) = delete; void operator=(const atomic&) = delete; void operator=(shared_ptr desired) noexcept;   private: shared_ptr p; // exposition only }; }

[edit] Class template std::atomic's specialization for std::weak_ptr

namespace std { template struct atomic<weak_ptr> { using value_type = weak_ptr; static constexpr bool is_always_lock_free = /* implementation-defined */;   bool is_lock_free() const noexcept; void store(weak_ptr desired, memory_order order = memory_order::seq_cst) noexcept; weak_ptr load(memory_order order = memory_order::seq_cst) const noexcept; operator weak_ptr() const noexcept;   weak_ptr exchange(weak_ptr desired, memory_order order = memory_order::seq_cst) noexcept;   bool compare_exchange_weak(weak_ptr& expected, weak_ptr desired, memory_order success, memory_order failure) noexcept; bool compare_exchange_strong(weak_ptr& expected, weak_ptr desired, memory_order success, memory_order failure) noexcept;   bool compare_exchange_weak(weak_ptr& expected, weak_ptr desired, memory_order order = memory_order::seq_cst) noexcept; bool compare_exchange_strong(weak_ptr& expected, weak_ptr desired, memory_order order = memory_order::seq_cst) noexcept;   constexpr atomic() noexcept = default; atomic(weak_ptr desired) noexcept; atomic(const atomic&) = delete; void operator=(const atomic&) = delete; void operator=(weak_ptr desired) noexcept;   private: weak_ptr p; // exposition only }; }

[edit] Class template std::out_ptr_t

namespace std { template<class Smart, class Pointer, class... Args> class out_ptr_t { public: explicit out_ptr_t(Smart&, Args...); out_ptr_t(const out_ptr_t&) = delete;   ~out_ptr_t();   operator Pointer*() const noexcept; operator void**() const noexcept;   private: Smart& s; // exposition-only tuple<Args...> a; // exposition-only Pointer p; // exposition-only }; }

[edit] Class template std::inout_ptr_t

namespace std { template<class Smart, class Pointer, class... Args> class inout_ptr_t { public: explicit inout_ptr_t(Smart&, Args...); inout_ptr_t(const inout_ptr_t&) = delete;   ~inout_ptr_t();   operator Pointer*() const noexcept; operator void**() const noexcept;   private: Smart& s; // exposition-only tuple<Args...> a; // exposition-only Pointer p; // exposition-only }; }

[edit] Class template std::indirect

namespace std { template<class T, class Allocator = allocator> class indirect { public: using value_type = T; using allocator_type = Allocator; using pointer = typename allocator_traits::pointer; using const_pointer = typename allocator_traits::const_pointer;   // constructors constexpr explicit indirect(); constexpr explicit indirect(allocator_arg_t, const Allocator& a); constexpr indirect(const indirect& other); constexpr indirect(allocator_arg_t, const Allocator& a, const indirect& other); constexpr indirect(indirect&& other) noexcept; constexpr indirect(allocator_arg_t, const Allocator& a, indirect&& other) noexcept(/* see description /); template constexpr explicit indirect(U&& u); template constexpr explicit indirect(allocator_arg_t, const Allocator& a, U&& u); template<class... Us> constexpr explicit indirect(in_place_t, Us&&... us); template<class... Us> constexpr explicit indirect(allocator_arg_t, const Allocator& a, in_place_t, Us&&... us); template<class I, class... Us> constexpr explicit indirect(in_place_t, initializer_list ilist, Us&&... us); template<class I, class... Us> constexpr explicit indirect(allocator_arg_t, const Allocator& a, in_place_t, initializer_list ilist, Us&&... us);   // destructor constexpr ~indirect();   // assignment constexpr indirect& operator=(const indirect& other); constexpr indirect& operator=(indirect&& other) noexcept(/ see description /); template constexpr indirect& operator=(U&& u);   // observers constexpr const T& operator() const& noexcept; constexpr T& operator*() & noexcept; constexpr const T&& operator*() const&& noexcept; constexpr T&& operator*() && noexcept; constexpr const_pointer operator->() const noexcept; constexpr pointer operator->() noexcept; constexpr bool valueless_after_move() const noexcept; constexpr allocator_type get_allocator() const noexcept;   // swap constexpr void swap(indirect& other) noexcept(/* see description /); friend constexpr void swap(indirect& lhs, indirect& rhs) noexcept(/ see description /);   // relational operators template<class U, class AA> friend constexpr bool operator==( const indirect& lhs, const indirect<U, AA>& rhs) noexcept(/ see description /); template<class U, class AA> friend constexpr auto operator<=>(const indirect& lhs, const indirect<U, AA>& rhs) -> /synth-three-way-result/<T, U>;   // comparison with T template friend constexpr bool operator==(const indirect& lhs, const U& rhs) noexcept(/ see description */); template friend constexpr auto operator<=>(const indirect& lhs, const U& rhs) -> /synth-three-way-result/<T, U>;   private: pointer /p/; // exposition-only Allocator /alloc/ = Allocator(); // exposition-only }; template indirect(Value) -> indirect; template<class Allocator, class Value> indirect(allocator_arg_t, Allocator, Value) -> indirect<Value, typename allocator_traits::template rebind_alloc>; }

[edit] Class template std::polymorphic

namespace std { template<class T, class Allocator = allocator> class polymorphic { public: using value_type = T; using allocator_type = Allocator; using pointer = typename allocator_traits::pointer; using const_pointer = typename allocator_traits::const_pointer;   // constructors constexpr explicit polymorphic(); constexpr explicit polymorphic(allocator_arg_t, const Allocator& a); constexpr polymorphic(const polymorphic& other); constexpr polymorphic(allocator_arg_t, const Allocator& a, const polymorphic& other); constexpr polymorphic(polymorphic&& other) noexcept; constexpr polymorphic(allocator_arg_t, const Allocator& a, polymorphic&& other) noexcept(/* see description /); template constexpr explicit polymorphic(U&& u); template constexpr explicit polymorphic(allocator_arg_t, const Allocator& a, U&& u); template<class U, class... Ts> constexpr explicit polymorphic(in_place_type_t, Ts&&... ts); template<class U, class... Ts> constexpr explicit polymorphic(allocator_arg_t, const Allocator& a, in_place_type_t, Ts&&... ts); template<class U, class I, class... Us> constexpr explicit polymorphic(in_place_type_t, initializer_list ilist, Us&&... us); template<class U, class I, class... Us> constexpr explicit polymorphic(allocator_arg_t, const Allocator& a, in_place_type_t, initializer_list ilist, Us&&... us);   // destructor constexpr ~polymorphic();   // assignment constexpr polymorphic& operator=(const polymorphic& other); constexpr polymorphic& operator=(polymorphic&& other) noexcept(/ see description /);   // observers constexpr const T& operator() const noexcept; constexpr T& operator*() noexcept; constexpr const_pointer operator->() const noexcept; constexpr pointer operator->() noexcept; constexpr bool valueless_after_move() const noexcept; constexpr allocator_type get_allocator() const noexcept;   // swap constexpr void swap(polymorphic& other) noexcept(/* see description /); friend constexpr void swap(polymorphic& lhs, polymorphic& rhs) noexcept(/ see description */);   private: Allocator /alloc/ = Allocator(); // exposition-only }; }