punteros de funciones de fundición con diferentes tipos de punteros como un argumento

Question

El siguiente código, creo, describe lo que estoy tratando de hacer. Específicamente, deseo convertir un puntero de función en un tipo de función genérico, con la única diferencia en la firma de diferentes tipos de puntero.

Ahora, soy consciente de que no es un requisito para los punteros de función para ser compatibles como se discute en this question, pero no estoy seguro de si tienen un argumento de diferentes satisface tipo puntero que requisito de compatibilidad.

El código se compila y se ejecuta, pero, como se espera, proporciona advertencias sobre la asignación desde un tipo de puntero incompatible. ¿Hay alguna manera de satisfacer al compilador y lograr lo que busco?

#include <stdio.h> 

int float_function(float *array, int length) 
{ 
    int i; 
    for(i=0; i<length; i++){ 
     printf("%f\n", array[i]); 
    } 
} 

int double_function(double *array, int length) 
{ 
    int i; 
    for(i=0; i<length; i++){ 
     printf("%f\n", array[i]); 
    } 
} 


int main() 
{ 
    float a[5] = {0.0, 1.0, 2.0, 3.0, 4.0};  
    double b[5] = {0.0, 1.0, 2.0, 3.0, 4.0}; 

    int (*generic_function)(void*, int) = NULL; 

    generic_function = &float_function; 
    generic_function(a, 5); 

    generic_function = &double_function; 
    generic_function(b, 5); 

    return 0; 
} 

Answer 1

La manera más limpia es en mi humilde opinión para realizar el molde dentro de la función. Esto obligará a todas las firmas de funciones a ser las mismas, y mantiene los moldes fuera del código de la persona que llama. (Esta es, por ejemplo, la forma en que qsort() la quiere)

int double_function(void *p, unsigned size) 
{ 
    double *array = p  
    unsigned uu; 

    for(uu=0; uu < size; uu++){ 
     printf("%f\n", array[uu]); 
    } 
return 42; 
} 

Answer 2

EDIT: Como @Mat señala, para satisfacer la especificación de C, que había necesidad de emitir el puntero de función volver al tipo original antes de llamarlo, lo que haría que todo este ejercicio un poco menos útil ;

((int(*)(float*,int))generic_function)(a, 5); 

Otra solución (inspirado en la respuesta de @wildplasser) es envolver las funciones de funciones teniendo void * y la realización de un yeso en ese parámetro en su lugar. Hacerlo "por macro" es bastante simple;

#define WRAP(FN, TYPE) int FN##_wrapped(void* p, int len) { return FN((TYPE*)p, len); } 
WRAP(float_function, float) 
WRAP(double_function, double) 

Luego puede usar las siguientes líneas bastante limpias;

generic_function = float_function_wrapped; 
generic_function(a, 5); 

Dicho esto, fundición de puntero no es generalmente una solución que había abogado, pero tiene sus casos de uso.

Answer 3

Sí, declararlo sin un prototipo.

int (*generic_function)() = NULL; 

Ahora puede asignar cualquier función que devuelve int, pero también puede pasar cualquier argumento y el compilador no está obligado a rechazar los argumentos incompatibles.