Question

我正在尝试从接受Callable类型的模板函数中创建一个Promise。但是我不确定该怎么做。我尝试使用std::invoke_result_t，但是需要参数来知道结果类型，这在构造promise时是不知道的。

我可以推断出返回类型的任何方式吗？我想对于通用Lambda来说可能是不可能的，但是在非通用Lambda情况下有什么作用吗？

template <typename Callable, typename Promise>
class Job {

  public:
    Job(Callable&& c, Promise&& p) 
    : callable(std::move(c))
    , promise(std::move(p))
    {}

    auto getFuture() {
        return /* a std::shared_future */;
    }   

    template<typename... Args>
    void call(Args&&... args) {
        promise.set_value(std::invoke(callable, args...));
    }

  private:
    Callable callable;
    Promise promise;
};

template<typename Callable>
decltype(auto) makeJob(Callable&& c) {
    std::promise</* some type */> promise = /* something */;
    return Job(std::forward<Callable>(c), std::move(promise));
}

int main() {
    f1 = [](int arg){return arg;};
    auto job = makeJob(std::move(f1));
    auto future = job.getFuture();
    job.call(1);
    std::cout << future.get() << '\n';
 }

Answer 1

我可以推断出返回类型的任何方式吗？我想对于通用Lambda来说可能是不可能的，但是在非通用Lambda情况下有什么作用吗？

您为C ++ 17加上了标签，因此... std::function和演绎指南是您的朋友。

您可以通过以下方式检测可调用对象的返回类型

typename decltype(std::function{c})::result_type;

因此您的makeJob()函数可以被编写

template <typename Callable>
auto makeJob (Callable && c)
 {
   using retT = typename decltype(std::function{c})::result_type;

   return Job{std::forward<Callable>(c), std::promise<retT>{}};
 }

与Job类相同。

显然可以，因为f1

auto f1 = [](int arg){return arg;};

具有不依赖于参数的返回类型；带有通用lambda

// ..........vvvv
auto f1 = [](auto arg){return arg;};

此解决方案不再有效，我不认为您可以编写一些不知道参数类型的返回类型。

以下是完整的编译示例

#include <future>
#include <memory>
#include <iostream>
#include <functional>

template <typename C, typename P>
class Job
 {
   public:
      using retT
         = typename decltype(std::function{std::declval<C>()})::result_type;

      Job (C && c, P && p) : callable{std::move(c)}, promise{std::move(p)}
       { }

      auto getFuture ()
       { return std::shared_future<retT>{ promise.get_future() }; }   

      template <typename ... Args>
      void call (Args && ... args)
       { promise.set_value(std::invoke(callable, args...)); }

   private:
      C callable;
      P promise;
 };

template <typename Callable>
auto makeJob (Callable && c)
 {
   using retT
      = typename decltype(std::function{c})::result_type;

   return Job{std::forward<Callable>(c), std::promise<retT>{}};
 }

int main ()
 {
   auto f1 = [](int arg){return arg;};
   auto job = makeJob(std::move(f1));
   auto future = job.getFuture();

   job.call(42);

   std::cout << future.get() << '\n';
 }

从可调用模板生成承诺

1 个答案: