c – 如何绑定传递未指定的调用包装器的成员函数模板

#include <functional>

class X {
public:
  template <typename T>
  explicit X(T t)
  {
    std::bind(&X::invoke<T>,this,t)();
  }
private:
  template <typename T>
  void invoke(T t)
  {
    t();
  }
};

class Y {
  public:
    void foo() {
      //...
    }
};


int main() {
  Y y;
  X x(std::bind(&Y::foo,&y));
  return 0;
}

问题的根本原因似乎是由std :: bind执行其参数的内部复制,特别是对t的引用.

您可能希望以这种方式解决它：

template <typename T>
  explicit X(T t)
  {
      std::bind(&X::invoke<T>,std::placeholders::_1)(t);
      //                             ^^^^^^^^^^^^^^^^^^^^^  ^
  }

这也可以,但是你不会允许绑定的结果比参数t更长(否则,你将传递一个悬空引用来调用< T>())：

template <typename T>
  explicit X(T t)
  {
      std::bind(&X::invoke<T>,cref(t))();
      //                             ^^^^^^^
  }

更新：

上述解决方案是有助于实现您在示例中显示的内容的解决方法.但是,从评论中可以看出,您的用例可能大不相同(例如,传递绑定结果以供以后评估).

正如Maxim Yegorushkin在他的回答中正确指出的那样,概念上正确的解决方案在于使用诸如Boost的保护之类的结构.

如果您不想使用Boost,使用C 11的可变参数模板定义您自己的protect()函数非常容易：

// Imitates boost::protect,but with variadic templates and perfect forwarding
namespace detail
{
    template<typename F>
    struct protect
    {
    private:

        F _f;

    public:

        explicit protect(F f): _f(f)
        {
        }

        template<typename... Ts>
        auto operator () (Ts&&... args) -> 
            decltype(_f(std::forward<Ts>(args)...))
        {
            return _f(std::forward<Ts>(args)...);
        }
    };
}

template<typename F>
detail::protect<F> protect(F&& f)
{
    return detail::protect<F>(std::forward<F>(f));
}

最终,这是你在课堂上使用它的方式,正如Maxim建议的那样：

class X
{
public:
    template <typename T>
    explicit X(T t)
    {
        auto pt = protect(t);
        std::bind(&X::invoke<decltype(pt)>,pt)();
    }
private:
    template <typename T>
    void invoke(T t)
    {
        t();
    }
};