标准库标头 <memory>

此头文件是动态内存管理库的一部分。

std::atomic_is_lock_free(std::shared_ptr)std::atomic_load(std::shared_ptr)std::atomic_load_explicit(std::shared_ptr)std::atomic_store(std::shared_ptr)std::atomic_store_explicit(std::shared_ptr)std::atomic_exchange(std::shared_ptr)std::atomic_exchange_explicit(std::shared_ptr)std::atomic_compare_exchange_weak(std::shared_ptr)std::atomic_compare_exchange_strong(std::shared_ptr)std::atomic_compare_exchange_weak_explicit(std::shared_ptr)std::atomic_compare_exchange_strong_explicit(std::shared_ptr)

(C++20 弃用)(C++26 移除)

为 std::shared_ptr 特化的原子操作
(函数模板)[编辑]

函数式实体
在命名空间 `std::ranges` 定义
未初始化存储
ranges::uninitialized_copy (C++20)	复制范围中对象到未初始化内存 (算法函数对象)[编辑]
ranges::uninitialized_copy_n (C++20)	复制若干对象到未初始化内存 (算法函数对象)[编辑]
ranges::uninitialized_fill (C++20)	复制一个对象到范围所定义的未初始化内存 (算法函数对象)[编辑]
ranges::uninitialized_fill_n (C++20)	复制一个对象到起点和数量所定义的未初始化内存 (算法函数对象)[编辑]
ranges::uninitialized_move (C++20)	移动范围中对象到未初始化内存 (算法函数对象)[编辑]
ranges::uninitialized_move_n (C++20)	移动若干对象到未初始化内存 (算法函数对象)[编辑]
ranges::uninitialized_default_construct (C++20)	在范围所定义的未初始化内存中用默认初始化构造对象 (算法函数对象)[编辑]
ranges::uninitialized_default_construct_n (C++20)	在起点和数量所定义的未初始化内存中用默认初始化构造对象 (算法函数对象)[编辑]
ranges::uninitialized_value_construct (C++20)	在范围所定义的未初始化内存中用值初始化构造对象 (算法函数对象)[编辑]
ranges::uninitialized_value_construct_n (C++20)	在起点和数量所定义的未初始化内存中用值初始化构造对象 (算法函数对象)[编辑]
ranges::construct_at (C++20)	在给定地址创建对象 (算法函数对象)[编辑]
ranges::destroy_at (C++20)	销毁给定地址的对象 (算法函数对象)[编辑]
ranges::destroy (C++20)	销毁范围中的对象 (算法函数对象)[编辑]
ranges::destroy_n (C++20)	销毁范围中若干对象 (算法函数对象)[编辑]

[编辑]概要

