std::async、std::function 对象和带有 'callable' 参数的模板

std::async, std::function object and templates with 'callable' parameter

#include <functional>
#include <future>

void z(int&&){}
void f1(int){}
void f2(int, double){}

template<typename Callable>
void g(Callable&& fn)
{
    fn(123);
}

template<typename Callable>
std::future<void> async_g(Callable&& fn)
{
    return std::async(std::launch::async, std::bind(&g<Callable>, fn));
}

int main()
{
    int a = 1; z(std::move(a)); // Does not work without std::move, OK.

    std::function<void(int)> bound_f1 = f1;
    auto fut = async_g(bound_f1); // (*) Works without std::move, how so?
    // Do I have to ensure bound_f1 lives until thread created by async_g() terminates?
    fut.get();

    std::function<void(int)> bound_f2 = std::bind(f2, std::placeholders::_1, 1.0);
    auto fut2 = async_g(bound_f2);
    // Do I have to ensure bound_f2 lives until thread created by async_g() terminates?
    fut2.get();

    // I don't want to worry about bound_f1 lifetime,
    // but uncommenting the line below causes compilation error, why?
    //async_g(std::function<void(int)>(f1)).get(); // (**)
}

问题 1. 为什么在 (*) 的调用在没有 std::move 的情况下有效?

问题2.因为我不明白(*)处的代码是如何工作的,所以出现了第二个问题。我是否必须确保每个变量 bound_f1bound_f2 一直存在,直到 async_g() 创建的相应线程终止?

问题3.为什么取消注释(**)标记的行会导致编译错误?

简答: 在模板类型推导的上下文中,类型是从

形式的表达式推导出来的
template <typename T>
T&& t

t 不是右值引用,而是 转发引用(要查找的关键字,有时也称为通用引用)。自动类型推导也会发生这种情况

auto&& t = xxx;

转发引用的作用是它们绑定到左值和右值引用,并且仅真正用于 std::forward<T>(t) 以将具有相同引用限定符的参数转发到下一个函数。

当您将此通用引用与左值一起使用时,T 推导的类型为 type&,而当您将其与右值引用一起使用时,类型将仅为 type (归结为参考折叠规则)。那么现在让我们看看你的问题会发生什么。

  1. 你的 async_g 函数是用 bound_f1 调用的,它是一个左值。因此,为 Callable 推导的类型是 std::function<void(int)>&,并且由于您显式地将此类型传递给 g,因此 g 需要一个左值类型的参数。当您调用 bind 时,它会复制它绑定的参数,因此 fn 将被复制,然后该副本将传递给 g.

  2. bind(和 thread/async)执行参数的 copies/moves,如果您考虑一下,这是正确的做法。这样你就不必担心 bound_f1/bound_f2.

  3. 的生命周期
  4. 由于您实际上将右值传递给了对 async_g 的调用,这次为 Callable 推导出的类型只是 std::function<void(int)>。但是因为您将此类型转发给 g,它需要一个右值参数。虽然 fn 的类型是右值,但它本身是左值并被复制到 bind 中。所以当绑定函数执行时,它会尝试调用

    void g(std::function<void(int)>&& fn)
    

    参数不是右值。这就是您的错误来源。在 VS13 中,最终的错误信息是:

    Error   1   error C2664: 'void (Callable &&)' : 
    cannot convert argument 1 from 'std::function<void (int)>' to 'std::function<void (int)> &&'    
    c:\program files\microsoft visual studio 12.0\vc\include\functional 1149
    

现在您实际上应该重新考虑使用转发引用 (Callable&&) 尝试实现的目标、需要转发多远以及参数应该在哪里结束。这也需要考虑参数的生命周期。

为了克服错误,用 lambda 替换 bind 就足够了(总是个好主意!)。代码变为:

template<typename Callable>
std::future<void> async_g(Callable&& fn)
{
    return std::async(std::launch::async, [fn] { g(fn); });
}

这是最省力的解决方案,但参数被复制到 lambda 中。