在函数指针类型之间转换

Question

I have a program that has to store functions as void (*) (void*) . Creating functions with that signature leads to code duplication (usually the first line is to cast the void pointer to the correct type) and reduces type safety (the void pointer can be cast to anything, such as the wrong type), so I was wondering if I can take a function of type void (*)(T*) , and then convert it to a void(*)(void*) and call it like that, in a way similar to this:

#include <iostream>
#include <string>

void printer(std::string* string)
{
    std::cout << *string << std::endl;
}

int main() 
{
    //Cast the function to a one that takes a void pointer
    auto func = reinterpret_cast<void(*)(void*)>(&printer);
    //Create a string and call the function with it
    std::string string = "Hello World";
    func(&string);
    return 0;
}

The above code compiles and runs fine (on ideone ) but I was wondering if it's at all standards compliant or if it's undefined behaviour and is just working correctly for my specific example and OS

Answer 1

This is undefined behavior.

[expr.call]/1:

Calling a function through an expression whose function type is different from the function type of the called function's definition results in undefined behavior.

[expr.reinterpret.cast]/6:

A function pointer can be explicitly converted to a function pointer of a different type. Except that converting a prvalue of type "pointer to T1 " to the type "pointer to T2 " (where T1 and T2 are function types) and back to its original type yields the original pointer value, the result of such a pointer conversion is unspecified.

C++ doesn't allow for very many function casts at all to work, even for things you might think would be safe like changing const details. When you need such a thing, use an explicit wrapper function instead. A non-capturing lambda could be one easy way to write one without naming it; or you could define a general template to wrap other functions in a way you need.

[Strangely, C++17 allows an implicit conversion from a pointer to nonthrowing function to a pointer to potentially-throwing function even though C++17 makes those different function types - but then doesn't have any wording I can see saying you're allowed to actually call the function via that converted pointer.]

Answer 2

Behaviour of doing so is undefined. Standard (draft) says:

[expr.reinterpret.cast] A function pointer can be explicitly converted to a function pointer of a different type. [Note: The effect of calling a function through a pointer to a function type (9.2.3.5) that is not the same as the type used in the definition of the function is undefined. — end note] Except that converting a prvalue of type “pointer to T1” to the type “pointer to T2” (where T1 and T2 are function types) and back to its original type yields the original pointer value, the result of such a pointer conversion is unspecified. [Note: See also 7.3.11 for more details of pointer conversions. — end note]

---

You could use a lambda:

void(*func)(void*) = [](void *string) {
    printer(static_cast<std::string*>(string));
};