unsigned int vs size_t

Je remarque que la modernité de code C et C++ semble utiliser size_t au lieu de int/unsigned int un peu partout - à partir de paramètres pour C les fonctions de chaîne à la STL. Je suis curieux de savoir la raison de cette et les avantages qu'elle apporte.

InformationsquelleAutor Rob | 2008-09-25
  1. 376

    La size_t type est le type entier non signé qui est le résultat de la sizeof de l'opérateur (et le offsetof de l'opérateur), de sorte qu'il est garanti d'être assez grand pour contenir la taille du plus grand objet de votre système (par exemple, un tableau statique de 8 go).

    La size_t type peut être plus grande que, égal ou plus petit qu'un unsigned int, et votre compilateur peut faire des hypothèses à ce sujet pour l'optimisation.

    Vous pouvez trouver plus d'informations précises dans le standard C99, section 7.17, dont un projet est disponible sur Internet dans pdf format, ou dans la norme C11, l'article 7.19, également disponible en tant que pdf projet.

    • Nope. Pensez x86-16 avec la grande (pas énorme) modèle de mémoire: les Pointeurs sont loin (32 bits), mais les objets sont limités à 64 ko (donc size_t peut être de 16 bits).
    • "taille de la plus grosse objet" n'est pas mauvaise formulation, mais tout à fait correcte. La sixe d'un objet peut être beaucoup plus limité que celui de l'adresse de l'espace.
    • "votre compilateur peut faire l'hypothèse à ce sujet": j'espère que le compilateur le sait de la gamme exacte des valeurs qui size_t peut représenter! Si elle ne le fait pas, qui le fait?
    • Je pense que le point est plus, que le compilateur pourrait être en mesure de faire quelque chose en connaissance de cause.
    • Je souhaite juste que ce de plus en plus populaire type de ne pas exiger l'inclusion d'un fichier d'en-tête.
    • En fait, les compilateurs généralement à prendre de meilleures optimisations lors de la pas à l'aide de size_t, parce que les types non signés sont plus strictement défini et donc (dans certaines circonstances) vérifier, pour dépassement de capacité, entre autres choses. Comparé à d'autres types non signés, les opérations simples comme pointeur/tableau d'indexation peut-être encore plus rapide, parce que le compilateur pourrait par exemple ne pas avoir à convertir les entiers 64 bits en premier (si votre PROCESSEUR n'effectue de l'arithmétique des pointeurs en 64 bits).
    • En plus de cela, l'adresse de l'espace est rarement plus de 48 bits en 64 bits, donc à moins d'avoir besoin d'accéder à plus de 2 * sizeof(T) GO d'éléments, je vous recommande fortement de stockage de votre tableau des tailles et des indices comme int au lieu de size_t chaque fois que vous pouvez sortir avec elle. Peut vous faire économiser jusqu'à 50% de la mémoire, et peut même accélérer la vitesse de votre code.
    • Tant qu'il est non signé sûr. Mais non signée. Il y a beaucoup de problèmes avec signés y compris les poussières de se plaindre. Bien sûr, cela ne signifie pas que l'on peut facilement prendre de l'ancien code qui utilise ints et de les changer tous les non signé, sans aucun problème. Je suis d'accord qu'il ya des moments où un int a ses mérites (y compris le fait que certains appels les utiliser comme de la prise de fonctions!) mais il n'est pas toujours une décision facile à prendre (bien que parfois il est facile de faire).

    InformationsquelleAutor Remo.D
  2. 97

    Classique C (le début du dialecte de C décrite par Brian Kernighan et Dennis Ritchie dans Le Langage de Programmation C, Prentice-Hall, 1978) n'a pas fournir size_t. Le C comité des normes introduites size_t pour éliminer un problème de portabilité

    Expliqué en détail lors de embedded.com (avec un très bon exemple)

    InformationsquelleAutor azeemarif
  3. 72

    En bref, size_t n'est jamais négatif, et il optimise les performances, car il est typedef pour être le type entier non signé qui est assez grand, mais pas trop grand -- pour représenter la taille de la plus grande possible de l'objet sur la plate-forme cible.

    Tailles ne doivent jamais être négatif, et en effet size_t est un type non signé. Aussi, parce que size_t est pas signé, vous pouvez stocker les numéros qui sont à peu près deux fois plus grande que dans le type signé, parce que nous pouvons utiliser le bit de signe pour représenter l'ampleur, comme tous les autres bits de l'entier non signé. Quand nous gagnons un peu plus, nous sommes en multipliant la plage de nombres, nous pouvons représente par un facteur de deux.

    Donc, vous demandez-vous, pourquoi ne pas simplement utiliser un unsigned int? Il peut ne pas être en mesure de tenir assez grand nombre. Dans une application où unsigned int est de 32 bits, le plus grand nombre, il peut représenter est 4294967295. Certains processeurs, tels que la IP16L32, vous pouvez copier des objets de plus de 4294967295 octets.

    Donc, vous demandez-vous, pourquoi ne pas utiliser un unsigned long int? Elle exige une performance sans frais sur certaines plates-formes. C Standard exige qu'un long occuper au moins 32 bits. Un IP16L32 plate-forme met en œuvre chaque long 32 bits comme une paire de mots de 16 bits. Presque tous les 32-bit les opérateurs sur ces plates-formes ont besoin de deux instructions, si pas plus, parce qu'ils travaillent avec le 32 bits dans deux de 16 bits morceaux. Par exemple, le déplacement d'un long 32 bits nécessite généralement deux instructions machine, l'une pour le déplacement de chaque 16 bits morceau.

    À l'aide de size_t évite cette performance sans frais. Selon ce fantastique article, "Type size_t est une définition de type qui est un alias pour certains type entier non signé, généralement unsigned int ou unsigned long, mais peut-être même unsigned long long. Chaque Norme C mise en œuvre est censé choisir le nombre entier non signé qui est assez grand--mais pas plus grand que nécessaire--pour représenter la taille de la plus grande possible de l'objet sur la plate-forme cible."

    • Désolé pour commenter cet après autant de temps, mais j'ai juste eu à confirmer le plus grand nombre qu'un unsigned int peut contenir - je suis peut-être un malentendu votre terminologie, mais je pensais que le plus grand nombre un unsigned int peut contenir est 4294967295, 65356 étant le maximum d'un court non signé.
    • Si votre unsigned int occupe 32 bits, alors oui, le plus grand nombre, il peut contenir est de 2^32 - 1, qui est 4294967295 (0xffffffff). Avez-vous une autre question?
    • Pas d'autres questions, j'étais juste curieux de savoir pourquoi vous avez utilisé 65,356 qui impliquerait un 16 bits unsigned int, que je n'ai jamais connu d'être le cas le plus fréquent, par tout moyen.
    • La plus grande valeur qui peut être représenté dans un unsigned int peut varier d'un système à l'autre. Il est nécessaire de au moins 65536, mais il est communément 4294967295 et pourrait être 18446744073709551615 (2**64-1) sur certains systèmes.
    • Oh ok. Est-il une norme ou quelque chose qui dicte qu'il soit au moins 65536? Aussi, je viens de réaliser que j'ai écrit 65356 au lieu de 65 536 - oups!
    • DANS cet article , il est dit que: l'Utilisation de unsigned int comme le type de paramètre, comme dans: void *memcpy(void *s1, const void *s2, unsigned int n); œuvres de dandy sur toute plate-forme dans lequel un unsigned int peut représenter la taille de la plus grande base de données de l'objet. Alors peut-on dire size_t = unsigned int . Peut-on dire qu'il n'y a pas de différence entre eux? (mon pc est en 32 bits)
    • La plus grande valeur de 16 bits unsigned int peut contenir est de 65535, pas 65536. Une petite mais importante différence que 65536 est le même que 0 en 16 bits unsigned int.
    • La norme "ou quelque chose" qui dicte qu'un unsigned int doit être capable de tenir au moins de 65 536 valeurs différentes est la Norme (la Norme C++, dit la même chose).
    • Êtes-vous sûr de la norme C++? Après avoir cherché pendant un certain temps j'ai l'impression qu'ils ont tout simplement supprimé toutes les garanties absolues sur entier plages (à l'exclusion des unsigned char). La norme ne semble pas contenir la chaîne de caractères "65535" ou "65536" n'importe où, et '+32767' ne se produit (1.9:9) dans une note que possible le plus grand entier représentable dans int; aucune garantie n'est donnée même que INT_MAX ne peut pas être plus petit que!
    • dans 18.3.3/2, C++11 standard dit à propos de <climits>: "Le contenu est le même que la bibliothèque Standard C de l'en-tête <limits.h>". J'avais suppose que les exigences en termes de contenu sont les mêmes. C99 dit dans 5.2.4.2.1/1 "Leur mise en œuvre-la définition des valeurs doit être égale ou de plus grande ampleur (valeur absolue) à celles indiquées, avec le même signe.", suivi par les valeurs elles-mêmes.
    • Pas nécessairement. Vérifier la valeur de SIZE_MAX et UINT_MAX et tout en elle ULONG_MAX (voir les fichiers d'en-tête stdint.h et limits.h). Bien sûr, c'est pour le C - j'ai eu une très mauvaise réaction de C++, mais même alors, il y a toujours des limites.

    InformationsquelleAutor Rose Perrone
  4. 50

    Le type size_t est le type retourné par l'opérateur sizeof. Il est un entier non signé capable d'exprimer la taille en octets de mémoire pris en charge sur la machine hôte. Il est (généralement) liées à ptrdiff_t dans ce ptrdiff_t est un entier signé valeur tels que sizeof(ptrdiff_t) et sizeof(size_t) sont égaux.

    Lors de l'écriture de code C, vous devez toujours utilisation size_t chaque fois que de traiter avec des plages de mémoire.

    Le type int sur l'autre main est essentiellement définie comme la taille de l' (signé) valeur entière que la machine hôte peut utiliser le plus efficacement possible d'effectuer l'arithmétique des nombres entiers. Par exemple, sur de nombreux anciens de type PC ordinateurs de la valeur de sizeof(size_t) serait de 4 (octets), mais sizeof(int) serait de 2 (octet). 16 bits arithmétique a été plus rapide que le 32 bits, l'arithmétique, bien que le PROCESSEUR peut gérer une (logique) de l'espace mémoire de 4 Go.

    Utiliser le type int seulement quand vous vous souciez de l'efficacité réelle de la précision dépend fortement sur les deux options du compilateur et de l'architecture de la machine. En particulier, la norme spécifie les éléments suivants invariants: sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) sans autres limitations de la représentation réelle de la précision à la disposition du programmeur pour chacun de ces types de primitives.

    Remarque: Ce n'est PAS le même qu'en Java (ce qui indique le peu de précision pour chacun des types de 'char', 'octet', 'courte', 'int' et 'long').

    • la définition de facto de type int, c'est que c'est 16 bits sur 16 machines et 32 bits sur quelque chose de plus grand. Trop de code qui a été écrit, qui supposent que l'int est de 32 bits de large, pour changer cela maintenant, et comme un résultat, les gens devraient toujours utiliser size_t ou {u}int{8,16,32,64}_t si ils veulent quelque chose de spécifique, comme une mesure de précaution, les gens devraient toujours utiliser ceux-ci, au lieu de l'intégrale types d'entiers.
    • "C'est un entier non signé capable d'exprimer la taille en octets de mémoire pris en charge sur la machine hôte." --> Pas de. size_t est capable de représenter la taille d'un objet unique (par exemple: nombre, tableau, structure). L'ensemble de la plage de mémoire peut dépasser size_t
    InformationsquelleAutor Kevin S.
  5. 23

    Type size_t doit être assez grand pour stocker la taille de n'importe quel objet possible. Unsigned int n'a pas à satisfaire à cette condition.

    Par exemple dans les systèmes 64 bits int et unsigned int peut être de 32 bits de large, mais size_t doit être assez grand pour stocker des nombres plus grands que la 4G

    • "objet" est la langue utilisée par la norme.
    • Je pense que size_t aurait seulement besoin d'être grand si le compilateur pourrait accepter un type de X tels que sizeof(X) donnerait une valeur plus grande que la 4G. La plupart des compilateurs de se faire rejeter par exemple typedef unsigned char foo[1000000000000LL][1000000000000LL], et même foo[65536][65536]; pourrait légitimement être rejeté s'il a dépassé une documentation de mise en œuvre-limite définie.
    • La formulation est très bien. "Objet" n'est pas vague du tout, mais plutôt la définition de "zone de stockage".
    InformationsquelleAutor Maciej Hehl
  6. 4

    Cet extrait de la glibc manuel de 0,02, peuvent également être utiles lors de la recherche de la rubrique:

    Il y a un problème potentiel avec le type size_t et versions de GCC avant la version 2.4. ANSI C exige que size_t toujours être d'un type non signé. Pour la compatibilité avec les systèmes de fichiers d'en-tête, GCC définit size_t dans stddef.h' to be whatever type the system'ssys/types.h' définit qu'il soit. La plupart des systèmes Unix qui définissent size_t dans `sys/types.h', de définir un type signé. Un peu de code dans la bibliothèque dépend size_t être un type non signé, et ne fonctionnera pas correctement si elle est signée.

    La bibliothèque C de GNU code, qui prévoit que la size_t être non signé est correct. La définition de size_t comme un type signé est incorrect. Nous prévoyons que dans la version 2.4, GCC sera toujours définir size_t comme un type non signé, et la fixincludes' script will massage the system'ssys/types.h " afin de ne pas entrer en conflit avec cette.

    Dans l'intervalle, nous contourner ce problème en disant GCC explicitement à l'utilisation d'un type non signé pour size_t lors de la compilation de la bibliothèque C de GNU. "configurer" détecte automatiquement quel type de GCC utilise pour size_t organiser pour le remplacer si nécessaire.

    InformationsquelleAutor Graeme Burke
  7. 2

    Si mon compilateur est de 32 bits, size_t est rien d'autre qu'un typedef pour unsigned int. Si mon compilateur est réglé sur 64 bits, size_t est rien d'autre qu'un typedef pour unsigned long long.

    • Peut être simplement définie comme unsigned long pour les deux cas sur certains Systèmes d'exploitation.
    InformationsquelleAutor Zebrafish
  8. -3

    size_t est la taille d'un pointeur.

    Donc en 32 bits ou la commune ILP32 (integer, long, pointeur) modèle size_t est de 32 bits.
    et en 64 bits ou la commune LP64 (long, pointeur) modèle size_t est de 64 bits (entiers sont encore en 32 bits).

    Il y a d'autres modèles, mais ce sont ceux que g++ utilisation (au moins par défaut)

    • size_t n'est pas nécessairement la même taille qu'un pointeur, mais il est généralement. Un pointeur doit être capable de pointer vers n'importe quel emplacement mémoire; size_t ne doit être suffisamment grand pour représenter la taille de la plus grande d'un seul objet.
    InformationsquelleAutor