std::unique_ptr<T,Deleter>::unique_ptr

 

C++

编译器支持

自立实现与有宿主实现

语言

标准库

标准库标头

具名要求

功能特性测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用工具库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

并发支持库 (C++11)

技术规范

符号索引

外部库

 

工具库

语言支持 类型支持（基本类型、 RTTI） 库功能特性测试宏 (C++20) 动态内存管理 程序工具 协程支持 (C++20) 变参数函数 is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) 三路比较 (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20) is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

通用工具 日期和时间 函数对象 格式化库 (C++20) bitset hash (C++11) 关系运算符 (C++20 中弃用) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= 整数比较函数 cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20) cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) swap 与类型运算 swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) 常用词汇类型 pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23) 初等字符串转换 to_chars (C++17) from_chars (C++17) chars_format (C++17) to_chars_result (C++17) from_chars_result (C++17)

 

动态内存管理

未初始化内存算法 uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) destroy_at (C++17) voidify (C++20) uninitialized_copy_n (C++11) uninitialized_fill_n uninitialized_move_n (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17) destroy_n (C++17) construct_at (C++20) 受约束的未初始化内存算法 ranges::uninitialized_copy (C++20) ranges::uninitialized_fill (C++20) ranges::uninitialized_move (C++20) ranges::construct_at (C++20) ranges::destroy (C++20) ranges::destroy_n (C++20) ranges::destroy_at (C++20) ranges::uninitialized_copy_n (C++20) ranges::uninitialized_fill_n (C++20) ranges::uninitialized_move_n (C++20) ranges::uninitialized_default_construct (C++20) ranges::uninitialized_value_construct (C++20) ranges::uninitialized_default_construct_n (C++20)   ranges::uninitialized_value_construct_n (C++20) 分配器 allocator allocator_traits (C++11) allocation_result (C++23) allocator_arg (C++11) uses_allocator (C++11) uses_allocator_construction_args (C++20) make_obj_using_allocator (C++20) uninitialized_construct_using_allocator (C++20) scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) 内存资源 pmr::memory_resource (C++17) pmr::get_default_resource (C++17) pmr::set_default_resource (C++17) pmr::new_delete_resource (C++17) pmr::null_memory_resource (C++17) pmr::synchronized_pool_resource (C++17) pmr::unsynchronized_pool_resource (C++17)   pmr::monotonic_buffer_resource (C++17) pmr::pool_options (C++17) 垃圾收集支持 declare_reachable (C++11)(C++23 前) undeclare_reachable (C++11)(C++23 前) declare_no_pointers (C++11)(C++23 前) undeclare_no_pointers (C++11)(C++23 前) pointer_safety (C++11)(C++23 前) get_pointer_safety (C++11)(C++23 前) 未初始化存储 raw_storage_iterator (C++20 前*) get_temporary_buffer (C++20 前*) return_temporary_buffer (C++20 前*) 显式生存期管理 start_lifetime_asstart_lifetime_as_array (C++23)(C++23)

智能指针 unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (C++17 前*) owner_less (C++11) owner_less<void> (C++17) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) out_ptr_t (C++23) inout_ptr_t (C++23) 低层内存管理 operator new operator new[] operator delete operator delete[] get_new_handler set_new_handler launder (C++17) bad_alloc bad_array_new_length nothrow_t align_val_t destroying_delete_t new_handler nothrow 杂项 pointer_traits (C++11) to_address (C++20) addressof (C++11) align (C++11) assume_aligned (C++20) C 库 malloc calloc realloc    aligned_alloc (C++17) free

 

std::unique_ptr

成员函数

unique_ptr::unique_ptr

unique_ptr::~unique_ptr

unique_ptr::operator=

修改器

unique_ptr::release

unique_ptr::reset

unique_ptr::swap

观察器

unique_ptr::get

unique_ptr::get_deleter

unique_ptr::operator bool

unique_ptr::operator*unique_ptr::operator->

unique_ptr::operator[]

非成员函数

make_uniquemake_unique_for_overwrite (C++14)(C++20)

operator==operator!=operator<operator>operator<=operator>=operator<=> (C++20 前)(C++20)

operator<< (C++20)

std::swap

std::hash

 

