L'assegnazione del puntatore funzione funziona in C ma non in C++

Question

Ho bisogno di collegarmi dinamicamente ad una funzione di libreria in fase di esecuzione in Mac OS X. Seguendo Apple's example, dichiaro un puntatore a funzione e lo assegno con il risultato di dlsym(). Il seguente esempio si compila correttamente come un semplice file C (.c). Ma ho bisogno di questo in un file C++, e se compilo questo esempio come C++ di file (cpp), il compilatore clang mi dice

Impossibile inizializzare una variabile di tipo 'void () (char *)' con un valore di tipo 'void '

Perché funziona in semplice 'C' e come posso risolvere questo problema?

#include <dlfcn.h> 

void Test() { 
    // Load the library which defines myFunc 
    void* lib_handle = dlopen("myLib.dylib", RTLD_LOCAL|RTLD_LAZY); 

    // The following line is an error if compiled as C++ 
    void (*myFunc)(char*) = dlsym(lib_handle, "myFunc"); 

    myFunc("Hello"); 

    dlclose(lib_handle) ; 
} 

Answer 1

dlsym rendimenti void*. In POSIX (ma non C standard, come fa notare James) c'è una conversione implicita da void* a un tipo puntatore-a-funzione, quindi l'assegnazione a myFunc funziona. In C++ non v'è alcuna conversione implicita (perché non è il tipo di sicurezza), quindi è necessario dire al compilatore che realmente significa che con l'aggiunta di un cast:

void (*myFunc)(char*) = (void(*)(char*))dlsym(lib_handle, "myFunc"); 

(o si può ottenere fantasia con un reinterpret_cast).

Answer 2

Perché il compilatore C è danneggiato. Nessuna conversione (esplicita o implicita) tra void* e un puntatore alla funzione , né in C né in C++.

Posix aggiunge una restrizione a C, e richiede che void* e puntatori a funzioni hanno la stessa dimensione e la rappresentazione, in modo che :

void (*myFunc)(char *); 
*(void (**myFunc)(char*))(&myFunc) = dlsym(...); 

funzionerà.

In C++, si potrebbe desiderare di usare qualcosa come:

class GetFunctionHelper; 
GetFunctionHelper getFunction(void* dlHandle, std::string const& functionName); 

class GetFunctionHelper 
{ 
    void* fromSystem; 
    freind GetFunctionHelper getFunction(void* , std::string const&); 
    GetFunctionHelper(void* fromSystem) : fromSystem(fromSystem) {} 
public: 
    template <typename Ptr> operator Ptr() const 
    { 
     return *reinterpret_cast<Ptr const*>(&fromSystem); 
    } 
}; 

GetFunctionHelper 
getFunction(void* dlHandle, std::string const& functionName) 
{ 
    return GetFunctionHelper(dlsym(dlHandle, functionName.c_str())); 
} 

(con un controllo degli errori po 'di più, naturalmente).