Function pointers casting in C++

Question

I have a void pointer returned by dlsym(), I want to call the function pointed by the void pointer. So I do a type conversion by casting:

void *gptr = dlsym(some symbol..) ;
typedef void (*fptr)();
fptr my_fptr = static_cast<fptr>(gptr) ;

I have also tried reinterpret_cast but no luck, although the C cast operator seems to work..

I think that conversion pointer to function into void* was originally a bad idea. Is that problem to return pointer to function from dlsym? — Kirill V. Lyadvinsky, Jul 08 '09 at 07:09

score 64 · Accepted Answer · edited Oct 03 '19 at 01:35

Converting a void* to a function pointer directly is not allowed (should not compile using any of the casts) in C++98/03. It is conditionally supported in C++0x (an implementation may choose to define the behavior and if it does define it, then it must do what the standard says it should do. A void*, as defined by the C++98/03 standard, was meant to point to objects and not to contain function pointers or member pointers.

Knowing that what you are doing is heavily implementation dependent, here is one option that should compile and work (assuming 32 bit pointers, use long long for 64 bit) on most platforms, even though it is clearly undefined behavior according to the standard:

void *gptr = dlsym(some symbol..) ;
typedef void (*fptr)();
fptr my_fptr = reinterpret_cast<fptr>(reinterpret_cast<long>(gptr)) ;

And here is another option that should compile and work, but carries the same caveats with it as the above:

fptr my_ptr = 0;
reinterpret_cast<void*&>(my_ptr) = gptr;

Or, in Slow motion...

// get the address which is an object pointer
void (**object_ptr)() = &my_ptr;  

// convert it to void** which is also an object pointer
void ** ppv = reinterpret_cast<void**>(object_ptr);

// assign the address in the memory cell named by 'gptr' 
// to the memory cell that is named by 'my_ptr' which is
// the same memory cell that is pointed to 
// by the memory cell that is named by 'ppv'
*ppv = gptr;

It essentially exploits the fact that the address of the function pointer is an object pointer (void (**object_ptr)()) - so we can use reinterpret_cast to convert it to any other object pointer: such as void**. We can then follow the address back (by dereferencing the void**) to the actual function pointer and store the value of the gptr there.

yuk - by no means well-defined code - but it should do what you expect it to do on most implementations.

I expect this is it - the C++ casting is being standard-compliant, the C casting is being backward compatible with the requirements of the POSIX shared library calls. — Daniel Earwicker, Jul 08 '09 at 06:16
Even the C style explicit cast is not required to do the conversion or even compile - the C style cast is defined in terms of the other casts (with one minor additional feature regarding base class accessibility). — Faisal Vali, Jul 08 '09 at 06:25
As a side note, a better choice of a type to use in an intermediate cast might be `size_t` - it is usually large enough to fit a pointer on any platform, even though that isn't guaranteed either. Better yet, use ``/`` header and `intptr_t` typedef in it where it's available (C99, C++TR1, C++0x). — Pavel Minaev, Jul 08 '09 at 07:02
The "conditionally supported" wording was in fact invented with dlsym() behavior in mind - around 2001 it was noticed that real C++ compilers for POSIXy systems all accepted this cast. — MSalters, Jul 08 '09 at 08:01
@MSalters - thanks for the background :) - here's the link to the DR that might have started it all: http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#195 — Faisal Vali, Jul 08 '09 at 16:50
If you want a more portable way, you can always write a wrapper around that specific `dlsym` in C which does return a function pointer and call that wrapper from C++. — , Feb 20 '12 at 11:28

score 20 · Answer 2 · edited May 23 '17 at 12:34

Note that C++11 allows such a conversion and from gcc 4.9 and above this conversion does not generate a warning: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57869.

See SO discussions:

score 2 · Answer 3 · edited Sep 30 '22 at 00:13

Well, if you know what the argument list is, it's extremely simple to just c-cast it. As stated above, it has undefined behavior, but I've been using this in my own events handler for a pet project and it seems to work just fine on MSVC.

I can cast the same void* to _beginthread_proc_type to start a thread with _beginthread(), and that also doesn't seem to cause any issues (though I don't really know what the consequences of sending arguments to a function that doesn't require any, or not sending arguments to functions that do require arguments will do, that does seem to at least call the function/start the thread in my limited testing):

