tipos - Función de punteros de casting en C++

funciones en c++ ejemplos

Question

Tengo un puntero void devuelto por dlsym (), quiero llamar a la función apuntada por el puntero void. Así que hago una conversión de tipo mediante conversión:

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

También probé reinterpret_cast pero no tuve suerte, aunque el operador de elenco de C parece funcionar.

Answer 1

Encontré esta solución (un poco fea). gcc con nivel de advertencia máximo no se queja. Este ejemplo llama a dlsym () (que devuelve un vacío *) y devuelve el resultado en un puntero a función.

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 2

Esto puede ayudarte. Imprime "Hola".

#include <iostream>

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

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

O puedes hacer:

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

donde & hello es reemplazado por el comando dlsym.

Answer 3

Esto se compila en Visual Studio sin usar reinterpret cast:

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

Answer 4

La conversión de un void* a un puntero de función directamente no está permitida (no debe compilarse usando ninguno de los casts) en C ++ 98/03. Se admite de forma condicional en C ++ 0x (una implementación puede elegir definir el comportamiento y si lo define, entonces debe hacer lo que la norma dice que debe hacer. Un void* , como lo define C ++ 98/03 estándar, estaba destinado a apuntar a objetos y no a contener punteros de función o punteros de miembro.

Sabiendo que lo que está haciendo depende en gran medida de la implementación, aquí hay una opción que debe compilar y trabajar (suponiendo que los punteros de 32 bits usen mucho tiempo para 64 bits) en la mayoría de las plataformas, aunque es claramente un comportamiento indefinido de acuerdo con el estándar:

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

Y aquí hay otra opción que debería compilar y trabajar, pero conlleva las mismas advertencias que la anterior:

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

O, en cámara lenta ...

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

Básicamente, explota el hecho de que la dirección del puntero de función es un puntero de objeto [void (*(*object_ptr))()] , por lo que podemos usar reinterpret_cast para convertirlo en cualquier otro puntero de objeto: como void** . Luego podemos seguir la dirección de regreso (al eliminar la referencia al vacío **) al puntero de la función real y almacenar el valor de la gptr allí.

yuk: no es un código bien definido, pero debe hacer lo que usted espera que haga en la mayoría de las implementaciones.

Answer 5

Se podría utilizar la siguiente técnica:

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

O

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

Compilado con

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

Answer 6

Tenga en cuenta que C ++ 11 permite dicha conversión y desde gcc 4.9 y por encima de esta conversión no se genera una advertencia: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57869 .

Ver las discusiones SO:

• Castes entre puntero a función y puntero a objeto en C y C ++
• ¿Por qué los punteros de función y los punteros de datos son incompatibles en C / C ++?
• ¿Se puede utilizar void * para almacenar punteros de función?
• Usando reinterpret_cast para convertir una función en void *, ¿por qué no es ilegal?