Les pointeurs de fonction coulent en C++

Question

J'ai un pointeur vide retourné par dlsym(), je veux appeler la fonction pointée par le pointeur vide. donc je fais une conversion de type par coulée:

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

J'ai aussi essayé reinterpret_cast mais pas de chance, bien que l'opérateur de cast C semble fonctionner ..

Answer 1

Conversion d'un void* à un pointeur de fonction directement n'est pas autorisé (ne devrait pas compiler en utilisant l'un des moulages) en C++ 98/03. Il est supporté sous condition en C++ 0x (une implémentation peut choisir de définir le comportement et si elle le définit, elle doit faire ce que la norme dit qu'elle devrait faire.) void*, comme défini par la norme C++ 98/03 Nous voulions pointer vers des objets et ne pas contenir de pointeurs de fonction ou de membres

Sachant que ce que vous faites est fortement dépendant de l'implémentation, voici une option qui devrait compiler et fonctionner (en supposant que les pointeurs 32 bits, utilisent long long 64 bits) sur la plupart des plates-formes, même si ce comportement est clairement définie selon la norme:

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

et est une autre option ici qui devrait compiler et le travail, mais carr s les mêmes mises en garde avec elle comme ci-dessus:

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

Ou, en mouvement lent ...

// 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; 

Il exploite essentiellement le fait que l'adresse du pointeur de fonction est un pointeur d'objet [void (*(*object_ptr))()] - nous pouvons donc utiliser reinterpret_cast pour le convertir en n'importe quel autre pointeur d'objet: tel que void**. Nous pouvons ensuite suivre l'adresse (en déréférenciant le vide **) au pointeur de fonction réel et y stocker la valeur du gptr. Yu - en aucun cas un code bien défini - mais il devrait faire ce que vous attendez de lui pour la plupart des implémentations.

Answer 2

Cela peut vous aider. Il imprime "Bonjour".

#include <iostream> 

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

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

OU vous pouvez faire:

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

où & bonjour est remplacé par la commande dlsym.

Answer 3

Cette compile dans Visual Studio sans utiliser réinterprètent cast:

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

Answer 4

Je trouve cela (un peu laid) solution. Gcc avec le niveau d'avertissement maximum ne se plaint pas. Cet exemple appelle dlsym() (qui renvoie un void *) et renvoie le résultat dans un pointeur de fonction.

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; 
} 

Answer 5

Notez que C++ 11 permet une telle conversion et de gcc 4.9 et au-dessus de cette conversion ne génère pas d'avertissement: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57869.

Voir SO discussions:

• Casts between pointer-to-function and pointer-to-object in C and C++
• Why are function pointers and data pointers incompatible in C/C++?
• can void* be used to store function pointers?
• Using reinterpret_cast to cast a function to void*, why isn't it illegal?