déterminer le type d'exécution C

Question

Si le type d'une variable doit être déterminée comme l'exécution en C mais est fixe et donné le nom de la variable, est-il possible de réutiliser le code qui implique la variable?

En fait, je me interroge sur la situation de contrepartie C de l'exécution déterminer le type C ++ .

Si possible s'il vous plaît donner quelques exemples.

Answer 1

Le langage C ne possède pas les fonctionnalités orientées objet qui le rendent utile pour poser des questions sur le type d'exécution d'un objet en C ++.

Vous implémentez généralement généricité en C par coulée vers et à partir void*. Exemple:. la fonction C qsort

Si votre question porte sur la détermination à l'exécution quel type réel un pointeur de void* à, c'est impossible. Les informations sont tout simplement pas conservé à tous par la plupart des compilateurs.

Answer 2

Une technique standard est de fournir une variable d'information de type rapide comme paramètre et changer à cet égard, et transmettre toutes les données de référence. à l'intérieur de la fonction, nous récupérons la valeur avec la coulée explicite. Le type void * est désactivée par le compilateur de sorte que le danger envoie un type qui est non gérée par la fonction (erreur de segmentation, une altération des données ou le résultat d'un comportement inconnu). commencer par la mise en place d'une énumération des types dont vous avez besoin:

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

La directive enum choisit des nombres entiers successifs de 0, ou vous pouvez attribuer à 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 la fonction que vous envoyez à la fois les données de référence et le type et de le jeter au type correct avant d'utiliser:

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 string ...
       float dollarvalue = msp->dvalue; 
       ...
     case INT_FUNCTION:
       fp = (f_int)data;
       an_int = fp( ANINT, 5); 
    }
return an_int;
}

Comme vous pouvez le deviner, cela se joue avec des allumettes dans une usine de feux d'artifice, et non encouragé comme une pratique constante.

dans votre code que vous appelez comme ceci:

double pi =3.14159; 
int g = myfunction( ADOUBLE, &pi  ); // pass by reference, not value   

int j = myfunction (ASTRING , "HEY NOW" );  //C strings 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 ... */

Autre que pour une fonction unique il est recommandé d'utiliser les fonctions varargs http://www.eskimo.com/~scs/cclass/int/sx11b .html