将 std::bind 的结果传递给 std::function “重载”

Question

我有类似于 Passing different lambdas to function template in c++ 的问题，但现在使用由 std::bind 而不是 lambdas 创建的包装器。

我有两个方法 Add 的重载，它们采用不同形式的 std::function：

template<typename T>
struct Value
{
    T value;
};

template <typename T>
void Add(Value<T> &value, function<bool()> predicate)
{
}

template <typename T>
void Add(Value<T> &value, block_deduction<function<bool(const Value<T> &)>> predicate)
{
}

这现在适用于 lambdas，但与绑定 std::bind 的函子失败：

struct Predicates
{
    bool Predicate0() { return true; }
    bool Predicate1(const Value<int> &) { return true; }
};

Predicates p;
Add(i, std::bind(&Predicates::Predicate0, &p));

失败

错误 C2668：“添加”：对重载函数的模糊调用

和

Add(i, std::bind(&Predicates::Predicate1, &p, _1));

静态断言失败（Visual C++ 2015，更新 3）：

元组索引超出范围

有没有办法让它与 lambdas 和绑定函子一起工作？我会考虑使用 SFINAE 来启用基于 is_bindable_expression 的单个重载并检查参数类型，但我没有把它放在一起。

Answer 1

停止使用std::bind。这是一堆随机特征和怪癖。

今天的怪癖是std::bind 将接受无限数量的参数并丢弃任何多余的参数。明天你可能会遇到这样一个事实：将std::bind 结果传递给std::bind 会产生奇怪的魔力。

std::bind 被移植到boost，同时将 lambdas 添加到语言中。 Lambda 几乎解决了 bind 的所有问题，语法清晰，但没有 bind 的无数怪癖，尤其是在 C++14 之后 auto lambda 可用时。 （大多数 C++11 编译器也支持auto lambda）。

您可以编写函数，以便当它们都适用时，一个或另一个是首选的重载。但是这样做会给你的界面增加一堆噪音，在这种情况下，你想要这种偏好的唯一原因是因为std::bind 正在做一些愚蠢的事情。

围绕设计不佳的 std 库进行工程设计是不值得的。只需停止使用设计不佳的 std 库，或在使用点显式转换。

---

如果做不到，请执行以下操作：

template <class T, class F,
  std::enable_if_t<
    std::is_convertible<
      std::result_of_t<std::decay_t<F> const&(Value<T> const&)>,
      bool
    >{}, int
  > = 0
>
void Add(Value<T> &value, F&& f)
{
  // do pass f Value<T>
}
template <class T, class F,
  std::enable_if_t<
    !std::is_convertible<
      std::result_of_t<std::decay_t<F> const&(Value<T> const&)>,
      bool
    >{}
    && std::is_convertible<
      std::result_of_t<std::decay_t<F> const&()>,
      bool
    >{}, int
  > = 0
>
void Add(Value<T> &value, F&& f)
{
  // do not pass f Value<T>
}

我们对您要使用的两个重载中的哪一个进行了一些令人讨厌的 SFINAE 检测，并明确首选一个。

这不值得。

Answer 2

我不认为你可以做你想做的事。

您可以使用is_bind_expression 来检查您的参数是否是通过调用std::bind 生成的类型，但是无法判断可调用对象需要多少个参数。正如cpplearned在cmets中提到的，这是std::bind的一个特性：

如果在调用 g() 时提供的某些参数不是 由存储在g 中的任何占位符匹配，未使用的参数是 评估并丢弃。

这意味着两个重载同样有效。

---

如果您不介意为所有bind 结果共享相同的重载，则可以传递所有参数并让它们随意丢弃：

template <typename T>
void AddImpl(Value<T> &value, function<bool()> predicate, std::false_type)
{
    predicate();
}

template <typename T>
void AddImpl(Value<T> &value, block_deduction<function<bool(const Value<T> &)>> predicate, std::false_type)
{
    predicate(value);
}

template <typename T, typename U>
void AddImpl(Value<T>& value, U&& bind_expression, std::true_type)
{
    bind_expression(value);
}

template<typename T, typename U>
void Add(T&& t, U&& u)
{
    AddImpl(std::forward<T>(t), std::forward<U>(u), std::is_bind_expression<std::decay_t<U>>{});
}

demo

但这类似于使用布尔参数。在我看来，在正确命名的标签上分派可读性会更好：

template <typename T>
void AddImpl(Value<T> &value, function<bool()> predicate, tag::default_)
{
    predicate();
}

template <typename T>
void AddImpl(Value<T> &value, block_deduction<function<bool(const Value<T> &)>> predicate, tag::default_)
{
    predicate(value);
}

template <typename T, typename U>
void AddImpl(Value<T>& value, U&& bind_expression, tag::bind)
{
    bind_expression(value);
}

template<typename T, typename U>
void Add(T&& t, U&& u)
{
    AddImpl(std::forward<T>(t), std::forward<U>(u), tag::get_tag<std::decay_t<U>>{});
}

标签定义为

namespace tag
{
struct default_{};
struct bind{};

template<typename T, typename = void>
struct get_tag : default_ {};

template<typename T>
struct get_tag<T, std::enable_if_t<std::is_bind_expression<T>::value>> : bind {};

}

demo