主模板 unique_ptr<T> 的成员
constexpr unique_ptr() noexcept; constexpr unique_ptr( std::nullptr_t ) noexcept;	(1)
explicit unique_ptr( pointer p ) noexcept;	(2)	(C++23 起为 constexpr)
unique_ptr( pointer p, /* see below */ d1 ) noexcept;	(3)	(C++23 起为 constexpr)
unique_ptr( pointer p, /* see below */ d2 ) noexcept;	(4)	(C++23 起为 constexpr)
unique_ptr( unique_ptr&& u ) noexcept;	(5)	(C++23 起为 constexpr)
template< class U, class E > unique_ptr( unique_ptr<U, E>&& u ) noexcept;	(6)	(C++23 起为 constexpr)
template< class U > unique_ptr( std::auto_ptr<U>&& u ) noexcept;	(7)	(C++17 中移除)
数组特化 unique_ptr<T[]> 的成员
constexpr unique_ptr() noexcept; constexpr unique_ptr( std::nullptr_t ) noexcept;	(1)
template<class U> explicit unique_ptr( U p ) noexcept;	(2)	(C++23 起为 constexpr)
template<class U> unique_ptr( U p, /* see below */ d1 ) noexcept;	(3)	(C++23 起为 constexpr)
template<class U> unique_ptr( U p, /* see below */ d2 ) noexcept;	(4)	(C++23 起为 constexpr)
unique_ptr( unique_ptr&& u ) noexcept;	(5)	(C++23 起为 constexpr)
template< class U, class E > unique_ptr( unique_ptr<U, E>&& u ) noexcept;	(6)	(C++23 起为 constexpr)

1) 构造不占有对象的 std::unique_ptr 。值初始化存储的指针和存储的删除器。要求 Deleter 可默认构造 (DefaultConstructible) 且构造不抛异常。这些重载只有在 std::is_default_constructible<Deleter>::value 为 true 且 Deleter 不是指针类型时才会参与重载决议。

2) 构造占有 p 的 std::unique_ptr ，以 p 初始化存储的指针，并值初始化存储的删除器。要求 Deleter 可默认构造 (DefaultConstructible) 且构造不抛异常。这些重载只有在 std::is_default_constructible<Deleter>::value 为 true 且 Deleter 不是指针类型时才会参与重载决议。

类模板实参推导不选择此构造函数。

(C++17 起)

3-4) 构造占有 p 的 std::unique_ptr 对象，以 p 初始化存储的指针，并按下列方式初始化删除器 D （依赖于 D 是否为引用类型）

a) 若 D 是非引用类型 A ，则签名是：

unique_ptr(pointer p, const A& d) noexcept;	(1)	（要求 Deleter 为不抛出可复制构造 (CopyConstructible) ）
unique_ptr(pointer p, A&& d) noexcept;	(2)	（要求 Deleter 为不抛出可移动构造 (MoveConstructible) ）

b) 若 D 是左值引用类型 A& ，则签名是：

unique_ptr(pointer p, A& d) noexcept;	(1)
unique_ptr(pointer p, A&& d) = delete;	(2)

c) 若 D 是左值引用类型 const A& ，则签名是：

unique_ptr(pointer p, const A& d) noexcept;	(1)
unique_ptr(pointer p, const A&& d) = delete;	(2)

所有情况下中删除器从 std::forward<decltype(d)>(d) 初始化。这些重载只有在 std::is_constructible<D, decltype(d)>::value 为 true 时才会参与重载决议。

类模板实参推导不选择这二个构造函数。

(C++17 起)

2-4) 数组特化中表现同初等模板中接收一个指针参数的构造函数，除了它们不另外参与重载决议，除非下列之一为真：

• U 与 pointer 为同一类型，或
• U 为 std::nullptr_t ，或
• pointer 与 element_type* 为同一类型且 U 为指针类型 V* ，满足 V(*)[] 可隐式转换为 element_type(*)[] 。

5) 通过从 u 转移所有权给 *this 构造 unique_ptr 并存储空指针于 u 。此构造函数仅若 std::is_move_constructible<Deleter>::value 为 true 才参与重载决议。若 Deleter 不是引用类型，则要求它为不抛出可移动构造 (MoveConstructible) （若 Deleter 是引用，则 get_deleter() 和 u.get_deleter() 在移动构造后引用相同值）。

6) 通过从 u 转移所有权给 *this 构造 unique_ptr ，其中 u 以指定的删除器（ E ）构造。它依赖于 E 是否为引用类型，如下：

a) 若 E 是引用类型，则从 u 的删除器复制构造此删除器（要求此构造不抛出）

b) 若 E 不是引用类型，则从 u 的删除器移动构造此删除器（要求此构造不抛出）

此构造函数仅若下列皆为真才参与重载决议：

a) unique_ptr<U, E>::pointer 可隐式转换为 pointer

b) U 不是数组类型

c) Deleter 是引用类型且 E 与 D 为同一类型，或 Deleter 不是引用类型且 E 可隐式转换为 D

6) 数组特化中，表现同在初等模板中的版本，除了它仅若下列皆为真才会参与重载决议

• U 是数组类型
• pointer 与 element_type* 是同一类型
• unique_ptr<U,E>::pointer 与 unique_ptr<U,E>::element_type* 是同一类型
• unique_ptr<U,E>::element_type(*)[] 可转换为 element_type(*)[]
• Deleter 是引用类型且 E 与 Deleter 是同一类型，或 Deleter 非引用类型且 E 可隐式转换为 Deleter 。

7) 构造 unique_ptr ，其中以 u.release() 初始化存储的指针，并值初始化存储的删除器。此构造函数仅若 U* 可隐式转换为 T* 且 Deleter 与 std::default_delete<T> 为同一类型才参与重载决议。

