runtime determinare tipo per C
-
20-09-2019 - |
Domanda
Se il tipo di una variabile deve essere determinato a runtime in C, ma il nome della variabile è fisso e data, non v'è alcun modo per riutilizzare il codice che coinvolge la variabile?
In realtà io sto chiedendo circa la situazione controparte C di runtime determinare il tipo di C ++ .
Se possibile, fare qualche esempio.
Soluzione
Il linguaggio C non ha le caratteristiche object-oriented che rendono significativo per chiedere informazioni sul tipo run-time di un oggetto in C ++.
In genere implementare genericità in C lanciando da e per void*
. Esempio:. la funzione C qsort
Se la domanda riguarda la determinazione in fase di esecuzione che tipo effettivo di un puntatore punta void*
a, che è impossibile. L'informazione non è semplicemente conservato a tutti dalla maggior parte dei compilatori.
Altri suggerimenti
Una tecnica standard è quello di fornire una variabile di tipo Quick info come parametro e accendere questo, e trasmettere tutti i dati per riferimento. all'interno della funzione, recuperiamo il valore con cast esplicito. Il vuoto di tipo * è deselezionata per il compilatore in modo che il pericolo è l'invio di un tipo che è gestita dalla funzione (segmentation fault, il danneggiamento dei dati o il risultato comportamento sconosciuto). iniziare con la creazione di un'enumerazione dei tipi è necessario:
In questo caso uso il TYPE_FUNCTION convenzione per rappresentare una funzione che restituisce un tipo.
La direttiva enum sceglie interi consecutivi da 0, oppure è possibile assegnare ad ogni enumerazione il proprio valore 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* );
Nella definizione della funzione di inviare sia i dati per riferimento e il tipo e gettalo via al tipo corretto prima dell'uso:
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;
}
Come si può immaginare, questo sta giocando con i fiammiferi in una fabbrica di fuochi d'artificio, e non incoraggiata come una pratica costante.
nel codice si dovrebbe chiamare in questo modo:
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 ... */
Oltre che per una funzione one-off si consiglia di utilizzare le funzioni varargs http://www.eskimo.com/~scs/cclass/int/sx11b .html