tiempo de ejecución determinar tipo para C

Question

Si el tipo de una variable debe ser determinada como tiempo de ejecución en C, pero el nombre de la variable es fijo y determinado, hay alguna forma de reutilizar el código que implica la variable?

En realidad estoy preguntando por la situación de contraparte C tiempo de ejecución determinar el tipo de C ++ .

Si es posible dar algunos ejemplos.

Answer 1

El lenguaje C no tiene las características orientadas a objetos que hacen que sea significativa para preguntar sobre el tipo de tiempo de ejecución de un objeto en C ++.

Por lo general, poner en práctica generalidad en C echando hacia y desde void*. Ejemplo:. la función C qsort

Si su pregunta se refiere a la determinación en tiempo de ejecución qué tipo real de un puntero apunta a void*, eso es imposible. La información que simplemente no se almacena en absoluto por la mayoría de los compiladores.

Answer 2

Una técnica estándar es proporcionar una variable de tipo info rápida como un parámetro y cambiar en eso, y pasar todos los datos de referencia. dentro de la función, recuperamos el valor con conversión explícita. * El tipo de vacío está desactivada de forma que el compilador lo que el peligro es el envío de un tipo que es controlada por la función (fallo de segmentación, la corrupción de datos o el resultado de un comportamiento desconocido). empezar por la creación de una enumeración de los tipos que necesita:

En este caso utilizo el TYPE_FUNCTION convención para representar una función que devuelve un tipo.

La directiva enumeración elige enteros sucesivos de 0, o se puede asignar a cada enumeración su propio valor 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* ); 

En su definición de la función de enviar tanto los datos de referencia y el tipo y echarlo al tipo correcto antes de su 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;
}

Como se puede adivinar, esto está jugando con fósforos en una fábrica de fuegos artificiales, y no se anima como una práctica constante.

en el código que podría llamarse de esta manera:

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

Aparte de una función de una sola vez se recomienda utilizar las funciones varargs http://www.eskimo.com/~scs/cclass/int/sx11b .html