C++ 模板 : do something inside a function, 取决于模板参数

Question

请查看成员函数virtual std::future<void> DoInvoke ()类(class) EventMemberImpl :

#include <future>
#include <functional>

class EventImpl
{
public:
  virtual ~EventImpl () = default;
  std::future<void> Invoke () { return DoInvoke (); }
private:
  virtual std::future<void> DoInvoke () = 0;
};

template <typename... Ts>
EventImpl * MakeEvent (Ts&&... args)
{
  class EventMemberImpl : public EventImpl
  {
public:
    EventMemberImpl (Ts&&... args)
      : m_function (std::bind (std::forward<Ts> (args)...))
    {
    }
protected:
    virtual ~EventMemberImpl ()
    {
    }
private:
    virtual std::future<void> DoInvoke ()
    {
      // MakeEvent has been called with
      // a Callable which does not return a future
      m_function ();
      return std::future<void> ();
      // OR
      // MakeEvent has been called with a
      // Callable which returns a future:
      return m_function();
    }
     // In case is any function...  :
    std::function<void ()> m_function;

    // OR
    // ... except when it returns a future:
    std::function<std::future<void> ()> m_function;
  };
  return new EventMemberImpl (std::forward<Ts> (args)...);
}

int foo() { return 5; }
std::future<int> baz () { return std::future<int> (); }

int main ()
{

  EventImpl *event1 = MakeEvent(std::forward<decltype (&foo)> (&foo));
  EventImpl *event2 = MakeEvent(std::forward<decltype (&baz)> (&baz));

  return 0;
}

我想做的是，当有人使用一个函数(任何可调用的)作为返回 void(或几乎任何其他东西)的参数调用 MakeEvent 时，主体的行为应该与我编写的完全一样。另一方面，当使用返回 std::future 的函数作为参数调用 MakeEvent 函数时，它应该做不同的事情。

Answer 1

您可以混合使用 std::conditional 和函数重载。

让我们为函数的返回类型定义一个别名:

using result = decltype(std::bind(std::declval<Ts>()...)());

然后，我们可以为我们的条件创建另一个别名:

template<typename T>
using is_future = std::is_convertible<T, std::future<void>>;

然后，有了这个条件，我们就可以声明我们的成员了:

std::conditional_t<is_future<result>::value,
    std::function<std::future<void>>,
    std::function<void()>
> m_function;

然后，我们可以重载一个函数来有条件地选择需要哪个表达式。在 C++17 中，仅在需要时使用 constexpr:

virtual std::future<void> DoInvoke () {
    if constexpr (!is_future<result>::value) {
        m_function ();
        return std::future<void>();
    } else {
        return m_function();
    }
}

对比C++14，需要重载函数，使用sfinae:

template<typename F, std::enable_if_t<is_future<std::result_of_t<F()>>::value>* = nullptr>
auto DoInvokeSelect(F& function) -> std::future<void> {
    return function();
}

template<typename F, std::enable_if_t<!is_future<std::result_of_t<F()>>::value>* = nullptr>
auto DoInvokeSelect(F& function) -> std::future<void> {
    function();
    return std::future<void>();
}

virtual std::future<void> DoInvoke () {
    return DoInvokeSelect(m_function);
}

无论结果是否为 future ，enable_if 都会选择其中一个函数。