void somefunction(){
    std::cout <<"hi"<<std::endl;
}

void* function = (void*)&somefunction;
((void(__cdecl*)(void))(function)) ();

_beginthread((_beginthread_proc_type)function, 0, NULL);

I know the community has developed a hatred for macros, but I use a macro for that function call in my events handler:

#define call_voidstar_function(fc)     ((void(__cdecl*)(void))(fc)) ()

score 1 · Answer 4 · answered Jun 11 '15 at 19:02

1

I found this (a bit ugly) solution. gcc with maximum warning level does not complain. This example calls dlsym() (that returns a void*) and returns the result in a function pointer.

typedef void (*FUNPTR)();

FUNPTR fun_dlsym(void* handle, const char* name) {
    union {
        void* ptr;
        FUNPTR fptr;
    } u;
    u.ptr = dlsym(handle, name);
    return u.fptr;
}

answered Jun 11 '15 at 19:02

BrunoLevy

2,495
17
30

1

That works if the compilation unit is C but not C++11 & later as it's undefined behaviour: http://stackoverflow.com/questions/11373203/accessing-inactive-union-member-undefined-behavior – Vitali Sep 14 '16 at 18:33

score 1 · Answer 5 · answered Nov 20 '11 at 01:51

1

This compiles in Visual Studio without using reinterpret cast:

void *ptr;
int (*func)(void) = (int(*)(void))ptr;
int num = func();

answered Nov 20 '11 at 01:51

Andrew Best

51
1

3

Might compile, but **will** result in undefined behavior (as described by the C specs.) – luis.espinal Sep 17 '12 at 19:11
2

Is that really without `reinterpret_cast`? Which cast will the compiler choose? – Janusz Lenar May 27 '13 at 11:24
10

You're doing a c-style cast, which is effectively a reinterpret cast in this case. – WestleyArgentum Mar 24 '15 at 17:00

score 0 · Answer 6 · answered Aug 08 '18 at 21:45

0

One might use the following technique:

int (*fn)(int);
*(void **)(&fn) = dlsym(lib1, "function");
int result = (*fn)(3);

Or

fn = (int (*)(int))dlsym(lib1, "function");

Compiled with:

g++ -Wall -pedantic -std=c++11

answered Aug 08 '18 at 21:45

Yuriy Vasylenko

3,031
25
25

Elviss Strazdins · Answer 7 · 2019-06-17T10:43:18.253

You can cast dlsym to a function that returns the required pointer and then call it like this:

typedef void (*fptr)();
fptr my_fptr = reinterpret_cast<fptr (*)(void*, const char*)>(dlsym)(RTLD_DEFAULT, name);

PS. Casting a function pointer to a different function pointer and then calling it is undefined behavior (see point 7 in https://en.cppreference.com/w/cpp/language/reinterpret_cast) so it is better to cast the result of dlsym to uintptr_t and then to the required type:

fptr my_fptr = reinterpret_cast<fptr>(reinterpret_cast<uintptr_t>(dlsym(RTLD_DEFAULT, name)));

Ryan Oberoi · Answer 8 · 2009-07-08T06:22:17.667

-3

This may help you. It prints "Hello".

#include <iostream>

void hello()
{
  std::cout << "Hello" << std::endl;
}

int main() {
  typedef void (*fptr)();
  fptr gptr = (fptr) (void *) &hello;
  gptr();
}

OR you can do:

fptr gptr = reinterpret_cast<fptr>( (void *) &hello);

where &hello is replaced by the dlsym command.

edited Jul 08 '09 at 06:22

answered Jul 08 '09 at 06:15

Ryan Oberoi

13,817
2
24
23

2

I'm gonna be *amazed* if that's helpful! – Daniel Earwicker Jul 08 '09 at 06:17
The reason that's working is because you're not going via a `void *` pointer. – Daniel Earwicker Jul 08 '09 at 06:19
1

After the edit he is, right? And the code seems to work. (Though I'm no expert, so maybe this happens to work, but is actually undefined?) – Mike Oct 15 '13 at 12:34

Function pointers casting in C++

8 Answers8

Linked

Related