#include <compare>   namespace std {// 指针特征template<class Ptr>struct pointer_traits;// 独立template<class T>struct pointer_traits<T*>;// 独立   // 指针转换template<class T>constexpr T* to_address(T* p)noexcept;// 独立template<class Ptr>constexprauto to_address(const Ptr& p)noexcept;// 独立   // 指针对齐void* align(size_t alignment, size_t size, void*& ptr, size_t& space);// 独立template<size_t N, class T>constexpr T* assume_aligned(T* ptr);// 独立template<size_t Alignment, class T>bool is_sufficiently_aligned(T* ptr);   // 显式生存期管理template<class T> T* start_lifetime_as(void* p)noexcept;// 独立template<class T>const T* start_lifetime_as(constvoid* p)noexcept;// 独立template<class T>volatile T* start_lifetime_as(volatilevoid* p)noexcept;// 独立template<class T>constvolatile T* start_lifetime_as(constvolatilevoid* p)noexcept;// 独立template<class T> T* start_lifetime_as_array(void* p, size_t n)noexcept;// 独立template<class T>const T* start_lifetime_as_array(constvoid* p, size_t n)noexcept;// 独立template<class T>volatile T* start_lifetime_as_array(volatilevoid* p, size_t n)noexcept;// 独立template<class T>constvolatile T* start_lifetime_as_array(constvolatilevoid* p, // 独立 size_t n)noexcept;template<class T> T* trivially_relocate(T* first, T* last, T* result);// 独立template<class T>constexpr T* relocate(T* first, T* last, T* result);// 独立   // 分配器实参标签struct allocator_arg_t {explicit allocator_arg_t()=default;};// 独立inlineconstexpr allocator_arg_t allocator_arg{};// 独立   // uses_allocatortemplate<class T, class Alloc>struct uses_allocator;// 独立   // uses_allocatortemplate<class T, class Alloc>constexprbool uses_allocator_v = uses_allocator<T, Alloc>::value;// 独立   // uses-allocator 构造template<class T, class Alloc, class... Args>constexprauto uses_allocator_construction_args(const Alloc& alloc, // 独立 Args&&... args)noexcept;template<class T, class Alloc, class Tuple1, class Tuple2>constexprauto uses_allocator_construction_args(const Alloc& alloc, // 独立 piecewise_construct_t, Tuple1&& x, Tuple2&& y)noexcept;template<class T, class Alloc>constexprauto uses_allocator_construction_args(const Alloc& alloc)noexcept;// 独立template<class T, class Alloc, class U, class V>constexprauto uses_allocator_construction_args(const Alloc& alloc, // 独立 U&& u, V&& v)noexcept;template<class T, class Alloc, class U, class V>constexprauto uses_allocator_construction_args(const Alloc& alloc, // 独立 pair<U, V>& pr)noexcept;template<class T, class Alloc, class U, class V>constexprauto uses_allocator_construction_args(const Alloc& alloc, // 独立const pair<U, V>& pr)noexcept;template<class T, class Alloc, class U, class V>constexprauto uses_allocator_construction_args(const Alloc& alloc, // 独立 pair<U, V>&& pr)noexcept;template<class T, class Alloc, class U, class V>constexprauto uses_allocator_construction_args(const Alloc& alloc, // 独立const pair<U, V>&& pr)noexcept;template<class T, class Alloc, /*pair-like*/ P>constexprauto uses_allocator_construction_args(const Alloc& alloc, // 独立 P&& p)noexcept;template<class T, class Alloc, class U>constexprauto uses_allocator_construction_args(const Alloc& alloc, // 独立 U&& u)noexcept;template<class T, class Alloc, class... Args>constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args);// 独立template<class T, class Alloc, class... Args>constexpr T* uninitialized_construct_using_allocator(T* p, // 独立const Alloc& alloc, Args&&... args);   // 分配器特征template<class Alloc>struct allocator_traits;// 独立   template<class Pointer, class SizeType = size_t>struct allocation_result {// 独立 Pointer ptr; SizeType count;};   // 默认分配器template<class T>class allocator;template<class T, class U>constexprbool operator==(const allocator<T>&, const allocator<U>&)noexcept;   // addressoftemplate<class T>constexpr T* addressof(T& r)noexcept;// 独立template<class T>const T* addressof(const T&&)= delete;// 独立   // 专用算法// 特殊内存概念template<class I> concept no-throw-input-iterator=/* 见描述 */;// 仅用于阐述template<class I> concept no-throw-forward-iterator=/* 见描述 */;// 仅用于阐述template<class S, class I> concept no-throw-sentinel-for=/* 见描述 */;// 仅用于阐述template<class R> concept no-throw-input-range=/* 见描述 */;// 仅用于阐述template<class R> concept no-throw-forward-range=/* 见描述 */;// 仅用于阐述   template<class NoThrowForwardIter>constexprvoid uninitialized_default_construct(NoThrowForwardIter first, // 独立 NoThrowForwardIter last);template<class ExecutionPolicy, class NoThrowForwardIter>void uninitialized_default_construct(ExecutionPolicy&& exec, // 独立或弃置 NoThrowForwardIter first, NoThrowForwardIter last);template<class NoThrowForwardIter, class Size>constexpr NoThrowForwardIter uninitialized_default_construct_n(NoThrowForwardIter first, Size n);// 独立template<class ExecutionPolicy, class NoThrowForwardIter, class Size> NoThrowForwardIter uninitialized_default_construct_n( ExecutionPolicy&& exec, // 独立或弃置 NoThrowForwardIter first, Size n);   namespace ranges {template<no-throw-forward-iterator I, no-throw-sentinel-for<I> S> requires default_initializable<iter_value_t<I>>constexpr I uninitialized_default_construct(I first, S last);// 独立template<no-throw-forward-range R> requires default_initializable<range_value_t<R>>constexpr borrowed_iterator_t<R> uninitialized_default_construct( R&& r);// 独立   template<no-throw-forward-iterator I> requires default_initializable<iter_value_t<I>>constexpr I uninitialized_default_construct_n(I first, // 独立 iter_difference_t<I> n);}   template<class NoThrowForwardIter>constexprvoid uninitialized_value_construct(NoThrowForwardIter first, // 独立 NoThrowForwardIter last);template<class ExecutionPolicy, class NoThrowForwardIter>void uninitialized_value_construct(ExecutionPolicy&& exec, // 独立或弃置 NoThrowForwardIter first, NoThrowForwardIter last);template<class NoThrowForwardIter, class Size>constexpr NoThrowForwardIter uninitialized_value_construct_n(NoThrowForwardIter first, Size n);// 独立template<class ExecutionPolicy, class NoThrowForwardIter, class Size> NoThrowForwardIter uninitialized_value_construct_n( ExecutionPolicy&& exec, // 独立或弃置 NoThrowForwardIter first, Size n);   namespace ranges {template<no-throw-forward-iterator I, no-throw-sentinel-for<I> S> requires default_initializable<iter_value_t<I>>constexpr I uninitialized_value_construct(I first, S last);// 独立template<no-throw-forward-range R> requires default_initializable<range_value_t<R>>constexpr borrowed_iterator_t<R> uninitialized_value_construct(R&& r);// 独立   template<no-throw-forward-iterator I> requires default_initializable<iter_value_t<I>>constexpr I uninitialized_value_construct_n(I first, // 独立 iter_difference_t<I> n);}   template<class InputIter, class NoThrowForwardIter>constexpr NoThrowForwardIter uninitialized_copy(InputIter first, // 独立 InputIter last, NoThrowForwardIter result);template<class ExecutionPolicy, class ForwardIter, class NoThrowForwardIter> NoThrowForwardIter uninitialized_copy(ExecutionPolicy&& exec, // 独立或弃置 ForwardIter first, ForwardIter last, NoThrowForwardIter result);template<class InputIter, class Size, class NoThrowForwardIter>constexpr NoThrowForwardIter uninitialized_copy_n(InputIter first, // 独立 Size n, NoThrowForwardIter result);template<class ExecutionPolicy, class ForwardIter, class Size, class NoThrowForwardIter> NoThrowForwardIter uninitialized_copy_n(ExecutionPolicy&& exec, // 独立或弃置 ForwardIter first, Size n, NoThrowForwardIter result);   namespace ranges {template<class I, class O>using uninitialized_copy_result = in_out_result<I, O>;// 独立template<input_iterator I, sentinel_for<I> S1, no-throw-forward-iterator O, no-throw-sentinel-for<O> S2> requires constructible_from<iter_value_t<O>, iter_reference_t<I>>constexpr uninitialized_copy_result<I, O> uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast);// 独立template<input_range IR, no-throw-forward-range OR> requires constructible_from<range_value_t<OR>, range_reference_t<IR>>constexpr uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>> uninitialized_copy(IR&& in_range, OR&& out_range);// 独立   template<class I, class O>using uninitialized_copy_n_result = in_out_result<I, O>;// 独立template<input_iterator I, no-throw-forward-iterator O, no-throw-sentinel-for<O> S> requires constructible_from<iter_value_t<O>, iter_reference_t<I>>constexpr uninitialized_copy_n_result<I, O> uninitialized_copy_n( I ifirst, iter_difference_t<I> n, // 独立 O ofirst, S olast);}   template<class InputIter, class NoThrowForwardIter>constexpr NoThrowForwardIter uninitialized_move(InputIter first, // 独立 InputIter last, NoThrowForwardIter result);template<class ExecutionPolicy, class ForwardIter, class NoThrowForwardIter> NoThrowForwardIter uninitialized_move(ExecutionPolicy&& exec, // 独立或弃置 ForwardIter first, ForwardIter last, NoThrowForwardIter result);template<class InputIter, class Size, class NoThrowForwardIter>constexpr pair<InputIter, NoThrowForwardIter> uninitialized_move_n( InputIter first, Size n, // 独立 NoThrowForwardIter result);template<class ExecutionPolicy, class ForwardIter, class Size, class NoThrowForwardIter> pair<ForwardIter, NoThrowForwardIter> uninitialized_move_n( ExecutionPolicy&& exec, // 独立或弃置 ForwardIter first, Size n, NoThrowForwardIter result);   namespace ranges {template<class I, class O>using uninitialized_move_result = in_out_result<I, O>;// 独立template<input_iterator I, sentinel_for<I> S1, no-throw-forward-iterator O, no-throw-sentinel-for<O> S2> requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>constexpr uninitialized_move_result<I, O> uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast);// 独立template<input_range IR, no-throw-forward-range OR> requires constructible_from<range_value_t<OR>, range_rvalue_reference_t<IR>>constexpr uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>> uninitialized_move(IR&& in_range, OR&& out_range);// 独立   template<class I, class O>using uninitialized_move_n_result = in_out_result<I, O>;// 独立template<input_iterator I, no-throw-forward-iterator O, no-throw-sentinel-for<O> S> requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>constexpr uninitialized_move_n_result<I, O> uninitialized_move_n( I ifirst, iter_difference_t<I> n, // 独立 O ofirst, S olast);}   template<class NoThrowForwardIter, class T>constexprvoid uninitialized_fill(NoThrowForwardIter first, // 独立 NoThrowForwardIter last, const T& x);template<class ExecutionPolicy, class NoThrowForwardIter, class T>void uninitialized_fill(ExecutionPolicy&& exec, // 独立或弃置 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);// 独立template<class ExecutionPolicy, class NoThrowForwardIter, class Size, class T> NoThrowForwardIter uninitialized_fill_n(ExecutionPolicy&& exec, // 独立或弃置 NoThrowForwardIter first, Size n, const T& x);   namespace ranges {template<no-throw-forward-iterator I, no-throw-sentinel-for<I> S, class T> requires constructible_from<iter_value_t<I>, const T&>constexpr I uninitialized_fill(I first, S last, const T& x);// 独立template<no-throw-forward-range R, class T> requires constructible_from<range_value_t<R>, const T&>constexpr borrowed_iterator_t<R> uninitialized_fill(R&& r, const T& x);// 独立   template<no-throw-forward-iterator I, class T> requires constructible_from<iter_value_t<I>, const T&>constexpr I uninitialized_fill_n(I first, // 独立 iter_difference_t<I> n, const T& x);}   // construct_attemplate<class T, class... Args>constexpr T* construct_at(T* location, Args&&... args);// 独立   namespace ranges {template<class T, class... Args>constexpr T* construct_at(T* location, Args&&... args);// 独立}   // destroytemplate<class T>constexprvoid destroy_at(T* location);// 独立template<class NoThrowForwardIter>constexprvoid destroy(NoThrowForwardIter first, // 独立 NoThrowForwardIter last);template<class ExecutionPolicy, class NoThrowForwardIter>void destroy(ExecutionPolicy&& exec, // 独立或弃置 NoThrowForwardIter first, NoThrowForwardIter last);template<class NoThrowForwardIter, class Size>constexpr NoThrowForwardIter destroy_n(NoThrowForwardIter first, // 独立 Size n);template<class ExecutionPolicy, class NoThrowForwardIter, class Size> NoThrowForwardIter destroy_n(ExecutionPolicy&& exec, // 独立或弃置 NoThrowForwardIter first, Size n);   namespace ranges {template<destructible T>constexprvoid destroy_at(T* location)noexcept;// 独立   template<no-throw-input-iterator I, no-throw-sentinel-for<I> S> requires destructible<iter_value_t<I>>constexpr I destroy(I first, S last)noexcept;// 独立template<no-throw-input-range R> requires destructible<range_value_t<R>>constexpr borrowed_iterator_t<R> destroy(R&& r)noexcept;// 独立   template<no-throw-input-iterator I> requires destructible<iter_value_t<I>>constexpr I destroy_n(I first, iter_difference_t<I> n)noexcept;// 独立}   // 类模板 unique_ptrtemplate<class T>struct default_delete;// 独立template<class T>struct default_delete<T[]>;// 独立template<class T, class D = default_delete<T>>class unique_ptr;// 独立template<class T, class D>class unique_ptr<T[], D>;// 独立   template<class T, class... Args>constexpr unique_ptr<T> make_unique(Args&&... args);// T 非数组template<class T>constexpr unique_ptr<T> make_unique(size_t n);// T 是 U[]template<class T, class... Args>/* 未指定 */ make_unique(Args&&...)= delete;// T 是 U[N]   template<class T>constexpr unique_ptr<T> make_unique_for_overwrite();// T 非数组template<class T>constexpr unique_ptr<T> make_unique_for_overwrite(size_t n);// T 是 U[]template<class T, class... Args>/* 未指定 */ make_unique_for_overwrite(Args&&...)= delete;// T 是 U[N]   template<class T, class D>constexprvoid swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y)noexcept;// 独立   template<class T1, class D1, class T2, class D2>constexprbool operator==(const unique_ptr<T1, D1>& x, // 独立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);// 独立template<class T1, class D1, class T2, class D2>bool operator>(const unique_ptr<T1, D1>& x, 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);// 独立template<class T1, class D1, class T2, class D2>bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);// 独立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);// 独立   template<class T, class D>constexprbool operator==(const unique_ptr<T, D>& x, nullptr_t)noexcept;// 独立template<class T, class D>constexprbool operator<(const unique_ptr<T, D>& x, nullptr_t);// 独立template<class T, class D>constexprbool operator<(nullptr_t, const unique_ptr<T, D>& y);// 独立template<class T, class D>constexprbool operator>(const unique_ptr<T, D>& x, nullptr_t);// 独立template<class T, class D>constexprbool operator>(nullptr_t, const unique_ptr<T, D>& y);// 独立template<class T, class D>constexprbool operator<=(const unique_ptr<T, D>& x, nullptr_t);// 独立template<class T, class D>constexprbool operator<=(nullptr_t, const unique_ptr<T, D>& y);// 独立template<class T, class D>constexprbool operator>=(const unique_ptr<T, D>& x, nullptr_t);// 独立template<class T, class D>constexprbool operator>=(nullptr_t, const unique_ptr<T, D>& y);// 独立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);// 独立   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);   // 类 bad_weak_ptrclass bad_weak_ptr;   // 类模板 shared_ptrtemplate<class T>class shared_ptr;   // shared_ptr 创建template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args);// T 非数组template<class T, class A, class... Args> shared_ptr<T> allocate_shared(const A& a, Args&&... args);// T 非数组   template<class T> shared_ptr<T> make_shared(size_t N);// T 是 U[]template<class T, class A> shared_ptr<T> allocate_shared(const A& a, size_t N);// T 是 U[]   template<class T> shared_ptr<T> make_shared();// T 是 U[N]template<class T, class A> shared_ptr<T> allocate_shared(const A& a);// T 是 U[N]   template<class T> shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u);// T 是 U[]template<class T, class A> shared_ptr<T> allocate_shared(const A& a, size_t N, const remove_extent_t<T>& u);// T 是 U[]   template<class T> shared_ptr<T> make_shared(const remove_extent_t<T>& u);// T 是 U[N]template<class T, class A> shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u);// T 是 U[N]   template<class T> shared_ptr<T> make_shared_for_overwrite();// T 不是 U[]template<class T, class A> shared_ptr<T> allocate_shared_for_overwrite(const A& a);// T 不是 U[]   template<class T> shared_ptr<T> make_shared_for_overwrite(size_t N);// T 是 U[]template<class T, class A> shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N);// T 是 U[]   // shared_ptr 比较template<class T, class U>bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b)noexcept;template<class T, class U> strong_ordering operator<=>(const shared_ptr<T>& a, const shared_ptr<U>& b)noexcept;   template<class T>bool operator==(const shared_ptr<T>& x, nullptr_t)noexcept;template<class T> strong_ordering operator<=>(const shared_ptr<T>& x, nullptr_t)noexcept;   // shared_ptr 特化算法template<class T>void swap(shared_ptr<T>& a, shared_ptr<T>& b)noexcept;   // shared_ptr 转型template<class T, class U> shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r)noexcept;template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r)noexcept;template<class T, class U> shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r)noexcept;template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U>&& r)noexcept;template<class T, class U> shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r)noexcept;template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U>&& r)noexcept;template<class T, class U> shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r)noexcept;template<class T, class U> shared_ptr<T> reinterpret_pointer_cast(shared_ptr<U>&& r)noexcept;   // shared_ptr get_deletertemplate<class D, class T> D* get_deleter(const shared_ptr<T>& p)noexcept;   // shared_ptr I/Otemplate<class E, class T, class Y> basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);   // 类模板 weak_ptrtemplate<class T>class weak_ptr;   // weak_ptr 特化算法template<class T>void swap(weak_ptr<T>& a, weak_ptr<T>& b)noexcept;   // 类模板 owner_lesstemplate<class T =void>struct owner_less;   // 结构体 owner_hashstruct owner_hash;   // 结构体 owner_equalstruct owner_equal;   // 类模板 enable_shared_from_thistemplate<class T>class enable_shared_from_this;   // 散列支持template<class T>struct hash;// 独立template<class T, class D>struct hash<unique_ptr<T, D>>;// 独立template<class T>struct hash<shared_ptr<T>>;   // 原子智能指针template<class T>struct atomic;// 独立template<class T>struct atomic<shared_ptr<T>>;template<class T>struct atomic<weak_ptr<T>>;   // 类模板 out_ptr_ttemplate<class Smart, class Pointer, class... Args>class out_ptr_t;// 独立   // 函数模板 out_ptrtemplate<class Pointer =void, class Smart, class... Args>auto out_ptr(Smart& s, Args&&... args);// 独立   // 类模板 inout_ptr_ttemplate<class Smart, class Pointer, class... Args>class inout_ptr_t;// 独立   // 函数模板 inout_ptrtemplate<class Pointer =void, class Smart, class... Args>auto inout_ptr(Smart& s, Args&&... args);// 独立   // 类模板 indirecttemplate<class T, class Allocator = allocator<T>>class indirect;   // 散列支持template<class T, class Alloc>struct hash<indirect<T, Alloc>>;   // 类模板 polymorphictemplate<class T, class Allocator = allocator<T>>class polymorphic;   namespace pmr {template<class T>using indirect = indirect<T, polymorphic_allocator<T>>;template<class T>using polymorphic = polymorphic<T, polymorphic_allocator<T>>;}}

