Question

Yesterday I was doing some research on dynamic loading of shared objects and about getting pointers to functions.

I have been told many times that sharing pointers to functions through void pointers is forbidden by the ISO C++ standard and is still and issue to resolve.

After reading Johan Petterson’s artitle “about the problem with dlsym” I understand better the reasons, and I also understand that being forbidden by the standard does not mean you absolutely must not use it. Otherwise, how do all C++ programmers work with functions from shared objects with correct ISO C++ code? Just guessing, I might be wrong, I am not very expert in C++.

While experimenting with my code, I found that by sharing a pointer to a struct which contains a reference to the function I want to invoke, my compiler will not complain. I use -Wall and -pedantic while compiling.

My code looks as follows:

myclass.hpp

class myclass
{
    public:
    virtual void dosomething (void)=0;
}

api.hpp

#include <myclass.hpp>
struct API
{
    myclass* (* func)(void);
};

so.hpp

#include <iostream>
#include "myclass.cpp"
#include "api.hpp"

class childclass : public myclass
{
    void dosomething (void)
    {
        std::cout << "Did it.\n";
    }
}

/* function to return a new instance of childclass */

extern "C" myclass* make (void)
{
    return new childclass;
}

/* struct that contains a pointer to the function */

extern "C" API interface;
API interface
{
    make
};

host.cpp

#include <iostream>
#include <dlfcn.h>
#include "myclass.hpp"
#include "api.hpp"
int main (void)
{
    void * th = dlopen("./so.so", RTLD_LAZY);
    /* error checking was here */

    #ifndef usefunction

        API* api = static_cast<API*>( dlsym(th, "interface") );
        myclass * inst = api->make();
        inst->dosomething();

    #else

        myclass* (*func)(void) = reinterpret_cast<myclass* (*)(void)>( dlsym(th, "make") );
        /* will never get to this point */

    #endif

    return 0;
}

Having already compiled so.so, I then compile my host.cpp file.

g++ -ldl -Wall -pedantic host.cpp -o host
Compiles fine, program correcly prints Did it. when run.

g++ -ldl -Wall -pedantic host.cpp -o host -Dusefunction
Complains

In function ‘int main(int, char**)’:
warning: ISO C++ forbids casting between pointer-to-function
and pointer-to-object [enabled by default]

I know it is just a warning, but why is not the warning print in the first case, when using the struct, if in the end I am indirectly being able to reference a pointer to a function that resides in a shared object?

Speaking of which, anybody knows a way to achieve all this in a totally correct ISO C++ manner? Does it even exist?

Answer 1

If you have your function pointer wrapped in a struct, then you are getting around the problem by adding an extra level of indirection. Imagine if a function pointer took 10 bytes, but an object pointer took four bytes. Your struct would be at least 10 bytes, and you would have a 4-byte pointer to that. This is all perfectly fine. When you access the struct to get to your function pointer, you pull out the full 10 bytes. Nothing is lost. However, if you were to cast the 10-byte function pointer to a 4-byte object pointer, you would necessarily lose 6 bytes of information.

This isn’t an actual problem here, since platforms that support dlsym must have void pointers that are large enough to store the address of a function pointer, but the compiler is trying to prevent you from writing non-portable code.