Différence entre uint et int non signé?

Certains systèmes peuvent définir uint comme un typedef.

typedef unsigned int uint;

Pour ces systèmes, ils sont même. Mais uint n'est pas un type standard, de sorte que chaque système peut ne pas le soutenir et donc il n'est pas portable.

je suis d'étendre un peu les réponses par Erik, Teoman Soygul et taskinoor

uint n'est pas une norme.

par conséquent, utiliser votre propre raccourci comme ceci est déconseillé:

typedef unsigned int uint;

si vous recherchez plutôt la spécificité de la plate-forme (par exemple, vous devez spécifier le nombre de bits que votre int occupe), y compris stdint.h:

#include <stdint.h>

exposera la norme suivante catégories d'entiers:

• types entiers ayant certaines largeurs exactes

• types entiers ayant au moins certaines largeurs spécifiées

• les types entiers les plus rapides ayant au moins certaines largeurs spécifiées

• des types entiers assez larges pour contenir des pointeurs vers des objets

• les types entiers ayant la plus grande largeur

Par exemple,

Exacte de la largeur des types d'entiers

le nom typedef int n _t désigne un type entier signé avec la largeur N, pas de bouts de rembourrage,et une représentation à deux. Ainsi, int8_t indique un type entier signé avec une largeur d'exactement 8 bits.

le nom de type uint n _t désigne un type entier non signé avec largeur N. ainsi, uint24_t dénote un type entier non signé avec une largeur exactement 24 bit.

définit

int8_t
int16_t
int32_t
uint8_t
uint16_t
uint32_t

unsigned int est un type intégré (standard) donc si vous voulez que votre projet soit multi-plateforme, utilisez toujours unsigned int comme il est garanti d'être supporté par tous les compilateurs (d'où la norme).

toutes les réponses omettent de mentionner la véritable raison de uint.

C'est évidemment un typedefunsigned int, mais cela n'explique pas son utilité.

La vraie question est:

pourquoi quelqu'un voudrait taper un type fondamental à un abrégé la version?

pour économiser sur la dactylographie?

Non, ils l'ont fait de la nécessité.

considérez le langage C; un langage qui n'a pas modèle.

Comment pourrais-tu traquer ton propre vecteur qui peut contenir n'importe quel type?

Vous pourriez faire quelque chose avec le vide des pointeurs,

mais une émulation plus proche des gabarits vous ferait recourir à des macros.

ainsi vous définiriez votre vecteur de template:

#define define_vector(type) \
  typedef struct vector_##type { \
    impl \
  };

Déclarer vos types:

define_vector(int)
define_vector(float)
define_vector(unsigned int)

Et après génération, se rendre compte que le type doit être un seul jeton:

typedef struct vector_int { impl };
typedef struct vector_float { impl };
typedef struct vector_unsigned int { impl };