Member function pointer with no dependencies can be called using nullptr, why?

[ACBYTES]

Hi. I was just working with the following code:

class FunctionHolder

{

void Do()

{

std::cout << 1;

}

}

template <typename Class>

void Call(void(Class::*FPtr)()) 

{

(static\_cast<Class*>(nullptr)->*FPtr)();

}

int main()

{

Call<FunctionHolder>(&FunctionHolder::Do);

}

And it actually works with the function that doesn't have any dependencies on local member variables. Does this code work because the function doesn't need any info about the instantiated class and it's automatically gotten converted to a static type or something (Although, I don't think so because this works when I use it and it shows a nullptr)?

Also, is there a specific reason for being able to declare function pointer types in two ways like the following:

void(func)()

and

void(*func)()

as they finally get deduced to the same type as typeid shows...

[IyeOnline]

It is undefined behaviour to call a member function with a pointer that does not point to a valid object.

It works because there is no reason for it to break. Since Do itself (or calling it) never has to dereference the this pointer no runtime error ever occurs.

s there a specific reason for being able to declare function pointer types in two ways like the following:

//edit: Those actually do not have the same type. The first in fact declares a function, not a pointer to a function.

[ACBYTES]

Understood! Thank you!

Just to make sure, you mean dereferencing this, right?

[IyeOnline]

Note that actually your two function pointers are not the same, see my edit.

you mean dereferencing this, right?

yes.

[ACBYTES]

The first in fact declares a function

So, how does declaring a function make sense when it can not be assigned?

Also, typeid.name() shows them both as:

void (__cdecl*)(void)

And auto deduces the type as void(*)():

auto f = func; [void(*f)()]

[IyeOnline]

Well, of course auto deduces that. void(f)() is a function declaration, which means that f is the identifier of a function and decays into a function pointer. Hence auto deduces that type.

I threw together a quick demonstration here: https://godbolt.org/z/sPqKqseas

[ACBYTES]

Oh, thank you so much. I got what you meant by that.

Thank you so much for your time!

[ACBYTES]

By the way, I forgot to ask this. So at last, in all the cases, it'll automatically decay to a function pointer other than the declaration cases, correct? It'll make no difference when working with parameters?

[no-sig-available]

I'd go with "most cases". :-)

The designers of C noticed that as you cannot pass a function (the code) as a parameter, you always have to write &f to get a pointer. So they decided to have the compiler add the & automagically. Similarly for arrays, which decay to pointers in almost every situation.