Foro de elhacker.net

Hola a todos.
Bueno quiero saber cual es la diferencia entre usar las variables con nombres normales por así decirle como:

int a;
short int p;
unsigned int r;
char b;
char s[6];
float c;
etc.
 

a usar estas por lo que yo entendido son los mismo, se refieren a un tipo de variable como los antes mencionados:

   int64_t t;
   uint8_t   a;
   uint16_t c;
   uint32_t d;
   uint8_t g;
   uint32_t r[5];
 

lo que aun no me queda muy claro es cual seria para float, char, double etc la única que si creo saber para que representa es int64_t = long int, int32_t = int, int16_t = short int.
Bueno espero que me puedan ayudar.
Saludos.
Drewermerc.

La diferencia es que las variables de codigo normal van apegadas a las reglas del compilador, es decir diferentes compiladores pueden manejarlo en diferente tamaño (aunque cumple un standard minimo) segun lo consideren, ej si compilas para 32bits, en compilador hara de ese el largo del int, en cambio, uintX_t es un especificacion puntual y exacta en bits donde sea necesaria precisión de bits.

Sin embargo char no tiene comparación directa (aunque perfectamente se pueda usar uint8 para unsigned char) porque sabemos que los char son 1byte (aunque hay sistemas que los pueden hacer de 2 byte)

Por otro lado no existe comparacion para float, ni double creo que es porque no requieren la exactitud de bytes

De todas formas aquí la Wikipedia con mas info
http://en.wikipedia.org/wiki/Stdint.h (http://en.wikipedia.org/wiki/Stdint.h)

Hola angel lex.
Muchas gracias por responder.
solo tengo una pregunta cuando se pueden usar este tipo de definiciones ya que si las uso por ejemplo con fgets o declaro:

 uint8_t f[10] ; 
 uint8_t *uno[] = {"uno", "dos"} ; 
 fgets(f, sizeof f, stdin);/*me da mucho error el compilador */
 uint16_t d; 
 scanf("%d", &d) ;/*me dice:
 warning: format '%d' expects argument of type 'int *', but argument 2 has type 'int16_t *' [-Wformat]*/
 

Saludos.
Drewermerc.

las usas cuando realmente necesitas una precisión en bits que no varíe con la arquitectura...

En el caso de fgets esta espera como primer argumento un valor de tipo "char *" con el tipo "char" equivalente a "signed char" o "unsigned char" dependiendo de la implementación, lo usual es el tipo con signo. En ese escenario estarías pasando un valor de tipo "unsigned char *" a la función cuando esta requiere un "signed char *".

En el caso de scanf "%d" indica que el segundo argumento sera de tipo "signed int *" mientras que tu pasas "&d" cuyo tipo es "unsigned entero_16 *", ahí el calificador de signo (como posiblemente el tamaño de los tipos) no coincide.

A eso hay que sumarle que los tipos intN_t y uintN_t son opcionales.

Un saludo

bueno gracias por responder angel lex y rir3760.
Ya entendí como funciona mas o menos  int  pero con el que toda vía no encuentro como implementarlo  buen es quiero aprender  manjar bien este tipo de variables no se si sepan de algún libro o web donde me pueda documentar sobre este tema.
Entonces se puede manejar un programa ya esa usando char, int o uintN_t o intN_t?
es que lo que estoy tratando es un programa así básico como este.

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
 
int main(void)
{
	int8_t *uno[]={"hola", "como"};
	int32_t dos;
	uint16_t tres;
	int8_t palabra[30];
	printf("Introduce un numero\n");
	scanf("%d", &dos);
	printf("tu numero es%hu\n", dos);
	printf("%s\n", *uno);
	fgets(palabra, sizeof palabra, stdin);
	printf("tu palabra es %s\n", palabra);
	return EXIT_SUCCESS;
}
 

donde me da problema es al usar char ya use tanto uint8_t como int8_t y me manda estos mensajes de warning al inicializar  el uno y pasar el parámetro a fgets.

prueba_uint.c: In function 'main':
prueba_uint.c:8:2: warning: pointer targets in initialization differ in signedness [-Wpointer-sign]
prueba_uint.c:8:2: warning: (near initialization for 'uno[0]') [-Wpointer-sign]
prueba_uint.c:8:2: warning: pointer targets in initialization differ in signedness [-Wpointer-sign]
prueba_uint.c:8:2: warning: (near initialization for 'uno[1]') [-Wpointer-sign]
prueba_uint.c:16:2: warning: pointer targets in passing argument 1 of 'fgets' differ in signedness [-Wpointer-sign]
In file included from prueba_uint.c:1:0:
/usr/include/stdio.h:624:14: note: expected 'char * __restrict__' but argument is of type 'int8_t *'
 

Bueno espero que me puedan ayudar.
Saludos.
Drewermerc.

Las palabras del profesor Oak resuenan: "Usa cada cosa en su momento."

Si vas a trabajar con caracteres, repito, caracteres, lo lógico es usar char.
Si vas a trabajar con valores numéricos de tamaños fijos, usar el set de variables "uintX_t" y compañía puede ser útil.

Todo esto, obviamente, salvo excepciones, o salvo que exista un alto control del lenguaje.

Hola ivancea96.
Bueno gracias por responder ya me quedo mas claro este tema de uintN_t.

Saludos.
Drewermerc.