Hola que tal? desde hace rato me vengo preguntando como hacer un programa que, al introducir un dato, identifique que tipo de dato se ha introducido, alguien sabe como?? no tengo idea de como hacer eso... alguien puede?? pueden ir postenado sus ideas, por cierto, es solo una duda, que otros tambien tendran.

Eso es lo que comenta leo.
El problema es que todo lo que vas usar tienes que declararlo antes.
Una cosa que puedes hacer es entrar los datos como string y después hacerles un cast a int o float por ejemplo, a la hora de hacer un calculo.
Pero no le veo la necesidad a eso.
Tu lo dirás para que lo quieras.
tal vez estés formulando mal la pregunta.   

Hola minari02, como muy bien te han contestado el control que tiene el C sobre las variables exige la declaración antes de utilizarlas, aunque  bien pudiera ser que lo que intentas preguntar es como "validar" un dato ingresado, que es otra cosa... lo más usual es encapsular la entrada en un "do-while...", ya que permite correr la sentencia al menos una vez (el cual usamos para el ingreso del dato) y lo aceptamos o rechazamos mediante la condiciones definidas al caso. Saludos.

Leosasan, estas discusiones sobre el comportamiento del compilador ante ciertas situaciones irregulares en los programas son sumamente enriquecedoras tanto para nosotros como para los usuarios menos experimentados de la comunidad  

Respecto a que no crees que el compilador informe un error siempre que encuentre una referencia a una variable que no se ha definido con anterioridad, ..... bueno dependerá del tipo de compilador, y lo estricto que éste sea.

Yo uso gcc de GNU para Linux y siempre me informa esta situación y lo cataloga como error (no Warning). Ello significa que el proceso de compilación se detiene y no genera un ejecutable. Por ejemplo, quise poner la sentencia de asignación x = 1 sin antes haber declarado la x y aquí el mensaje obtenido:


Ni siquiera (considerando que C99 define "int por defecto") se le ocurrió tomar la variable x como int y seguir con la compilación. Claro, esto quizá dependerá del tipo de compilador, a lo mejor algunos son más flexibles, o pueden ser configurados sobre cómo responder en situaciones como ésta.

En todo caso, creo que un compilador estricto es mejor (el de GNU lo es), porque te enseña desde el principio a programar como es debido, y ceñirte mejor a la norma ISO/IEC 9899:1999, mejor llamada ANSI C99 !!!

============================
Por otra parte, respecto a lo de convertir "1.23" en 1, y "12as" como 12, a eso precisamente me refiero con "las reglas de conversión implícita de tipo de C". Ya que es un lenguaje tipado, él posee protolocos internos que le dicen cómo convertir un valor dado a otro tipo esperado.

Ahora, SUPONEMOS que cadenas como "12as" se convertirán a 12, pero en general de la forma exacta de conversión yo no estoy seguro, pero eso debe estar claramente definido en la norma ANSI C99. Por algo C es un lenguaje que ha sido absolutamente normado, y al tener una duda sólo hay que consultar lo que dice la norma al respecto.

Yo no he investigado profundamente la conversión a entero de cadenas que incluyen caracteres no numéricos, preferiría validar el dato por mí mismo, tal como lo propone leosasan en su código.

Al usuario que inició este post le recuerdo que C tiene normas internas de conversión de tipo, y serán SÓLO esas, las que especifica el estándar oficial, y no las que tú creas, o las que crea el usuario. En tales situaciones "anómalas", nada te garantiza que el comportamiento de la función scanf será como tú supones que será. Pero como programador debes mantener tu programa siempre "bajo control", por eso debes confeccionar una rutina de validación de los datos que introduce el usuario según tus propias normas y preferencias. Eso te recomiendo  

======================
Continuando el tema, y para que minari02 te acostumbres a la buen práctica de validar los datos de entrada (nunca confíes en el buen juicio del usuario de tu programa) he aquí una humilde contribución que preparé hace tiempo. Esta función isnumeric recibe una cadena y devuelve True si corresponde a un número válido, y False si no. Admite los caracteres 0-9, además de +-., y el espacio. Los espacios al inicio y al final de la cadena serán despreciados, y además filtra la cadena de una forma más sofisticada que sólo ver si está compuesta de caracteres permitidos. Por ejemplo, permite el '+' o el '-', pero sólo uno de ellos, y antecediendo a cualquier carácter numérico. O sea, que por ejemplo rechazará expresiones como "++354", ó "3-456". El signo decimal '.' sólo podrá aparecer una vez.

