为什么 `std::thread()` 和 `std::packaged_task()` 工作方式不同，尽管它们都接受可调用目标？

Question

这是一个简单的code snippet:

#include <thread>
#include <future>
#include <functional>

void foo(int){}

int main()
{
    std::thread(foo, 1).join();                  //works indeed
    std::packaged_task<void(int)> task{foo, 1};  //complian
    std::packaged_task<void(int)> task{std::bind(foo, 1)};
}

Both std::thread() and std::packaged_task() accept callable targets，为什么 std::packaged_task() 的代码有点不同？为什么不让 std::packged_task() 像 std::thread() 那样工作（即接受像 std::thread 这样的参数）？

The class template std::packaged_task wraps any Callable target (function, lambda expression, bind expression, or another function object) so that it can be invoked asynchronously. Its return value or exception thrown is stored in a shared state which can be accessed through std::future objects.

Answer 1

std::packaged_task 不会立即运行一个 function/callable，函数执行被推迟，参数可以稍后传递给 void operator()( ArgTypes... args );，因此可能的构造函数 template< class Function, class... Args > explicit packaged_task( Function&& f, Args&&... args ); 没有必要。

但是std::thread运行立即function/callable，因此必须将参数传递给构造函数template< class Function, class... Args > explicit thread( Function&& f, Args&&... args );。你可能会认为它像糖一样避免像 std::thread(bind(f, 1)); 这样的代码而不是方便的 std::thread(f, 1);.

为什么 `std::thread()` 和 `std::packaged_task()` 工作方式不同，尽管它们都接受可调用目标？

Why `std::thread()` and `std::packaged_task()` works different, although they both accept callable targets?

c++

callable

packaged-task

c++11

stdthread