C puntero de función de conversión para anular puntero

Question

Estoy tratando de ejecutar el programa siguiente, pero conseguir algunos errores extraños: 1.c

del archivo:

typedef unsigned long (*FN_GET_VAL)(void); 

FN_GET_VAL gfnPtr; 

void setCallback(const void *fnPointer) 
{ 
    gfnPtr = *((FN_GET_VAL*) (&fnPointer)); 
} 

2.c del archivo:

extern FN_GET_VAL gfnPtr; 

unsigned long myfunc(void) 
{ 
    return 0; 
} 

main() 
{ 
    setCallback((void*)myfunc); 
    gfnPtr(); /* Crashing as value was not properly 
       assigned in setCallback function */ 
} 

Aquí el gfnPtr() se cuelga en suse linux de 64 bits cuando se compila con gcc. Pero está llamando con éxito a gfnPtr() VC6 y SunOS.

Pero si cambio la función como se indica a continuación, está funcionando correctamente.

void setCallback(const void *fnPointer) 
{ 
    int i; // put any statement here 
    gfnPtr = *((FN_GET_VAL*) (&fnPointer)); 
} 

Ayuda con la causa del problema. Gracias.

Answer 1

La norma no permite emitir punteros a void*. Solo puede convertir a otro tipo de puntero a función. 6.3.2.3 § 8:

Un puntero a una función de un tipo se puede convertir en un puntero a una función de otro tipo y de vuelta otra vez

Es importante destacar, que debe emitir la espalda al tipo original antes de usar el puntero para llamar a la función (técnicamente, a un tipo compatible. Definición de "compatible" en 6.2.7).

Answer 2

Tengo tres reglas de oro cuando se trata de punteros de datos y punteros de código:

• No no mezcla punteros de datos y punteros de código
• No mezcla punteros de datos y el código punteros
• No siempre ¡punteros de datos de mezcla y punteros de código!

En la siguiente función:

void setCallback(const void *fnPointer) 
{ 
    gfnPtr = *((FN_GET_VAL*) (&fnPointer)); 
} 

Usted tiene un puntero de datos que causa a un puntero de función. (Sin mencionar que usted hace esto tomando primero la dirección del puntero en sí, colóquelo en un puntero a un puntero, antes de quitarle la referencia).

Trate de reescribir como:

void setCallback(FN_GET_VAL fnPointer) 
{ 
    gfnPtr = fnPointer; 
} 

Además, puede (o debe) dejar caer el molde cuando se ajusta el puntero:

main() 
{ 
    setCallback(myfunc); 
    gfnPtr(); 
} 

Como un bono extra, puede ahora utilizar el verificaciones de tipo normales realizadas por el compilador.

Answer 3

Sugeriré una posible explicación parcial.

@Manoj Si examina (o puede proporcionar) la lista de ensamblaje para SetCallback generada por ambos compiladores, podemos obtener una respuesta definitiva.

En primer lugar, las declaraciones de Pascal Couq son correctas, y Lindydancer muestra cómo configurar correctamente la devolución de llamada. Mi respuesta es solo un intento de explicar el problema real.

Creo que el problema radica en el hecho de que Linux y la otra plataforma usan diferentes modelos de 64 bits (ver 64-bit models on Wikipedia). Tenga en cuenta que Linux usa LP64 (int es 32 bit). Necesitamos más detalles sobre la otra plataforma. Si es SPARC64, usa ILP64 (int es 64 bit).

Según tengo entendido, el problema solo se observó en Linux y desapareció si introdujo una variable local int. ¿Intentó esto con las optimizaciones de vez en cuando? Lo más probable es que este truco no tenga ningún efecto beneficioso con optimizaciones.

En ambos modelos de 64 bits, los punteros deben ser de 64 bits, independientemente de si apuntan a código o datos. Sin embargo, es posible que este no sea el caso (por ejemplo, modelos de memoria segmentada); de ahí, las advertencias de Pascal y Lindydancer.

Si los punteros son del mismo tamaño, lo que queda es un posible problema de alineación de pila. La introducción de un int local (que es de 32 bits en Linux) podría alterar la alineación. Esto solo tendría un efecto si void * y los punteros de función tienen diferentes requisitos de alineación. Un escenario dudoso.

Sin embargo, es probable que los diferentes modelos de memoria de 64 bits sean la causa de lo que usted observó. Le invitamos a proporcionar los listados de ensamblaje para que podamos analizarlos.

Answer 4

Desafortunadamente, la norma no permite el fundido entre los punteros de datos y los punteros a las funciones (porque puede que no tenga sentido en algunas plataformas realmente oscuras), aunque POSIX y otros requieren tales conversiones. Una solución no es lanzar el puntero sino lanzar un puntero al puntero (esto está bien para el compilador y hará el trabajo en todas las plataformas normales).

typedef void (*FPtr)(void); // Hide the ugliness 
FPtr f = someFunc;   // Function pointer to convert 
void* ptr = *(void**)(&f); // Data pointer 
FPtr f2 = *(FPtr*)(&ptr); // Function pointer restored 

Answer 5

a diferencia de lo que otros dicen, sí se puede tener un puntero void* como un puntero de función, pero la semántica es muy difícil de usar con ella.

Como puede ver, NO NECESITA usarlo como void*, simplemente asígnelo como lo hace normalmente. Ejecuté su código así y lo edité para que funcione.

Archivo1.c:

typedef unsigned long (*FN_GET_VAL)(void); 

extern FN_GET_VAL gfnPtr; 

void setCallback(const void *fnPointer) 
{ 
    gfnPtr = ((FN_GET_VAL) fnPointer); 
} 

Archivo2.c:

int main(void) 
{ 
    setCallback(myfunc); 
    ((unsigned long(*)(void))gfnPtr)(); 
}