C++ 参考手册

位置：首页 > C++ 参考手册 >动态内存管理 >std::unique_ptr > std::unique_ptr<T,Deleter>::unique_ptr

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

若 Deleter 是指针或引用类型则此构造函数为病式。

(C++17 前)

这些重载仅若 std::is_default_constructible<Deleter>::value 为 true 且 Deleter 不是指针类型才参与重载决议。

(C++17 起)
2) 构造占有 p 的 std::unique_ptr ，以 p 初始化存储的指针，并值初始化存储的删除器。要求 Deleter 可默认构造 (DefaultConstructible) 且构造不抛异常。

若 Deleter 是指针或引用类型则此构造函数为病式。

(C++17 前)

此重载仅若 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);
 (2)
c) 若 D 是左值引用类型 const A& ，则签名是：
unique_ptr(pointer p, const A& d) noexcept;
 (1)
unique_ptr(pointer p, const A&& d);
 (2)
所有情况中删除器从 std::forward<decltype(d)>(d) 初始化。

若 D 是引用类型且选择第二重载，则程序为病式。

(C++17 前)

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

参数

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

注意

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

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