绑定成员函数指针

Question

I was wondering why there is no concept like "bound member-function pointer", ie a member function pointer that is bound to a specific object and can therefore can be treated like a normal function pointer, eg

#include <functional>

struct Foo {
    void foo() {} 
};

void foo() {}

void call(void(*)()) {}

template<typename T>
void call_mem(void(T::*fn)(), T* x) { (x->*fn)(); }

int main() {
    Foo x{};
    call(&foo); // works fine
    call_mem<Foo>(&Foo::foo, &x); // okay, why though
    call(std::bind(std::mem_fn(&Foo::foo), &foo)); // doesnt work and looks horrible + return type of mem_fn is unspecified
    call(std::bind(std::function(&Foo::foo), &foo)); // doesnt work
    // something like this?
    call(&x::foo); // imaginary
    call(&Foo::foo(x)); // imaginary
}

the best I could come up with is this

#include <memory>

void call(Function<void> *fn) { (*fn)(); }

struct Foo {
  void foo() {}
};

void foo() {}

int main(int argc, char **argv) {
  auto x = [] {};

  Foo f{};
  std::unique_ptr<Function<void>> fn0{new Function{&foo}};
  std::unique_ptr<Function<void>> fn1{new MemberFunction{&f, &Foo::foo}};
  std::unique_ptr<Function<void>> fn2{new MemberFunction{x}};

  call(fn0.get());
  call(fn1.get());
  call(fn2.get());
}

using this utility class

#include <type_traits>
#include <utility>

template <typename R, typename... Args>
struct Function {
  using Fn = R (*)(Args...);

  Fn fn;

  explicit Function(Fn fn) : fn{fn} {}

  virtual R operator()(Args... args) noexcept(
      noexcept(fn(std::forward<Args>(args)...))) {
    return fn(std::forward<Args>(args)...);
  }
};

template <typename R, typename... Args>
Function(R (*)(Args...)) -> Function<R, Args...>;

template <typename T, typename = std::void_t<>>
struct MemberFunction;

template <typename T, typename R, typename... Args>
struct MemberFunction<R (T::*)(Args...)> final : Function<R, Args...> {
  using Fn = R (T::*)(Args...);

  T *obj;
  Fn fn;

  MemberFunction(T *obj, Fn fn)
      : Function<R, Args...>{nullptr}, obj{obj}, fn{fn} {}

  R operator()(Args... args) noexcept(
      noexcept((obj->*fn)(std::forward<Args>(args)...))) override {
    return (obj->*fn)(std::forward<Args>(args)...);
  }
};

template <typename T, typename R, typename... Args>
struct MemberFunction<R (T::*)(Args...) const> : Function<R, Args...> {
  using Fn = R (T::*)(Args...) const;

  const T *obj;
  Fn fn;

  MemberFunction(const T *obj, Fn fn)
      : Function<R, Args...>{nullptr}, obj{obj}, fn{fn} {}

  R operator()(Args... args) noexcept(
      noexcept((obj->*fn)(std::forward<Args>(args)...))) final override {
    return (obj->*fn)(std::forward<Args>(args)...);
  }
};

template <typename T>
struct MemberFunction<T, std::void_t<decltype(&T::operator())>> final
    : MemberFunction<decltype(&T::operator())> {
  explicit MemberFunction(const T &obj)
      : MemberFunction<decltype(&T::operator())>{&obj, &T::operator()} {}
};

template <typename T>
MemberFunction(T) -> MemberFunction<T>;

template <typename T, typename R, typename... Args>
MemberFunction(T *, R (T::*)(Args...)) -> MemberFunction<R (T::*)(Args...)>;

template <typename T, typename R, typename... Args>
MemberFunction(const T *, R (T::*)(Args...) const)
    -> MemberFunction<R (T::*)(Args...) const>;

Answer 1

Yes. Use lambda's

class Foo {
public:
    void Bar() const {}
};

#include <functional>

void Baz(std::function<void()> const& fun) {
    fun();
}


int main() {
    Foo foo;

    std::function<void()> fooBar = [&foo]() { foo.Bar(); };

    Baz(fooBar);
}

edit: more reading here

edit 2: using std::bind for this has massive overhead... Just look at this . Lambda's are practically zero cost.

Answer 2

Yes ,

you could use Lambda expressions, that from c++11 have replaced all these binding problem.

See this link for more details: Lambda Expression

Remember that from C++14 the lambda expressions are also polymorphic.