What's the function signature of a member function?

Question

I'm having trouble understanding function signatures and pointers.

struct myStruct
{
    static void staticFunc(){};
    void nonstaticFunc(){};
};

int main()
{
    void (*p)();     // Pointer to function with signature void();
    p = &myStruct::staticFunc;    // Works fine
    p = &myStruct::nonstaticFunc; // Type mismatch   
}

My compiler says that the type of myStruct::nonstaticFunc() is void (myStruct::*)(), but isn't that the type of a pointer pointing to it?

I'm asking because when you create an std::function object you pass the function signature of the function you want it to point to, like:

std::function<void()> funcPtr;      // Pointer to function with signature void()
not 
std::function<void(*)()> funcPtr;

If I had to guess based on the pattern of void() I would say:

void myStruct::();
or
void (myStruct::)();

But this isn't right. I don't see why I should add an asterisk just because it's nonstatic as opposed to static. In other words, pointer void(* )() points to function with signature void(), and pointer void(myStruct::*)() points to function with signature what?

Answer 1

To me there seems to be a basic misunderstanding of what a member pointer is. For example if you have:

struct P2d {
    double x, y;
};

the member pointer double P2d::*mp = &P2d::x; cannot point to the x coordinate of a specific P2d instance, it is instead a "pointer" to the name x: to get the double you will need to provide the P2d instance you're looking for... for example:

P2d p{10, 20};

printf("%.18g\n", p.*mp); // prints 10

The same applies to member functions... for example:

struct P2d {
    double x, y;
    double len() const {
        return sqrt(x*x + y*y);
    }
};

double (P2d::*f)() const = &P2d::len;

where f is not a pointer to a member function of a specific instance and it needs a this to be called with

printf("%.18g\n", (p.*f)());

f in other words is simply a "selector" of which of the const member functions of class P2d accepting no parameters and returning a double you are interested in. In this specific case (since there is only one member function compatible) such a selector could be stored using zero bits (the only possible value you can set that pointer to is &P2d::len).

Please don't feel ashamed for not understanding member pointers at first. They're indeed sort of "strange" and not many C++ programmers understand them.

To be honest they're also not really that useful: what is needed most often is instead a pointer to a method of a specific instance.

C++11 provides that with std::function wrapper and lambdas:

std::function<double()> g = [&](){ return p.len(); };

printf("%.18g\n", g()); // calls .len() on instance p

Answer 2

std::function<void()> funcPtr = std::bind(&myStruct::nonstaticFunc, obj);

Is how you store a member function in std::function. The member function must be called on a valid object.

---

If you want to delay the passing of an object until later, you can accomplish it like this:

#include <functional>
#include <iostream>

struct A {

    void foo() { std::cout << "A::foo\n"; }
};

int main() {
    using namespace std::placeholders;

    std::function<void(A&)> f = std::bind(&A::foo, _1);

    A a;
    f(a);

    return 0;
}

std::bind will take care of the details for you. std::function still must have the signature of a regular function as it's type parameter. But it can mask a member, if the object is made to appear as a parameter to the function.

---

Addenum:
For assigning into std::function, you don't even need std::bind for late binding of the object, so long as the prototype is correct:

std::function<void(A&)> f = &A::foo;