C++ 如何将成员函数绑定到C++；14

我试图将成员函数绑定到对象，同时保持参数打开。我知道我可以通过将它包装到lambda表达式（比如）中来实现，但我想使用std:：bind和std:：placeholder来实现

到目前为止，我得到的是：

template <size_t _Num>
struct place_holder {};

namespace std {
  template <size_t _Num>
  struct is_placeholder<::place_holder<_Num>> : integral_constant<size_t, _Num> {};
}

namespace _binding_helper_ {
  template <size_t ... _Indices>
  std::tuple<place_holder<_Indices>...> get_placeholders(std::index_sequence<_Indices...>) {
      return std::make_tuple(place_holder<_Indices>()...);
  }
}

template <typename _Obj, typename _Func, typename ... _Args>
std::function<_Func(_Args...)> bind_function_to_object
    (_Func (_Obj::*func)(_Args...), _Obj & obj) {
    return std::bind(func, obj,
        _binding_helper_::get_placeholders(std::make_index_sequence<sizeof...(_Args)>{}));
}

模板
结构放置{}；
名称空间标准{
模板
结构是_占位符：整型_常量{}；
}
名称空间\u绑定\u帮助程序\u{
模板
std:：tuple get_占位符（std:：index_序列）{
return std:：make_tuple（place_holder（）…）；
}
}
模板
函数绑定函数到对象
（_-Func（_-Obj:：*Func）（_-Args…，_-Obj&Obj）{
返回std:：bind（func，obj，
_绑定辅助对象：获取占位符（std:：make_index_sequence{}）；
}

---

创建place_holders的元组效果很好，但是当我在元组的元素上调用std:：is_placeholder:：value时，它们都是0。如何将所有必需的_Num值初始化为std:：placeholder结构？希望有个简单的解决办法。谢谢你的帮助。谢谢

占位符从

1

开始编号，而不是从

0

开始编号。基于我提到的原因，我假设在您的

静态断言中失败的是条件
std:：is\u占位符{}

此外，您正在将占位符元组传递给
std:：bind
。相反，您应该直接传递占位符，即，
placeholder{}…

template <int Num>
struct place_holder {};

namespace std 
{
    template <int Num>
    struct is_placeholder<::place_holder<Num>> : integral_constant<int, Num> {};
}

template <typename Obj, typename C, typename Func, typename... Args, int... Is>
std::function<Func(Args...)> bind_function_to_object(Func(C::*func)(Args...), Obj&& obj, std::integer_sequence<int, Is...>)
{
    return std::bind(func, std::forward<Obj>(obj), place_holder<Is + 1>{}...);
}

template <typename Obj, typename C, typename Func, typename... Args>
std::function<Func(Args...)> bind_function_to_object(Func(C::*func)(Args...), Obj&& obj)
{
    return bind_function_to_object(func, std::forward<Obj>(obj), std::make_integer_sequence<int, sizeof...(Args)>{});
}

模板
结构放置{}；
名称空间标准
{
模板
结构是_占位符：整型_常量{}；
}
模板
std:：function将函数绑定到对象（Func（C:：*Func）（Args…，Obj&&Obj，std:：integer\u序列）
{
返回std:：bind（func，std:：forward（obj），place_holder{}；
}
模板
std:：function将函数绑定到对象（Func（C:：*Func）（Args…，Obj&&Obj）
{
将bind_函数_返回给_对象（func，std:：forward（obj），std:：make_integer_sequence{}）；
}

你能演示一下模板是如何实例化的吗？我很确定
is\u placeholder
需要继承自
integral\u constant
，而不是
integral\u constant
。我想你应该将
obj
的地址传递给
std:：bind
，而不是
obj
。像
返回std:：bind（func，&obj，_binding_helper_:：get_placcholder（std:：make_index_sequence{}））您需要
std:：make_tuple（place_holder（）…），占位符从
1
开始，而不是
0
此外，代码中非法标识符的数量非常惊人，这就成功了！谢谢！有没有一种方法可以不用额外的模板类型C来实现呢？有两个模板参数基本上描述同一类型的对象，这似乎很奇怪。@geanakuch它允许您传递基类的成员函数和派生类的实例。但如果您不喜欢，请删除完美转发并使用左值引用，即
Obj&Obj
，然后
（Obj:：*func）
等。