我有一个 std::packaged_task 包含一个通过复制捕获变量的 lambda。当这个 std::packaged_task 被删除时，我希望 lambda 中的变量被破坏，但我注意到如果我得到相关的 std::future这个 std::packaged_task，future 对象延长了 lambda 内部变量的生命周期。

例如:

#include <iostream>
#include <future>

class Dummy
{
public:
    Dummy() {std::cout << this << ": default constructed;" << std::endl;}
    Dummy(const Dummy&) {std::cout << this << ": copy constructed;" << std::endl;}
    Dummy(Dummy&&) {std::cout << this << ": move constructed;" << std::endl;}
    ~Dummy() {std::cout << this << ": destructed;" << std::endl;}
};

int main()
{
    std::packaged_task<void()>* p_task;
    {
        Dummy ScopedDummy;
        p_task = new std::packaged_task<void()>([ScopedDummy](){std::cout << "lambda call with: " << &ScopedDummy << std::endl;});
        std::cout << "p_task completed" << std::endl;
    }
    {
        std::future<void> future_result;
        {
            future_result = p_task->get_future();
            (*p_task)();
            delete p_task;
        }
        std::cout << "after p_task has been deleted, the scope of future_result determines the scope of the dummy inside p_task" << std::endl;
    }
    std::cout << "p_task cleans up when future_result dies" << std::endl;
}

可能的输出是:

0x7fff9cf873fe: default constructed;
0x7fff9cf873ff: copy constructed;
0x1904b38: move constructed;
0x7fff9cf873ff: destructed;
0x7fff9cf873fe: destructed;
lambda call with: 0x1904b38
after p_task has been deleted, the scope of future_result determines the scope of the dummy inside p_task
0x1904b38: destructed;
p_task cleans up when future_result dies

因此 lambda 中的对象的生命周期延长了 future_result 的范围。

如果我们注释掉 future_result = p_task->get_future(); 行，可能的输出是:

0x7fff57087896: default constructed;
0x7fff57087897: copy constructed;
0x197cb38: move constructed;
0x7fff57087897: destructed;
0x7fff57087896: destructed;
lambda call with: 0x197cb38
0x197cb38: destructed;
after p_task has been deleted, the scope of future_result determines the scope of the dummy inside p_task
p_task cleans up when future_result dies

我一直在想什么机制在这里发挥作用，std::future 是否包含一些使关联对象保持事件状态的链接？

最佳答案

看着gcc7.2.0 packaged_task sources ，我们读到:

packaged_task(allocator_arg_t, const _Alloc &__a, _Fn &&__fn)
    : _M_state(__create_task_state<_Res(_ArgTypes...)>(std::forward<_Fn>(__fn), __a)){}

~packaged_task()
{
  if (static_cast<bool>(_M_state) && !_M_state.unique())
    _M_state->_M_break_promise(std::move(_M_state->_M_result));
}

其中 _M_state 是指向内部 packaged_task 共享状态的 shared_ptr。因此，事实证明，gcc 将可调用对象存储为 packaged_task 共享状态 的一部分，因此将可调用生命周期绑定(bind)到 packaged_task、future、shared_future 中最后死亡的对象。 p>

相比之下，clang 不会，它会在打包任务被销毁时销毁可调用对象(事实上，我的 clang 拷贝会将可调用对象存储为适当的成员)。

谁是对的？标准对存储的任务生命周期不是很清楚；一方面，我们有

[[futures.task]]

packaged_task defines a type for wrapping a function or callable object so that the return value of the function or callable object is stored in a future when it is invoked.

packaged_task(F&& f)[...]Constructs a new packaged_task object with a shared state and initializes the object’s stored task with std::forward(f).

packaged_task(packaged_task&& rhs)[...]Moves the stored task from rhs to *this.

reset()[...]Effects: As if *this = packaged_task(std::move(f)), where f is the task stored in *this.

这表明可调用对象属于 packaged_task，但我们也有

[[futures.state]]

-Many of the classes introduced in this subclause use some state to communicate results. This shared state consists of some state information and some (possibly not yet evaluated) result, which can be a (possibly void) value or an exception. [ Note: Futures, promises, and tasks defined in this clause reference such shared state. —endnote]

-[ Note: The result can be any kind of object including a function to compute that result, as by async [...]]

和

[futures.task.members]

-packaged_task(F&& f);[...]Invoking a copy of f shall behave the same as invoking f[...] -~packaged_task(); Effects: Abandons any shared state

建议可调用对象可以存储在共享状态中，并且不应依赖任何可调用的实例行为(这可能被解释为包括可调用生命周期结束的副作用；顺便说一句，这也意味着您的可调用对象不是严格有效的，因为它的行为与其拷贝不同)；此外，对于dtor中存储的任务也没有任何提及。

总而言之，我认为 clang 更一致地遵循了措辞，尽管似乎没有什么明确禁止 gcc 行为。也就是说，我同意应该更好地记录这一点，因为否则可能会导致令人惊讶的错误......

关于c++ - std::future 如何影响关联的 std::packaged_task 的生命周期？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47202990/