将成员函数指针作为参数发送到另一个成员函数中

Question

I want to send a member function as a parameter, but it won't compile. Why doesn't the code work? Here what I have written. If I pass a lambda instead it works though.

void global_func(std::function<void(void)>f)
{
    f();
}

class goo
{
public:
    goo() { }

    void func1()
    {
        std::function<void(void)> fp = &goo::func2;  // get a pointer to the function func2 . Error here or next line

        global_func( fp);
    }

    void func2(void)
    {

    }

};


void main()
{
    goo g1;
    g1.func1();

}

Here the compiler output ( my program name is tryvector.cpp)

1>------ Build started: Project: TryVector, Configuration: Debug Win32 ------
1>  TryVector.cpp
1>e:\program files\microsoft visual studio 12.0\vc\include\functional(506): error C2664: 'void std::_Func_class<_Ret,>::_Set(std::_Func_base<_Ret,> *)' : cannot convert argument 1 from '_Myimpl *' to 'std::_Func_base<_Ret,> *'
1>          with
1>          [
1>              _Ret=void
1>          ]
1>          Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
1>          e:\program files\microsoft visual studio 12.0\vc\include\functional(442) : see reference to function template instantiation 'void std::_Func_class<_Ret,>::_Do_alloc<_Myimpl,_Fret(__thiscall goo::* const &)(void),_Alloc>(_Fty,_Alloc)' being compiled
1>          with
1>          [
1>              _Ret=void
1>  ,            _Fret=void
1>  ,            _Alloc=std::allocator<std::_Func_class<void,>>
1>  ,            _Fty=void (__thiscall goo::* const &)(void)
1>          ]
1>          e:\program files\microsoft visual studio 12.0\vc\include\functional(442) : see reference to function template instantiation 'void std::_Func_class<_Ret,>::_Do_alloc<_Myimpl,_Fret(__thiscall goo::* const &)(void),_Alloc>(_Fty,_Alloc)' being compiled
1>          with
1>          [
1>              _Ret=void
1>  ,            _Fret=void
1>  ,            _Alloc=std::allocator<std::_Func_class<void,>>
1>  ,            _Fty=void (__thiscall goo::* const &)(void)
1>          ]
1>          e:\program files\microsoft visual studio 12.0\vc\include\functional(442) : see reference to function template instantiation 'void std::_Func_class<_Ret,>::_Reset_alloc<_Fret,goo,,std::allocator<std::_Func_class<_Ret,>>>(_Fret (__thiscall goo::* const )(void),_Alloc)' being compiled
1>          with
1>          [
1>              _Ret=void
1>  ,            _Fret=void
1>  ,            _Alloc=std::allocator<std::_Func_class<void,>>
1>          ]
1>          e:\program files\microsoft visual studio 12.0\vc\include\functional(442) : see reference to function template instantiation 'void std::_Func_class<_Ret,>::_Reset_alloc<_Fret,goo,,std::allocator<std::_Func_class<_Ret,>>>(_Fret (__thiscall goo::* const )(void),_Alloc)' being compiled
1>          with
1>          [
1>              _Ret=void
1>  ,            _Fret=void
1>  ,            _Alloc=std::allocator<std::_Func_class<void,>>
1>          ]
1>          e:\program files\microsoft visual studio 12.0\vc\include\functional(671) : see reference to function template instantiation 'void std::_Func_class<_Ret,>::_Reset<void,goo,>(_Fret (__thiscall goo::* const )(void))' being compiled
1>          with
1>          [
1>              _Ret=void
1>  ,            _Fret=void
1>          ]
1>          e:\program files\microsoft visual studio 12.0\vc\include\functional(671) : see reference to function template instantiation 'void std::_Func_class<_Ret,>::_Reset<void,goo,>(_Fret (__thiscall goo::* const )(void))' being compiled
1>          with
1>          [
1>              _Ret=void
1>  ,            _Fret=void
1>          ]
1>          d:\vc++ my files\tryvector\tryvector\tryvector.cpp(42) : see reference to function template instantiation 'std::function<void (void)>::function<void(__thiscall goo::* )(void)>(_Fx &&)' being compiled
1>          with
1>          [
1>              _Fx=void (__thiscall goo::* )(void)
1>          ]
1>          d:\vc++ my files\tryvector\tryvector\tryvector.cpp(42) : see reference to function template instantiation 'std::function<void (void)>::function<void(__thiscall goo::* )(void)>(_Fx &&)' being compiled
1>          with
1>          [
1>              _Fx=void (__thiscall goo::* )(void)
1>          ]
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

Answer 1

A std::function<void(void)> is something which can just be called, without any parameters and without any further context.

goo:func2 , however, is a non-static member function. It cannot just be called; it needs a goo instance . It's as if it had an invisible parameter: void func2(goo* const this) . And that makes sense, because func2 probably needs some other non-static goo members to do its job.

You have several options:

• Use a lambda to capture this , ie: auto const fp = [this] { func2(); }; auto const fp = [this] { func2(); }; . Remember, this is equal to auto const fp = [this] { this->func2(); }; auto const fp = [this] { this->func2(); }; .
• If func2 doesn't need any non-static members of goo , then make the function static .
• Use std::bind .

Answer 2

A member function pointer cannot be wrapped into a std::function<void(void)> because the member function has an implicit argument: The pointer this . But the function wrapper you have defined only takes nullary callables.

Solution 1: Change the function wrapper to std::function<void(goo*)> . This will require you to modify global_func as well to pass the argument.

Solution 2: Use std::bind to generate a functor where the implicit pointer is bound to some instance.

Answer 3

It's because the member function does not have a matching signature. It also contains implicit this . You can make your example by binding the member function and this :

#include <functional>

void global_func(std::function<void(void)>f)
{
    f();
}

class goo
{
public:
    goo() { }
    void func1()
    {
        std::function<void(void)> fp = std::bind(&goo::func2, this);
        global_func( fp);
    }

    void func2(void) { }
};

int main()
{
    goo g1;
    g1.func1();
}

Lambda works, because it can capture this .

Static function also would work, because it doesn't have implicit this parameter.

Basically you need an instance on which behalf you call the functions, so in your case this seems reasonable.

Answer 4

Member functions have an implicit this parameter as their first parameter.

goo::func2(void)

is actually

goo::func2(goo* const this);

You can do one of two things:

Change the signature of global_func to accept a type of std::function<void(goo*)>

Use std::bind to bind the this parameter.

std::function<void(void)> fp = std::bind(&goo::func2, this);
global_func(fp);

Answer 5

Your need either to make func2 a static class member function, or bind it to this when you convert it to a std::function :

 std::function<void()> fp = std::bind(&goo::func2, this);

---

Some more -- There are a few other unusual constructs in your code. Although they work, but they are not good C++ practice:

void func2(void)

this is C Style, in C++ you just write void func2() . Also:

void global_func(std::function<void()>f) // <-- not void(void)

Finally, int main() not void main()

Answer 6

Because a non static member function is not a function. In common implementations, it includes a hidden pointer to the object on which it acts ( this ).

Only static methods can be used the same as functions.