[编辑]辅助概念

注意：这些名字仅用于阐述，它们并不是接口的一部分。

template<class I> concept no-throw-input-iterator=// 仅用于阐述 input_iterator<I>&& is_lvalue_reference_v<iter_reference_t<I>>&& same_as<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;   template<class S, class I> concept no-throw-sentinel-for= sentinel_for<S, I>;// 仅用于阐述   template<class R> concept no-throw-input-range=// 仅用于阐述ranges::range<R>&&no-throw-input-iterator<ranges::iterator_t<R>>&& no-throw-sentinel-for<ranges::sentinel_t<R>, ranges::iterator_t<R>>;   template<class I> concept no-throw-forward-iterator=// 仅用于阐述no-throw-input-iterator<I>&& forward_iterator<I>&& no-throw-sentinel-for<I, I>;   template<class R> concept no-throw-forward-range=// 仅用于阐述no-throw-input-range<R>&&no-throw-forward-iterator<ranges::iterator_t<R>>;

[编辑]类模板 std::pointer_traits

namespace std {template<class Ptr>struct pointer_traits {/* 见描述 */;};   template<class T>struct pointer_traits<T*>{using pointer = T*;using element_type = T;using difference_type = ptrdiff_t;   template<class U>using rebind = U*;   staticconstexpr pointer pointer_to(/* 见描述 */ r)noexcept;};}

