runtime détermine le type pour C

Si le type d’une variable doit être déterminé comme étant le temps d’exécution en C mais que le nom de la variable est fixe et donné, existe-t-il un moyen de réutiliser le code qui implique la variable?

En fait, je m’interroge sur la situation de contrepartie C du type de détermination à l’exécution pour C ++ .

Si possible, donnez quelques exemples.

Le langage C ne possède pas les fonctionnalités orientées object qui permettent de poser des questions sur le type d’exécution d’un object en C ++.

Vous implémentez généralement la généricité en C en effectuant un casting vers et à partir de void* . Exemple: la fonction C qsort .

Si votre question concerne la détermination au moment de l’exécution du type d’un pointeur void* , c’est impossible. L’information n’est tout simplement pas stockée du tout par la plupart des compilateurs.

Une technique standard consiste à fournir une variable info de type rapide en tant que paramètre, à l’activer et à transmettre toutes les données par référence. à l’intérieur de la fonction, nous récupérons la valeur par transtypage explicite. Le type void * n’est pas coché par le compilateur, le danger est donc d’envoyer un type non géré par la fonction (erreur de segmentation, corruption des données ou résultat de comportement inconnu). Commencez par établir une énumération des types dont vous avez besoin:

Dans ce cas, j’utilise la convention TYPE_FUNCTION pour représenter une fonction renvoyant un type.

La directive enum choisit des entiers successifs à partir de 0, ou vous pouvez atsortingbuer à chaque énumération sa propre valeur int.

 typedef enum D_types { ANINT, // don't use actual system type names AFLOAT, ADOUBLE, ASTRING, MY_STRUCT=100, MY_STRUCT2=200 VOID_FUNCTION=1000, INT_FUNCTION = 2000, STRUCT_FUNCTION=3000 } DATATYPE; /* an f_int is a function pointer to a function */ typedef int (*f_int)(int, void* ); 

Dans votre définition de fonction, vous envoyez les données par référence et le type, puis vous les transformez en un type correct avant utilisation:

 int myfunction ( DATATYPE dt, void* data, ) { int an_int = 0; int * ip; // typed pointers for casting of the void pointer data double * dp; char * sp; struct My_struct * msp; struct My_struct_2 * ms2p; f_int fp; ... switch (dt){ case ANINT: ip = (int*) data; // only pointers can be assigned void pointer values. int i = *ip // dereference of typed pointer, no dereferencing void pointers. ... break; case ADOUBLE: dp = (double*) data; double d = *dp; ... break; case ASTRING: char * s = strdup( (char*) data); // cast to char pointer allowed (pointer->pointer) ... break; case MY_STRUCT: msp = ( struct My_Struct *) data; char* ms_name = msp->name; // if my_struct has a name ssortingng ... float dollarvalue = msp->dvalue; ... case INT_FUNCTION: fp = (f_int)data; an_int = fp( ANINT, 5); } return an_int; } 

Comme vous pouvez le deviner, jouer avec des allumettes dans une usine de feux d’artifice n’est pas encouragé comme une pratique constante.

dans votre code, vous l’appelleriez comme ceci:

 double pi =3.14159; int g = myfunction( ADOUBLE, &pi ); // pass by reference, not value int j = myfunction (ASTRING , "HEY NOW" ); //C ssortingngs pass by ref normally f_int myfunc = myfunction; // a function pointer (ref to the functions address ) int r = myfunction ( INT_FUNCTION, myfunc ); /* function as a parameter ... */ 

Hormis pour une fonction ponctuelle, il est recommandé d’utiliser les fonctions varargs http://www.eskimo.com/~scs/cclass/int/sx11b.html