u_int8_t vs unsigned char

Quel est l'avantage de l'utilisation de uint8_t sur unsigned char en C?

Je sais que sur presque tous les systèmes uint8_t est juste un typedef pour unsigned char,
alors pourquoi l'utiliser?

InformationsquelleAutor Lyndon White | 2009-11-12
  1. 204

    Il des documents à votre intention, vous serez le stockage de petits nombres, plutôt que d'un personnage.

    En outre, il semble plus agréable si vous utilisez d'autres typedefs comme uint16_t ou int32_t.

    • Il n'était pas clair dans la question de départ, si nous parlions d'un type standard ou pas. Je suis sûr qu'il existe beaucoup de variantes de cette convention de nommage au fil des ans.
    • J'ai ma réponse, merci.
    • Explicitement à l'aide de unsigned char ou signed char documents à l'intention de trop, car sans fioritures char est ce que montre vous travaillez avec des personnages.
    • Si vous êtes assez chanceux pour obtenir au-delà d'un sans fioritures 'unsigned' pour commencer, encore que je vois des gens faire de laisser la plate-forme de choisir si son int ou char par défaut. Mais, je pense que, dans cette journée et l'âge 'unsigned' (seul, ou orné) indique l'intention de manière adéquate, sinon un simple processus d'élimination explique cela 🙂
    • J'ai pensé à un sans fioritures unsigned était unsigned int par définition?
    • Donc, en utilisant uint8 pour une chaîne de texte serait bizarre/mal?
    • à l'aide de u_int8_t pour une chaîne de caractères n'est pas forcément mauvais, mais c'est vraiment bizarre.
    • Ainsi, un u_int8_t peut contenir une valeur entière entre 0 et 255 ou 8 bits binaires. Tout comme lors de la syntaxe a été unsigned char, mais beaucoup mieux que de la grammaire.
    • correct.
    • la question n'était pas au sujet de ces autres types de sorte que je n'ai pas entrer dans ce. Et malheureusement unsigned char et uint8_t ne sont pas de types distincts, voir par exemple ideone.com/GMV0uD
    • hmm. Je suis désolé pour donner de fausses informations... je savais que enum et int sont distrinct types et je suppose que c'est la même chose pour d'autres types qui peuvent être auto-coulé de type int. Ou peut-être que ça dépend de compiller...
    • Je pense que je peux faire un cas pour u_int8_t avec l'UTF8 texte. En effet, char semble impliquer un personnage, alors que dans le contexte d'une chaîne UTF8, il peut être en un seul octet d'un caractère multi-octets. À l'aide de u_int8_t pourraient le rendre clair que l'on ne doit pas s'attendre à un personnage dans chaque position-à-dire que chaque élément de la chaîne de caractères ou un tableau est un entier arbitraire que l'on ne doit pas faire de la sémantique des hypothèses sur. Bien sûr, tous les programmeurs C le savent, mais il peut pousser les débutants à se poser les bonnes questions.
    • Je dois dire, unsigned char n'est pas vraiment utilisé pour stocker les caractères en premier lieu, de sorte que "l'intention" question est discutable.
    • Eh bien, c'est historique. Je pense que nous pouvons supposer qu'il est utilisé pour stocker les caractères "en premier lieu" (à l'intention initiale; que char est une abréviation de caractère est assez clair), mais en effet ne pas en pratique parce que c'était historiquement, le seul standard de 8 bits type de données jusqu'à ce que le C99 inttypes.h est apparu. Maintenant que nous avons inttypes.h, je pense que c'est en fait tous sur l'intention, lorsque l'on compare les types de données d'origine et la nouvelle (u)int_(least/fast)N_t types de données, et sur l'intention, et l'assurance que le code compile avec largeur exacte ou pas du tout quand il s'agit de (u)intN_t.

    InformationsquelleAutor Mark Ransom
  2. 63

    Juste pour être pédant, certains systèmes peuvent ne pas avoir un 8 bits type. Selon Wikipédia:

    Une mise en œuvre est nécessaire pour définir exacte de la largeur des types d'entiers pour N = 8, 16, 32, ou 64 si et seulement si elle a un type qui satisfait aux exigences. Il n'est pas nécessaire de les définir pour toute autre N, même si elle prend en charge les types appropriés.

    Donc uint8_t n'est pas garanti pour exister, mais pour toutes les plates-formes 8 bits = 1 octet. Certaines plateformes embarquées peuvent être différentes, mais qui devient très rare. Certains systèmes peuvent définir char de types 16 bits, dans ce cas, il ne sera probablement pas en 8 bits type de toute nature.

    Autre que celle (mineur) problème, @Mark Rançon de la réponse est le meilleur à mon avis. Utilisez celle qui montre clairement ce que vous êtes en utilisant les données pour.

    Aussi, je suis en supposant que vous vouliez dire uint8_t (la norme de définition de type de C99 fourni dans le stdint.h en-tête) plutôt que de uint_8 (ne faisant pas partie de la norme).

    • Dsp avec CHAR_BIT > 8 sont de plus en moins rares, pas plus.
    • par pure curiosité - pouvez-vous le lien vers la description de quelques-uns? Je sais qu'ils existent parce que quelqu'un a mentionné l'un (et lié à développeur docs pour elle) dans une comp.lang.c++.discussion animée sur que C/C++ type de garanties sont trop faibles, mais je ne trouve pas que ce thread, et de plus, il est toujours à portée de main pour référence que dans toutes les discussions semblables 🙂
    • "Certains systèmes peuvent définir char de types 16 bits, dans ce cas, il ne sera probablement pas en 8 bits type de toute nature." - et en dépit de quelques incorrect objections de moi, Pavel a démontré dans sa réponse que si le char est de 16 bits, alors même si le compilateur ne fournir un 8 bits type, ne doit pas appeler uint8_t (ou définition de type pour qui). C'est parce que le 8 bits type de aurait les bits non utilisés dans la représentation de stockage, qui uint8_t ne doit pas avoir.
    • Le SHARC architecture 32 bits. Voir en.wikipedia.org/wiki/... pour plus de détails.
    • Et TI C5000 Dsp (qui étaient en OMAP1 et OMAP2) sont 16bit. Je pense que pour OMAP3, ils sont allés à C6000 de la série, avec un 8bit char.
    • Oh oui, il était en effet SHARC. Merci. Ressemble à une plate-forme idéale pour B (celui entre BCPL et C) pour moi 🙂
    • Creuser dans N3242 - ", document de Travail, Standard pour la Programmation en Langage C++", section 18.4.1 < cstdint > synopsis dit - typedef unsigned integer type uint8_t; // optional Donc, en substance, une C++ standard conforme de la bibliothèque n'est pas nécessaire de définir u_int8_t à tous (voir le commentaire //facultatif)
    • Dans les cas où le plus petit type de données est supérieure à 8 bits (par exemple, Ti C2000-série, ils sont au nombre de 16 bits) je crois que l'on pourrait utiliser uint_least8_t à indiquer correctement l'intention et le fait que le type ne peut pas être réellement en 8-bits.

    InformationsquelleAutor Chris Lutz
  3. 40

    Le but est d'écrire de la mise en œuvre-le code indépendant de la. unsigned char n'est pas garanti d'être un 8 bits type. uint8_t est (si disponible).

    • ...si elle existe sur un système, mais qui va être très rare. +1
    • eh bien, si vous avez vraiment eu de la difficulté avec votre code de la compilation sur un système, car u_int8_t n'existait pas, vous pouvez trouver et utiliser sed pour changer automatiquement toutes les occurences de u_int8_t à unsigned char ou quelque chose de plus utile pour vous.
    • pas si vous êtes en supposant que c'est un 8 bits type, vous ne pouvez pas par exemple pour décompresser les données emballés dans bytewise de la mode par un système distant. L'hypothèse implicite est que la raison pour u_int8_t de ne pas exister, c'est sur un processeur où un char de plus de 8 bits.
    • jeter dans l'affirmation assert(sizeof(unsigned char) == 8);
    • affirmation erronée, j'ai peur. sizeof(unsigned char) sera de retour 1 de 1 octet. mais si un système de char et int sont de la même taille, par exemple, 16-bits alors sizeof(int) est également de retour 1
    • OK .. quelqu'un a une solution?
    • CHAR_BIT == 8 ou #ifdef UINT8_MAX

    InformationsquelleAutor AnT
  4. 7

    Comme vous l'avez dit, "presque chaque système".

    char est probablement l'un des moins susceptibles de changer, mais une fois que vous commencez à utiliser uint16_t et amis, à l'aide de uint8_t mélanges de mieux, et peut même faire partie d'une norme de codage.

    InformationsquelleAutor Justin Love
  5. 7

    Dans mon expérience, il y a deux endroits où nous voulons utiliser u_int8_t à dire 8 bits (et uint16_t, etc) et où l'on peut avoir des champs de taille inférieure à 8 bits. Les deux endroits sont les cas où l'espace des questions et nous avons souvent besoin de regarder raw dump des données lors du débogage et doivent être en mesure de déterminer rapidement et de ce qu'il représente.

    La première est dans les protocoles RF, en particulier dans la bande étroite des systèmes. Dans cet environnement, nous pouvons avoir besoin pour emballer autant d'informations que possible, dans un seul message. La deuxième est en flash de stockage où l'on peut avoir très peu d'espace (comme dans les systèmes embarqués).
    Dans les deux cas, nous pouvons utiliser des paniers-structure de données dans laquelle le compilateur va prendre soin de l'emballage et le déballage pour nous:

    #pragma pack(1)
typedef struct {
  uint8_t    flag1:1;
  uint8_t    flag2:1;
  padding1   reserved:6;  /* not necessary but makes this struct more readable */
  uint32_t   sequence_no;
  uint8_t    data[8];
  uint32_t   crc32;
} s_mypacket __attribute__((packed));
#pragma pack()

    La méthode que vous utilisez dépend de votre compilateur. Vous pouvez aussi avoir besoin de l'appui de plusieurs des compilateurs différents avec les mêmes fichiers d'en-tête. Ce qui se passe dans les systèmes embarqués où les périphériques et les serveurs peuvent être complètement différents - par exemple, vous pouvez avoir un BRAS de l'appareil qui communique avec un x86 Linux serveur.

    Il existe quelques inconvénients à l'utilisation de paniers structures. Le plus grand piège est que vous devez éviter de référence à l'adresse d'un membre. Sur les systèmes avec mutibyte aligné des mots, cela peut entraîner un mauvais alignement de l'exception - et un coredump.

    Certaines personnes s'inquiètent également de la performance et affirment que l'utilisation de ces paniers structures vont ralentir votre système. Il est vrai que, derrière les coulisses, le compilateur ajoute le code pour accéder aux données non alignées membres. Vous pouvez le voir en regardant le code assembleur dans votre IDE.

    Mais depuis paniers structures sont les plus utiles pour la communication et le stockage des données les données peuvent être extraites dans un non-emballés représentation du travail dans la mémoire.
    Normalement nous n'avons pas besoin de travailler avec l'ensemble du paquet de données dans la mémoire de toute façon.

    Voici de discussion:

    pragma pack(1), ni __attribute__ ((alignés (1))) fonctionne

    Est du ccg __attribute__((emballé)) /#pragma pack dangereux?

    http://solidsmoke.blogspot.ca/2010/07/woes-of-structure-packing-pragma-pack.html

    InformationsquelleAutor Tereus Scott
  6. 6

    Il y a peu. Du point de vue de la portabilité, char ne peut pas être inférieure à 8 bits, et rien ne peut être plus petit que char, donc si une œuvre a un entier non signé de 8 bits type entier, ça va être char. Alternativement, il peut ne pas en avoir un à tous, à quel point tout typedef astuces sont discutable.

    Il pourrait être utilisé pour mieux documenter votre code, en ce sens qu'il est clair que vous avez besoin d'octets de 8 bits, et rien d'autre. Mais dans la pratique c'est une attente raisonnable en matière de pratiquement n'importe où déjà (il y a des DSP plates-formes sur lesquelles il n'est pas vrai, mais les chances de votre code en cours d'exécution il est mince, et vous pourriez tout aussi bien l'erreur à l'aide d'un statique affirmer en haut de votre programme sur une telle plate-forme).

    • Pour l'enregistrement, vous pourriez faire un 8 bits type sur n'importe quelle plateforme: typedef struct { unsigned i :8; } uint8_t; mais vous auriez à utiliser comme uint8_t x; x.i = ... de sorte qu'il faudrait être un peu plus lourd.
    • Je pense que les caractères peuvent aller aussi bas que 4 bits, en dessous et les choses tombent en morceaux un peu dans la norme (il y a une chance que je me trompe mais).
    • Non, la norme exige unsigned char pour être en mesure de conserver des valeurs entre 0 et 255. Si vous pouvez le faire en 4 bits, mon chapeau est hors de vous.
    • "il faudrait être un peu plus lourd" - lourd dans le sens que vous auriez à pied (nager, prendre l'avion, etc) tout le chemin à l'endroit où le compilateur écrivain, claque dans le dos de la tête, et de les faire ajouter uint8_t à la mise en œuvre. Je me demande, ne les compilateurs pour les Dsp avec 16 caractères généralement en œuvre uint8_t, ou pas?
    • non, ils ne le font pas, car il n'y a vraiment pas moyen pour eux de le faire. Champ de bits astuce ne fonctionne en effet, mais bitfields sont très limitées (vous ne pouvez pas avoir des tableaux d'entre eux, vous ne pouvez pas avoir des pointeurs, etc). Il n'y a aucune exigence en C99 pour qu'une norme ont uint8_t à tous - il faut l'avoir si et seulement si elle a un type correspondant. Il est, cependant, nécessaire de fournir uint8_least_t, qui est au moins 8 bits (mais peut-être plus).
    • Par la voie, sur une seconde pensée, c'est peut-être la façon la plus simple de dire "j'ai vraiment besoin de 8 bits" - #include <stdint.h>, et l'utilisation uint8_t. Si la plate-forme, il va se donner à vous. Si la plate-forme ne l'a pas, votre programme ne compilera pas, et la raison sera clair et simple.
    • J'aime la logique que si uint8_t existe à tous, ça va être unsigned char de toute façon.
    • "il n'y a vraiment pas moyen pour eux de le faire" - eh bien, cela dépend de la façon dont le compilateur est codé. Vous savez qu'ils sont en mesure de générer le code pour faire 8 bits non signé de l'arithmétique, en raison de bitfields (probablement normal de l'arithmétique, en plus de certains de masquage). Bien sûr, vous auriez sizeof(uint8_t) == sizeof(char) même si UCHAR_MAX != 255, mais c'est OK, c'est pourquoi les types n'ont pas à utiliser toute leur stockage bits. Par "claque dans le dos de la tête" bien sûr, je veux dire "faire un passionné mais poli demande de fonctionnalité". Ils sont en droit de le refuser, mais le degré de confiance sont-ils que vous n'aurez pas recours à la violence? 😉
    • Comme pour les "simples" - c'est certainement le moins avant l'effort de codage, mais comme vous le dites, pour la vraie portabilité vous avez juste à utiliser uint8_least_t et appliquer le modulo-256 dépassement de vous-même. Je devine que vous pouvez l'écrire ainsi que sur toute vaguement l'optimisation du compilateur où uint8_least_t est de 8 bits, tous les extra ops sont gommés.
    • "Bien sûr, vous auriez sizeof(u_int8_t) == sizeof(char), même si UCHAR_MAX != 255, mais c'est OK, c'est pourquoi les types n'ont pas à utiliser toute leur stockage bits." - ce n'est pas grave, parce unsigned char est spécifiquement requis pour l'utilisation de toutes les capacités de stockage de bits entièrement par l'ISO C et C++. Voir 6.2.6.1/3 (et la note de bas de page) pour C99, et 3.9.1/1 pour C++03.
    • Il est OK. unsigned char (qui dans cet exemple est de 16 bits) utilise tous les bits, mais autant que je sache uint8_t ne pas avoir à le faire. Donc uint8_t peut être plus petite que unsigned char dans la gamme, bien que, évidemment, pas dans la taille de stockage. Donc je ne vois pas pourquoi il devrait être difficile pour le compilateur de l'écrivain à l'appui de uint8_t. Il peut être monstrueusement inefficace, mais c'est une question distincte.
    • Toujours pas de cigare, désolé: "Pour un entier non signé de types autres que unsigned char, les bits de la représentation d'objet, doit être divisé en deux groupes: la valeur de bits et d'un rembourrage de bits ... Si il y a valeur de N bits, chaque bit représente une puissance différente de 2 entre 1 et 2^(N-1), de sorte que les objets de ce type doit être capable de représenter les valeurs de 0 à 2^(N-1) à l'aide d'une pure représentation binaire ... typedef nom intN_t désigne un entier signé de type avec une largeur de N, pas de rembourrage bits, et une représentation en complément à deux."
    • OK, vous gagnez :-). 7.18.1.1 visiblement ne veut pas dire que les versions non signées ont pas de rembourrage bits. Mais il est implicite par l'exigence que si vous fournissez u_int8_t ensuite, vous devez fournir int8_t, et le lemme: si u_int8_t a rembourrage bits, puis int8_t a padding bits, car ils sont de la même largeur et la même taille de stockage.
    • Morale de l'histoire: les types d'entiers sont stupides, mais rapide. Si vous avez besoin d'arithmétique modulo particulière d'une puissance de deux, soit l'écrire vous-même ou utiliser une POSIX mise en œuvre, où u_int8_t est obligatoire 😉
    • Si vous avez juste besoin de l'arithmétique modulo, unsigned champ de bits fera l'affaire (si gênant). C'est quand vous avez besoin, disons, un tableau d'octets sans rembourrage, que vous êtes SOL. Morale de l'histoire n'est pas de code pour les Dsp, et s'en tenir à bonne, honnête à Dieu de 8 bits char architectures 🙂
    • Malheureusement, alors que la Norme exigerait que si uint8_t existe, alors unsigned char doit également être de 8 bits, il ne serait pas interdire une mise en œuvre de la fabrication de uint8_t 8 bits étendu de type entier. Il serait vraiment utile d'avoir un 8 bits type non signé qui ne reçoit pas le spécial aliasing traitement unsigned char, et rien n'interdirait de mise en œuvre de la fabrication de uint8_t être un tel type [à mon humble avis, la bonne manière de définir ce type serait de lui donner un nom spécial qui pourrait être un alias de uint8_t sur des implémentations qui prennent en charge les derniers...
    • ...mais n'ont pas un non-aliasing 8 bits type].

    InformationsquelleAutor Pavel Minaev
  7. 3

    Qui est vraiment important, par exemple lors de l'écriture d'un analyseur de réseau.
    en-têtes de paquets sont définies par la spécification de protocole, pas par le moyen d'une plate-forme particulière compilateur C fonctionne.

    • quand j'ai demandé ce que j'étais, definint un protocole simple pour communticaion série.
    InformationsquelleAutor VP.
  8. 2

    Sur presque tous les systèmes que j'ai rencontré u_int8_t == unsigned char, mais ce n'est pas garanti par la norme. Si vous essayez d'écrire du code portable et il est important, exactement ce que la taille de la mémoire, utilisez u_int8_t. Sinon utiliser unsigned char.

    • uint8_t toujours correspond à la gamme et la taille de unsigned char et le rembourrage (aucun) lorsque unsigned char est de 8 bits. Lorsque unsigned char n'est pas de 8 bits, uint8_t n'existe pas.
    • Avez-vous une référence à l'endroit exact dans le standard, où il est dit que? Si unsigned char est de 8 bits, est uint8_t la garantie d'une typedef de celle-ci et pas un typedef d'un étendu unsigned integer?
    • place dans le standard, où il est dit que?" --> Pas encore regarder 7.20.1.1. Il est facilement déduire que unsigned char/signed char/char sont les plus petits de type ni inférieure à 8 bits. unsigned char a pas de rembourrage. Pour uint8_t être, il doit être de 8 bits, pas de rembourrage, existent en raison d'une mise en œuvre à condition de type entier: il correspond aux exigences minimales en matière de unsigned char. Quant à "... la garantie d'une définition de type..." ressemble à une bonne question à poste.
    InformationsquelleAutor atlpeg