[编辑]类 std::allocator_arg_t

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

[编辑]类模板 std::allocator_traits

namespace std {template<class Alloc>struct allocator_traits {using allocator_type = Alloc;   using value_type =typename Alloc::value_type;   using pointer =/* 见描述 */;using const_pointer =/* 见描述 */;using void_pointer =/* 见描述 */;using const_void_pointer =/* 见描述 */;   using difference_type =/* 见描述 */;using size_type =/* 见描述 */;   using propagate_on_container_copy_赋值 =/* 见描述 */;using propagate_on_container_move_赋值 =/* 见描述 */;using propagate_on_container_swap =/* 见描述 */;using is_always_equal =/* 见描述 */;   template<class T>using rebind_alloc =/* 见描述 */;template<class T>using rebind_traits = allocator_traits<rebind_alloc<T>>;   staticconstexpr pointer allocate(Alloc& a, size_type n);staticconstexpr pointer allocate(Alloc& a, size_type n, const_void_pointer hint);staticconstexpr allocation_result<pointer, size_type> allocate_at_least(Alloc& a, size_type n);   staticconstexprvoid deallocate(Alloc& a, pointer p, size_type n);   template<class T, class... Args>staticconstexprvoid construct(Alloc& a, T* p, Args&&... args);   template<class T>staticconstexprvoid destroy(Alloc& a, T* p);   staticconstexpr size_type max_size(const Alloc& a)noexcept;   staticconstexpr Alloc select_on_container_copy_construction(const Alloc& rhs);};}

