Laufzeit bestimmen Typ für C

Question

Wenn der Typ einer Variablen muß Laufzeit in C bestimmt werden, sondern der Variablenname ist festgelegt und angegeben, ist es eine Möglichkeit, den Code wieder zu verwenden, den die Variable beinhaltet?

Eigentlich frage ich über die C Pendant Situation von Laufzeit bestimmen Typ für C ++ .

Wenn möglich, bitte ein paar Beispiele geben.

Answer 1

Die Sprache C nicht über die objektorientierten Funktionen, die es sinnvoll zu fragen, um den Laufzeittyp eines Objekt in C ++ zu machen.

Sie implementieren typischerweise Genericity in C durch vom und zum void* Gießen. Beispiel:. die C-Funktion qsort

Wenn Ihre Frage über die Bestimmung während der Laufzeit ist, welche tatsächliche Typ ein void* Zeiger zeigt auf, das ist unmöglich. Die Informationen werden einfach nicht durch die meisten Compiler gespeichert.

Answer 2

Eine Standardtechnik ist eine schnelle Art Info Variable als Parameter zur Verfügung zu stellen und der Schalter auf das, und alle Daten, die durch Verweis übergeben. innerhalb der Funktion, erholen wir den Wert mit expliziten Gießen. Der void * Typ ist vom Compiler nicht markiert, so dass die Gefahr eine Art sendet, die durch die Funktion (Segmentierungsfehler, Datenbeschädigung oder unbekanntes Verhalten Ergebnis) Unbehandelte wird. beginnen durch eine Aufzählung der Typen Einrichtung benötigen Sie:

In diesem Fall verwende ich die Konvention TYPE_FUNCTION eine Funktion stellt eine Art Rückkehr.

Die Enum-Direktive wählt aufeinanderfolgende ganze Zahlen von 0, oder Sie können jeder Aufzählung seinen eigenen int Wert zuweisen.

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* ); 

In Ihrer Funktion Definition senden Sie sowohl die Daten als Referenz und den Typ und warf es auf den richtigen Typ vor dem Gebrauch:

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

Wie Sie sich vorstellen können, ist dies mit Streichhölzern in einer Feuerwerksfabrik spielen, und nicht als ständige Praxis gefördert.

in Ihrem Code Sie es so nennen würden:

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 ... */

Anders als für eine einmalige Funktion Es wird empfohlen, die varargs Funktionen zu nutzen http://www.eskimo.com/~scs/cclass/int/sx11b .html