何时释放 unique_ptr？

Question

在这段代码中：

void f(std::unique_ptr<int> q)
{
}

void g()
{
    std::unique_ptr<int> p{new int{42}};
    f(std::move(p));
}

p 在哪一行被释放？ 我会说在 f function 的出口处，因为它是使用 std::move 移到那里的，但我对这个答案不确定也没有信心。

Answer 1

p在哪一行被释放？

p是 object，对象可以被破坏。 这是可以释放的内存。

p最初指向的 memory （由new int{42}分配）在控制离开f时（当q被销毁时）被释放。

当控制离开g时p本身被破坏（此时p是 null，即不指向任何东西）。

Answer 2

p 在哪一行被释放？

在 scope 的末尾，在这种情况下，它被声明为 function g。 那是当具有自动存储的对象被销毁，并且它们的 memory 被释放时。

初始化为 42 的具有动态存储的 integer 将由 f 末尾的 q 的析构函数释放。 这是因为搬迁建设转移了所有权。

Answer 3

为了清楚地更改您的代码片段，请按以下方式

#include <iostream>
#include <memory>
#include <utility>

struct A
{
    ~A() { std::cout << "~A()\n"; }
};

void f(std::unique_ptr<A> q)
{
    std::cout << "f() begins\n";
}

void g()
{
    std::cout << "g() begins\n";
    std::unique_ptr<A> p{new A };
    f( std::move( p ) );
    std::cout << "p == nullptr is " << ( p == nullptr ) << '\n';
    std::cout << "g() endss\n";
}

int main() 
{
    std::cout << "Within main()\n";
    g();

    return 0;
}

程序 output 是

Within main()
g() begins
f() begins
~A()
p == nullptr is 1
g() endss

所以 function g 将指向 object 的所有权转移给 function f。 function f 结束并确实转移了指向 object 的所有权，也没有转移其他 function。 因此，在 function f 退出的那一刻，调用了析构函数。

Answer 4

您正在将所有权从p转移到q ，因此q现在拥有该资源。 因此，一旦q被销毁，您的 integer 就会被销毁，即在 function f的末尾。

唯一指针本身在其作用域的末尾被销毁，即当g()返回时p被销毁，而当f()返回时q被销毁。

另见这个小例子。

Answer 5

p将在退出g function 时被销毁，就像具有本地 scope 的任何其他变量一样。 只是，当时它不再保存数据； 要理解，您实际上不需要单独的 function ，只需考虑一下：

int* n = new int(42);

{
    std::unique_ptr<int> p(n); // p how owns the value pointed to by n
                               // for brevity, I'll say p owns n from now on,
                               // although technically not correct...

    { // opening another scope! (corresponds to function call)
        std::unique_ptr<int> q; // another variable, nothing else is a
                                // function parameter either...

        q = std::move(p);       // this happens, too, when calling a function
                                // at this point, the ownership is transferred to q
                                // q now owns n, p is left with just nothing
                                // (i. e. now holds a null-pointer)
    } // at this point, q is going out of scope; as it is the current
      // owner of n, it will delete it

    // p still is in scope, but it has transferred ownership, remember?

} // at this point, p is destroyed; as it doesn't own anything at all any more
  // it dies without doing anything either...