[编辑]类模板 std::allocator

namespace std {template<class T>class allocator {public:using value_type = T;using size_type = size_t;using difference_type = ptrdiff_t;using propagate_on_container_move_赋值 = true_type;   constexpr allocator()noexcept;constexpr allocator(const allocator&)noexcept;template<class U>constexpr allocator(const allocator<U>&)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);constexprvoid deallocate(T* p, size_t n);};}

[编辑]类模板 std::default_delete

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

[编辑]类模板 std::unique_ptr

namespace std {template<class T, class D = default_delete<T>>class unique_ptr {public:using pointer =/* 见描述 */;using element_type = T;using deleter_type = D;   // 构造函数constexpr unique_ptr()noexcept;constexprexplicit unique_ptr(type_identity_t<pointer> p)noexcept;constexpr unique_ptr(type_identity_t<pointer> p, /* 见描述 */ d1)noexcept;constexpr unique_ptr(type_identity_t<pointer> p, /* 见描述 */ 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;   // 析构函数constexpr ~unique_ptr();   // 赋值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;   // 观察器constexpr add_lvalue_reference_t<T> operator*()constnoexcept(/* 见描述 */);constexpr pointer operator->()constnoexcept;constexpr pointer get()constnoexcept;constexpr deleter_type& get_deleter()noexcept;constexprconst deleter_type& get_deleter()constnoexcept;constexprexplicit operator bool()constnoexcept;   // 修改器constexpr pointer release()noexcept;constexprvoid reset(pointer p = pointer())noexcept;constexprvoid swap(unique_ptr& u)noexcept;   // 禁用从左值复制 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 =/* 见描述 */;using element_type = T;using deleter_type = D;   // 构造函数constexpr unique_ptr()noexcept;template<class U>constexprexplicit unique_ptr(U p)noexcept;template<class U>constexpr unique_ptr(U p, /* 见描述 */ d)noexcept;template<class U>constexpr unique_ptr(U p, /* 见描述 */ 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;   // 析构函数constexpr ~unique_ptr();   // 赋值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;   // 观察器constexpr T& operator[](size_t i)const;constexpr pointer get()constnoexcept;constexpr deleter_type& get_deleter()noexcept;constexprconst deleter_type& get_deleter()constnoexcept;constexprexplicit operator bool()constnoexcept;   // 修改器constexpr pointer release()noexcept;template<class U>constexprvoid reset(U p)noexcept;constexprvoid reset(nullptr_t = nullptr)noexcept;constexprvoid swap(unique_ptr& u)noexcept;   // 禁用从左值复制 unique_ptr(const unique_ptr&)= delete; unique_ptr& operator=(const unique_ptr&)= delete;};}

[编辑]类 std::bad_weak_ptr

namespace std {class bad_weak_ptr :public exception {public:// 用于特殊成员函数的说明constchar* what()constnoexcept override;};}

[编辑]类模板 std::shared_ptr

namespace std {template<class T>class shared_ptr {public:using element_type = remove_extent_t<T>;using weak_type = weak_ptr<T>;   // 构造函数constexpr shared_ptr()noexcept;constexpr shared_ptr(nullptr_t)noexcept: shared_ptr(){}template<class Y>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<class D> shared_ptr(nullptr_t p, D d);template<class D, class A> shared_ptr(nullptr_t p, D d, A a);template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p)noexcept;template<class Y> shared_ptr(shared_ptr<Y>&& r, element_type* p)noexcept; shared_ptr(const shared_ptr& r)noexcept;template<class Y> shared_ptr(const shared_ptr<Y>& r)noexcept; shared_ptr(shared_ptr&& r)noexcept;template<class Y> shared_ptr(shared_ptr<Y>&& r)noexcept;template<class Y>explicit shared_ptr(const weak_ptr<Y>& r);template<class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);   // 析构函数 ~shared_ptr();   // 赋值 shared_ptr& operator=(const shared_ptr& r)noexcept;template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r)noexcept; shared_ptr& operator=(shared_ptr&& r)noexcept;template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r)noexcept;template<class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);   // 修改器void swap(shared_ptr& r)noexcept;void reset()noexcept;template<class Y>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);   // 观察器 element_type* get()constnoexcept; T& operator*()constnoexcept; T* operator->()constnoexcept; element_type& operator[](ptrdiff_t i)const;long use_count()constnoexcept;explicit operator bool()constnoexcept;template<class U>bool owner_before(const shared_ptr<U>& b)constnoexcept;template<class U>bool owner_before(const weak_ptr<U>& b)constnoexcept; size_t owner_hash()constnoexcept;template<class U>bool owner_equal(const shared_ptr<U>& b)constnoexcept;template<class U>bool owner_equal(const weak_ptr<U>& b)constnoexcept;};   template<class T> shared_ptr(weak_ptr<T>)-> shared_ptr<T>;template<class T, class D> shared_ptr(unique_ptr<T, D>)-> shared_ptr<T>;}

[编辑]类模板 std::weak_ptr

namespace std {template<class T>class weak_ptr {public:using element_type = remove_extent_t<T>;   // 构造函数constexpr weak_ptr()noexcept;template<class Y> weak_ptr(const shared_ptr<Y>& r)noexcept; weak_ptr(const weak_ptr& r)noexcept;template<class Y> weak_ptr(const weak_ptr<Y>& r)noexcept; weak_ptr(weak_ptr&& r)noexcept;template<class Y> weak_ptr(weak_ptr<Y>&& r)noexcept;   // 析构函数 ~weak_ptr();   // 赋值 weak_ptr& operator=(const weak_ptr& r)noexcept;template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r)noexcept;template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r)noexcept; weak_ptr& operator=(weak_ptr&& r)noexcept;template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r)noexcept;   // 修改器void swap(weak_ptr& r)noexcept;void reset()noexcept;   // 观察器long use_count()constnoexcept;bool expired()constnoexcept; shared_ptr<T> lock()constnoexcept;template<class U>bool owner_before(const shared_ptr<U>& b)constnoexcept;template<class U>bool owner_before(const weak_ptr<U>& b)constnoexcept; size_t owner_hash()constnoexcept;template<class U>bool owner_equal(const shared_ptr<U>& b)constnoexcept;template<class U>bool owner_equal(const weak_ptr<U>& b)constnoexcept;};   template<class T> weak_ptr(shared_ptr<T>)-> weak_ptr<T>;}

[编辑]类模板 std::owner_less

namespace std {template<class T =void>struct owner_less;   template<class T>struct owner_less<shared_ptr<T>>{bool operator()(const shared_ptr<T>&, const shared_ptr<T>&)constnoexcept;bool operator()(const shared_ptr<T>&, const weak_ptr<T>&)constnoexcept;bool operator()(const weak_ptr<T>&, const shared_ptr<T>&)constnoexcept;};   template<class T>struct owner_less<weak_ptr<T>>{bool operator()(const weak_ptr<T>&, const weak_ptr<T>&)constnoexcept;bool operator()(const shared_ptr<T>&, const weak_ptr<T>&)constnoexcept;bool operator()(const weak_ptr<T>&, const shared_ptr<T>&)constnoexcept;};   template<>struct owner_less<void>{template<class T, class U>bool operator()(const shared_ptr<T>&, const shared_ptr<U>&)constnoexcept;template<class T, class U>bool operator()(const shared_ptr<T>&, const weak_ptr<U>&)constnoexcept;template<class T, class U>bool operator()(const weak_ptr<T>&, const shared_ptr<U>&)constnoexcept;template<class T, class U>bool operator()(const weak_ptr<T>&, const weak_ptr<U>&)constnoexcept;   using is_transparent =/* 未指定 */;};}

[编辑]类 std::owner_hash

namespace std {struct owner_hash {template<class T> size_t operator()(const shared_ptr<T>&)constnoexcept;   template<class T> size_t operator()(const weak_ptr<T>&)constnoexcept;   using is_transparent =/* 未指定 */;};}

[编辑]类 std::owner_equal

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

[编辑]类模板 std::enable_shared_from_this

namespace std {template<class T>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<T> shared_from_this(); shared_ptr<T const> shared_from_this()const; weak_ptr<T> weak_from_this()noexcept; weak_ptr<T const> weak_from_this()constnoexcept;   private: mutable weak_ptr<T>/*weak-this*/;// 仅用于阐述};}

[编辑]类模板 std::atomic's specialization for std::shared_ptr

namespace std {template<class T>struct atomic<shared_ptr<T>>{using value_type = shared_ptr<T>;staticconstexprbool is_always_lock_free =/* 由实现定义 */;   bool is_lock_free()constnoexcept;void store(shared_ptr<T> desired, memory_order order = memory_order::seq_cst)noexcept; shared_ptr<T> load(memory_order order = memory_order::seq_cst)constnoexcept; operator shared_ptr<T>()constnoexcept;   shared_ptr<T> exchange(shared_ptr<T> desired, memory_order order = memory_order::seq_cst)noexcept;   bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired, memory_order success, memory_order failure)noexcept;bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired, memory_order success, memory_order failure)noexcept;   bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired, memory_order order = memory_order::seq_cst)noexcept;bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired, memory_order order = memory_order::seq_cst)noexcept;   constexpr atomic()noexcept=default; atomic(shared_ptr<T> desired)noexcept; atomic(const atomic&)= delete;void operator=(const atomic&)= delete;void operator=(shared_ptr<T> desired)noexcept;   private: shared_ptr<T> p;// 仅用于阐述};}

[编辑]类模板 std::atomic's specialization for std::weak_ptr

namespace std {template<class T>struct atomic<weak_ptr<T>>{using value_type = weak_ptr<T>;staticconstexprbool is_always_lock_free =/* 由实现定义 */;   bool is_lock_free()constnoexcept;void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst)noexcept; weak_ptr<T> load(memory_order order = memory_order::seq_cst)constnoexcept; operator weak_ptr<T>()constnoexcept;   weak_ptr<T> exchange(weak_ptr<T> desired, memory_order order = memory_order::seq_cst)noexcept;   bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired, memory_order success, memory_order failure)noexcept;bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired, memory_order success, memory_order failure)noexcept;   bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired, memory_order order = memory_order::seq_cst)noexcept;bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired, memory_order order = memory_order::seq_cst)noexcept;   constexpr atomic()noexcept=default; atomic(weak_ptr<T> desired)noexcept; atomic(const atomic&)= delete;void operator=(const atomic&)= delete;void operator=(weak_ptr<T> desired)noexcept;   private: weak_ptr<T> p;// 仅用于阐述};}

[编辑]类模板 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*()constnoexcept; operator void**()constnoexcept;   private: Smart& s;// 仅用于阐述 tuple<Args...> a;// 仅用于阐述 Pointer p;// 仅用于阐述};}

[编辑]类模板 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*()constnoexcept; operator void**()constnoexcept;   private: Smart& s;// 仅用于阐述 tuple<Args...> a;// 仅用于阐述 Pointer p;// 仅用于阐述};}

[编辑]类模板 std::indirect

namespace std {template<class T, class Allocator = allocator<T>>class indirect {public:using value_type = T;using allocator_type = Allocator;using pointer =typename allocator_traits<Allocator>::pointer;using const_pointer =typename allocator_traits<Allocator>::const_pointer;   // 构造函数constexprexplicit indirect();constexprexplicit 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(/* 见描述 */);template<class U = T>constexprexplicit indirect(U&& u);template<class U = T>constexprexplicit indirect(allocator_arg_t, const Allocator& a, U&& u);template<class... Us>constexprexplicit indirect(in_place_t, Us&&... us);template<class... Us>constexprexplicit indirect(allocator_arg_t, const Allocator& a, in_place_t, Us&&... us);template<class I, class... Us>constexprexplicit indirect(in_place_t, initializer_list<I> ilist, Us&&... us);template<class I, class... Us>constexprexplicit indirect(allocator_arg_t, const Allocator& a, in_place_t, initializer_list<I> ilist, Us&&... us);   // 析构函数constexpr ~indirect();   // 赋值constexpr indirect& operator=(const indirect& other);constexpr indirect& operator=(indirect&& other)noexcept(/* 见描述 */);template<class U = T>constexpr indirect& operator=(U&& u);   // 观察器constexprconst T& operator*()const&noexcept;constexpr T& operator*()&noexcept;constexprconst T&& operator*()const&&noexcept;constexpr T&& operator*()&&noexcept;constexpr const_pointer operator->()constnoexcept;constexpr pointer operator->()noexcept;constexprbool valueless_after_move()constnoexcept;constexpr allocator_type get_allocator()constnoexcept;   // swapconstexprvoid swap(indirect& other)noexcept(/* 见描述 */);friendconstexprvoid swap(indirect& lhs, indirect& rhs)noexcept(/* 见描述 */);   // 关系运算符template<class U, class AA>friendconstexprbool operator==(const indirect& lhs, const indirect<U, AA>& rhs)noexcept(/* 见描述 */);template<class U, class AA>friendconstexprauto operator<=>(const indirect& lhs, const indirect<U, AA>& rhs)->/*synth-three-way-result*/<T, U>;   // 与 T 比较template<class U>friendconstexprbool operator==(const indirect& lhs, const U& rhs)noexcept(/* 见描述 */);template<class U>friendconstexprauto operator<=>(const indirect& lhs, const U& rhs)->/*synth-three-way-result*/<T, U>;   private: pointer /*p*/;// 仅用于阐述 Allocator /*alloc*/= Allocator();// 仅用于阐述};template<class Value> indirect(Value)-> indirect<Value>;template<class Allocator, class Value> indirect(allocator_arg_t, Allocator, Value)-> indirect<Value, typename allocator_traits<Allocator>::template rebind_alloc<Value>>;}

[编辑]类模板 std::polymorphic

namespace std {template<class T, class Allocator = allocator<T>>class polymorphic {public:using value_type = T;using allocator_type = Allocator;using pointer =typename allocator_traits<Allocator>::pointer;using const_pointer =typename allocator_traits<Allocator>::const_pointer;   // 构造函数constexprexplicit polymorphic();constexprexplicit 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(/* 见描述 */);template<class U = T>constexprexplicit polymorphic(U&& u);template<class U = T>constexprexplicit polymorphic(allocator_arg_t, const Allocator& a, U&& u);template<class U, class... Ts>constexprexplicit polymorphic(in_place_type_t<U>, Ts&&... ts);template<class U, class... Ts>constexprexplicit polymorphic(allocator_arg_t, const Allocator& a, in_place_type_t<U>, Ts&&... ts);template<class U, class I, class... Us>constexprexplicit polymorphic(in_place_type_t<U>, initializer_list<I> ilist, Us&&... us);template<class U, class I, class... Us>constexprexplicit polymorphic(allocator_arg_t, const Allocator& a, in_place_type_t<U>, initializer_list<I> ilist, Us&&... us);   // 析构函数constexpr ~polymorphic();   // 赋值constexpr polymorphic& operator=(const polymorphic& other);constexpr polymorphic& operator=(polymorphic&& other)noexcept(/* 见描述 */);   // 观察器constexprconst T& operator*()constnoexcept;constexpr T& operator*()noexcept;constexpr const_pointer operator->()constnoexcept;constexpr pointer operator->()noexcept;constexprbool valueless_after_move()constnoexcept;constexpr allocator_type get_allocator()constnoexcept;   // swapconstexprvoid swap(polymorphic& other)noexcept(/* 见描述 */);friendconstexprvoid swap(polymorphic& lhs, polymorphic& rhs)noexcept(/* 见描述 */);   private: Allocator /*alloc*/= Allocator();// 仅用于阐述};}

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏(C++20)
语言支持库
概念库(C++20)
诊断库
内存管理库
元编程库(C++11)
通用工具库
容器库
迭代器库
范围库(C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库(C++17)
并发支持库(C++11)
执行控制库(C++26)
技术规范
符号索引
外部库

cppreference.com

名字空间

变换

查看

操作

标准库标头 <memory>

目录

包含

类

指针特征

垃圾收集器支持

分配器

未初始化存储

智能指针

智能指针适配器

用于组合类设计的类型

辅助类

前置声明

标签

函数

使用分配器的构造

杂项

显式生存期管理

垃圾收集器支持

未初始化存储

智能指针非成员操作

智能指针适配器创建

函数式实体

未初始化存储

[编辑]概要

[编辑]辅助概念

[编辑]类模板 std::pointer_traits

[编辑]类 std::allocator_arg_t

[编辑]类模板 std::allocator_traits

[编辑]类模板 std::allocator

[编辑]类模板 std::default_delete

[编辑]类模板 std::unique_ptr

[编辑]类 std::bad_weak_ptr

[编辑]类模板 std::shared_ptr

[编辑]类模板 std::weak_ptr

[编辑]类模板 std::owner_less

[编辑]类 std::owner_hash

[编辑]类 std::owner_equal

[编辑]类模板 std::enable_shared_from_this

[编辑]类模板 std::atomic's specialization for std::shared_ptr

[编辑]类模板 std::atomic's specialization for std::weak_ptr

[编辑]类模板 std::out_ptr_t

[编辑]类模板 std::inout_ptr_t

[编辑]类模板 std::indirect

[编辑]类模板 std::polymorphic

导航

工具箱