参数

p	-	指向要管理的对象的指针
d1,d2	-	用于销毁对象的删除器
u	-	获取所有权来源的智能指针

注解

使用 std::make_unique<T> 是更好的做法，可取代与 new 一起的重载 (2) 。

(C++14 起)

std::unique_ptr<Derived> 通过重载 (6) 可隐式转换为 std::unique_ptr<Base> （因为被管理指针和 std::default_delete 都可隐式转换）。

因为默认构造函数是 constexpr ，故静态的 unique_ptr 作为静态非局部初始化的一部分初始化，在任何动态初始化之前。这使得在任何静态对象的构造函数中使用 unique_ptr 是安全的。

无源自指针类型的类模板实参推导，因为不可能辨别来自 new 的数组和非数组形式的指针。

(C++17 起)

示例

运行此代码

#include <iostream>
#include <memory>
 
struct Foo { // 要管理的对象
    Foo() { std::cout << "Foo ctor\n"; }
    Foo(const Foo&) { std::cout << "Foo copy ctor\n"; }
    Foo(Foo&&) { std::cout << "Foo move ctor\n"; }
    ~Foo() { std::cout << "~Foo dtor\n"; }
};
 
struct D { // 删除器
    D() {};
    D(const D&) { std::cout << "D copy ctor\n"; }
    D(D&) { std::cout << "D non-const copy ctor\n";}
    D(D&&) { std::cout << "D move ctor \n"; }
    void operator()(Foo* p) const {
        std::cout << "D is deleting a Foo\n";
        delete p;
    };
};
 
int main()
{
    std::cout << "Example constructor(1)...\n";
    std::unique_ptr<Foo> up1;  // up1 为空
    std::unique_ptr<Foo> up1b(nullptr);  // up1b 为空
 
    std::cout << "Example constructor(2)...\n";
    {
        std::unique_ptr<Foo> up2(new Foo); // up2 现在占有 Foo
    } // Foo 被删除
 
    std::cout << "Example constructor(3)...\n";
    D d;
    {  // 删除器类型不是引用
       std::unique_ptr<Foo, D> up3(new Foo, d); // 复制删除器
    }
    {  // 删除器类型是引用 
       std::unique_ptr<Foo, D&> up3b(new Foo, d); // up3b 保有到 d 的引用
    }
 
    std::cout << "Example constructor(4)...\n";
    {  // 删除器不是引用
       std::unique_ptr<Foo, D> up4(new Foo, D()); // 移动删除器
    }
 
    std::cout << "Example constructor(5)...\n";
    {
       std::unique_ptr<Foo> up5a(new Foo);
       std::unique_ptr<Foo> up5b(std::move(up5a)); // 所有权转移
    }
 
    std::cout << "Example constructor(6)...\n";
    {
        std::unique_ptr<Foo, D> up6a(new Foo, d); // 复制 D
        std::unique_ptr<Foo, D> up6b(std::move(up6a)); // 移动 D
 
        std::unique_ptr<Foo, D&> up6c(new Foo, d); // D 是引用
        std::unique_ptr<Foo, D> up6d(std::move(up6c)); // 复制 D
    }
 
#if (__cplusplus < 201703L)
    std::cout << "Example constructor(7)...\n";
    {
        std::auto_ptr<Foo> up7a(new Foo);
        std::unique_ptr<Foo> up7b(std::move(up7a)); // 所有权转移
    }
#endif
 
    std::cout << "Example array constructor...\n";
    {
        std::unique_ptr<Foo[]> up(new Foo[3]);
    } // 删除三个 Foo 对象
}

输出：

Example constructor(1)...
Example constructor(2)...
Foo ctor
~Foo dtor
Example constructor(3)...
Foo ctor
D copy ctor
D is deleting a Foo
~Foo dtor
Foo ctor
D is deleting a Foo
~Foo dtor
Example constructor(4)...
Foo ctor
D move ctor 
D is deleting a Foo
~Foo dtor
Example constructor(5)...
Foo ctor
~Foo dtor
Example constructor(6)...
Foo ctor
D copy ctor
D move ctor 
Foo ctor
D non-const copy ctor
D is deleting a Foo
~Foo dtor
D is deleting a Foo
~Foo dtor
Example constructor(7)...
Foo ctor
~Foo dtor
Example array constructor...
Foo ctor
Foo ctor
Foo ctor
~Foo dtor
~Foo dtor
~Foo dtor

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告	应用于	出版时的行为	正确行为
LWG 2118	C++11	unique_ptr<T[]> 的构造函数拒绝限定转换	接受
LWG 2520	C++11	unique_ptr<T[]> 被意外地设为不可从 nullptr_t 构造	使之可构造
LWG 2801	C++11	默认构造函数未受约束	已约束
LWG 2899	C++11	移动构造函数未受约束	已约束
LWG 2905	C++11	来自指针和删除器的构造函数上的约束错误	更正
LWG 2944	C++11	某些前条件被 LWG 2905 意外丢弃	恢复