Question

请查看班级virtual std::future<void> DoInvoke ()的成员函数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;
}

我想要做的是，当有人用函数（任何可调用的）调用MakeEvent作为返回void（或几乎任何其他东西）的参数时，身体的行为应该与我写的一模一样。另一方面，当使用函数作为返回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);
}

如果结果是未来，则enable_if将选择任一函数。

C ++模板：根据模板参数在函数内部执行某些操作

1 个答案: