How std::bind(&T::memberFunc, this) can always bind to std::function regardless of what T is?

Question

As far as I know, the member function pointer only can be assigned to the pointer to member function type, and converted to any other except this will violate the standard, right?

And when calling std::bind(&T::memberFunc, this), it should return a dependent type which depend on T.(in std of VC++ version, it's a class template called _Binder).

So the question becomes to why one std::funcion can cover all _Binder(VC++ version) types.

class A
{
public:
    void func(){}
};
class B
{
public:
    void func(){}
};

std::function<void(void)> f[2];

A a;
B b;
f[0] = std::bind(&A::func, &a);
f[1] = std::bind(&B::func, &b);

And I can't picture what type of the member of std::funcion which stored the function would be like, unless I am wrong from the first beginning.

This question only covered the member function need to be called with it's instance.

But mine is about why one std::function type can hold all T types.

Aren't your bindings equivalent to something like `void f0() { return a.func(); }` and `void f1() { return b.func(); }`? — Jean-Baptiste Yunès, Mar 20 '18 at 06:55
No. And `return a.func();`? What's this?@Jean-BaptisteYunès — Francis, Mar 20 '18 at 07:10
@francis, have you seen this [explanation](https://stackoverflow.com/questions/37636373/how-stdbind-works-with-member-functions)? — Smit Ycyken, Mar 20 '18 at 08:55
Possible duplicate of [How std::bind works with member functions](https://stackoverflow.com/questions/37636373/how-stdbind-works-with-member-functions) — Smit Ycyken, Mar 20 '18 at 08:57
I think it's probably an application of **type erasure**. Please leave me an answer.@T.C. — Francis, Mar 21 '18 at 03:15

score 3 · Answer 1 · answered Mar 20 '18 at 06:56

3

In short what is happening is that std::bind(&A::func, &a) returns an object of a class similar to

class InternalClass
{
    A* a_;  // Will be initialized to &a
public:
    void operator()(void)
    {
        a_->func();
    }
};

_{[Note that this is highly simplified]}

The callable operator() function is what is matches the void(void) signature of the std::function<void(void)>.

answered Mar 20 '18 at 06:56

Some programmer dude

400,186
35
402
621

Still confused. The `InternalClass` is still a dependent type, isn't it? Can you be more specific? – Francis Mar 20 '18 at 07:29
@francis What does your binding do? Idea is to bind a call to member func on object a (and object b), isn't it? Then what is the signature of a call of member `func`on `a`? A function that takes no parameter and return nothing void f(). – Jean-Baptiste Yunès Mar 20 '18 at 16:30
Yes, they are equal things. But, `f0` and `f1` are different things. Then, `std::function` covers both of them magically. i.e. `std::function` covers `InternalClass` and `InternalClass`. That's what I try to understand.@Jean-BaptisteYunès – Francis Mar 21 '18 at 03:27
@francis `std::function` only cares about the callable function and its signature. – Some programmer dude Mar 21 '18 at 03:31
But `A::func` and `B::func` have different signatures, right?@Someprogrammerdude – Francis Mar 21 '18 at 03:36

score 0 · Accepted Answer · answered May 08 '19 at 09:40

I think the implementation would probably like this:

template</*...*/>
class std::bind</*...*/>
{
public:
    std::bind(callable_t call, param_t p)
    {
    _func = [call, p]()/* using lambda to capture all data for future calling */
    {
    p->call();
    };

}
operator std::function<void(void)>()
{

    return _func;

}
private:
std::function<void(void)> _func;
};

And lambda is the key.

How std::bind(&T::memberFunc, this) can always bind to std::function regardless of what T is?

2 Answers2