Aquí el código, para que lo incluyas en tu programa. Se aceptan con agrado sugerencias y mejoras 

/* No cero si la cadena apuntada por s representa un número real decimal.
	La cadena deberá contener sólo los caracteres "+-0123456789. ". 
 
	- El carácter de punto decimal es el punto '.', es opcional y sólo puede aparecer 
	  una vez en la cadena.
	- El carácter de signo '+' o '-' es opcional, sólo puede aparecer una vez y como 
	  primer carácter no blanco de la cadena.
	- Se admiten secuencias de espacios ' ' al principio o al final de la cadena, pero
	  son ignoradas. No se admiten espacios en el medio de la cadena.
 
	Esta definición es acorde con la configuración regional estándar en Español, pero
	pudiera adaptarse para la configuración en Inglés (la coma ',' antes que el punto '.').
 
	No admitimos en esta implementación representaciones en punto flotante con mantisa y
	exponente, sólo mantisa.
*/
int isnumeric(const char *s) {
 
	const char *allowed_chars = "0123456789.";		/* caracteres permitidos */
	char c;
	int i, j, N;
	bool exists_point = false, exists_sign = false;
	bool pre_space = false, post_space = false;
 
	N = strlen(allow_chars);
	for (i = 0; i < INT_MAX && s[i]!='\0'; i++) {
		c = s[i];
 
		// sólo se admite un carácter opcional '+' ó '-' y como primer
		// no blanco de la cadena
		if (c == '+' || c == '-') {
			if (exists_sign == true) 
				return 0;	
			else {
				exists_sign = 1;
				if (i>0)
					if (s[i-1] != ' ') return 0;
			}
			continue;
		}
 
		if (c == ' ') {
			if (pre_space == false) pre_space = 1;
			if (i > 0 && s[i-1] != ' ') post_space = 1;
			continue;
		}
		if (post_space == true && c != ' ') return 0;
 
		// buscando caracteres permitidos
		for (j=0; j<N; j++)
			if (c == allowed_chars[j]) break;
		if (j == N) return 0;		
 
		// no puede haber más de un carácter '.'
		if (c == '.') {
			if (exists_point == 1) 
				return 0;			
			else
				exists_point = 1;
		}
	}
 
	// si no detecta error, sale con valor 1
	return 1;
}

Me pongo a esto:

enum type{
    type_signed = 1,
    type_bool = 2,
    type_int = 4,
    type_short = 8,
    type_float = 16,
    type_double = 32,
    type_char = 64
    /* ... */
}
 
int typeOf(string s){
    /** Esto retornará un entero compuesto de los números que pueda ser.
          Si es "12", por ejemplo, puede ser short, int, float, double y char. Entonces, retornaría: 4+8+16+32+64. (Puede ser más tipos, pero aun estoy empezando el enum jaja **/
}

Luego, la salida de typeOf se parsearía así:

if(typeOf(str)&type_double) double d = parse<double>(str);

la función parse podría tener un template para retornar el tipo indicado xD


EDITO: Como es diferente el tamaño de un signed al de un unsigned (el tamaño máximo), quitaré el type_signed, y pondré type_uchar, type_uint etc etc

EDITO 2: Finalmente:

enum type{
    /**    SIGNED TYPES    **/
    type_bool     = 0b0000000000000001,
    type_char     = 0b0000000000000010,
    type_short    = 0b0000000000000100,
    type_int      = 0b0000000000001000,
    type_llong    = 0b0000000000010000,
    type_float    = 0b0000000000100000,
    type_double   = 0b0000000001000000,
    type_ldouble  = 0b0000000010000000,
 
    /**    UNSIGNED TYPES    **/
    type_ubool    = 0b0000000100000000,
    type_uchar    = 0b0000001000000000,
    type_ushort   = 0b0000010000000000,
    type_uint     = 0b0000100000000000,
    type_ullong   = 0b0001000000000000,
    type_ufloat   = 0b0010000000000000,
    type_udouble  = 0b0100000000000000,
    type_uldouble = 0b1000000000000000,
 
    /**    OTHER    **/
    type_signed   = 0b0000000011111111,
    type_unsigned = 0b1111111100000000,
    type_all      = 0b1111111111111111
};

RE-EDITO: Ahora me dió pereza poner toodos los "if" para comprobar cada tipo jaja. Si alguien se anima, aunque sea para 1 tipo solo, que postée :3