Qu'est-ce que size_t en C?

Je suis de se confondre avec l' size_t en C. je sais que c'est renvoyé par la sizeof de l'opérateur. Mais qu'en est-il exactement? Est-il un type de données?

Disons que j'ai un for boucle:

for(i = 0; i < some_size; i++)

Dois-je utiliser int i; ou size_t i;?

  • Si ce sont vos seules options, utilisez int si some_size est signé, size_t si elle n'est pas signée.
  • C'est incorrect. POSIX a un ssize_t type, mais le fait correct à utiliser est ptrdiff_t.
InformationsquelleAutor Vijay | 2010-03-31
  1. 420

    À Partir De Wikipedia:

    Selon l'1999 ISO C standard
    (C99), size_t est un entier non signé
    type d'au moins 16 bits (voir les sections
    7.17 et 7.18.3).

    size_test un type de données non signé
    défini par plusieurs C/C++ normes,
    par exemple, le C99 ISO/IEC 9899 standard,
    qui est définie dans stddef.h.Un Il peut
    encore être importés par l'inclusion de
    stdlib.h comme ce fichier en interne sous
    comprend stddef.h.

    Ce type est utilisé pour représenter l'
    de la taille d'un objet. Les fonctions de la bibliothèque
    que prendre ou de retour de tailles attendre d'eux
    pour être de type ou de retour de type
    de size_t. En outre, la plupart des
    fréquemment utilisé par le compilateur en fonction
    l'opérateur sizeof doit correspondre à une
    la valeur de la constante qui est compatible avec
    size_t.

    Comme conséquence, size_t est un type de garantie afin de conserver tous les index de tableau.

    • "Bibliothèque de fonctions ou de retour de tailles s'attendre à être de type ... size_t" Sauf que stat() utilise off_t de la taille d'un fichier
    • Ce commentaire reflète une confusion fondamentale. size_t est pour les objets en mémoire. La norme n'a même pas définir stat() ou off_t (ceux qui sont POSIX définitions) ou quelque chose à faire avec des disques ou des systèmes de fichiers - il s'arrête de lui-même à FILE ruisseaux. De gestion de mémoire virtuelle est complètement différent de systèmes de fichiers et de gestion de fichiers taille des exigences, afin de mentionner off_t est pas pertinente ici.
    • J'ai peine à appeler ça une confusion fondamentale, mais vous faites un point intéressant. Encore, le texte cité ne dit pas "les tailles des objets en mémoire", et "offset" est à peine un bon nom pour un type taille, peu importe où il se trouve à être stockés.
    • Bon point. Cette réponse citations de Wikipédia, qui dans ce cas n'ont pas la meilleure explication, à mon avis. La norme elle-même est beaucoup plus clair: il définit size_t que le type du résultat de la sizeof opérateur (7.17p2 sur <stddef.h>). La Section 6.5 explique exactement comment C les expressions de travail (6.5.3.4 pour sizeof). Puisque vous ne pouvez pas appliquer sizeof dans un fichier sur disque (surtout parce que C n'a même pas de définir la façon dont les disques et les fichiers de travail), il n'y a pas de place pour la confusion. En d'autres termes, la faute à Wikipédia (et cette réponse pour la citation de Wikipédia et non le C standard).
    • Je suis également d'accord avec la "confusion fondamentale" de l'évaluation. Si vous n'avez pas lu le C/C++ normes, vous pourriez penser "objet" désigne la "programmation orientée objet", auquel il ne le fait pas. Lire le C standard, qui n'en a aucun de ceux de la programmation orientée objet les objets, mais des objets, et la retrouver. La réponse pourrait vous surprendre!
    • Il est également intéressant de noter que size_t est (presque certainement) un typedef pour certains type entier non signé. Par exemple, size_t est généralement du même type que unsigned long (un typedef crée un alias pour un type existant, pas d'un nouveau type). Mais vous ne devriez pas supposer que size_t est le même que n'importe quel type particulier, puisqu'il peut varier d'un système à l'autre.
    • ainsi, le 16 bits signifie que ses juste un unsigned short?
    • Eh bien, sizeof me dit qu'il est de 8 octets, donc certainement plus grand que 16 bits, au moins pour moi.

    InformationsquelleAutor sblom
  2. 203

    size_t est un type non signé. Donc, il ne peut pas représenter toutes les valeurs négatives(<0). Vous l'utilisez lorsque vous êtes en comptant quelque chose, et que vous êtes sûr qu'il ne peut pas être négative. Par exemple, strlen() renvoie une size_t, car la longueur d'une chaîne de caractères doit être d'au moins 0.

    Dans votre exemple, si votre indice de boucle va être toujours supérieure à 0, il pourrait être judicieux d'utiliser size_t, ou de toute autre unsigned type de données.

    Lorsque vous utilisez un size_t objet, vous devez vous assurer que dans tous les contextes, il est utilisé, y compris l'arithmétique, vous voulez valeurs non négatives. Par exemple, disons que vous avez:

    size_t s1 = strlen(str1);
size_t s2 = strlen(str2);

    et vous voulez savoir la différence de la longueur des str2 et str1. Vous ne pouvez pas faire:

    int diff = s2 - s1; /* bad */

    C'est parce que la valeur attribuée à diff est toujours un nombre positif, même lorsque s2 < s1, parce que le calcul est fait avec des types non signés. Dans ce cas, selon ce que votre cas d'utilisation, vous pourriez être mieux à l'aide de int (ou long long) pour s1 et s2.

    Il y a quelques fonctions en C/POSIX qui pourrait/devrait utiliser size_t, mais n'est pas à cause de raisons historiques. Par exemple, le deuxième paramètre à fgets devrait idéalement être size_t, mais est int.

    • Deux questions: 1) quelle est la taille de size_t? 2) pourquoi devrais-je préfère size_t plus de quelque chose comme unsigned int?
    • size_t n'est pas garanti d'être la même chose que unsigned int (vous semblent être ce qui implique qu'ils sont les mêmes).
    • la taille de size_t est sizeof(size_t). La norme garantit que SIZE_MAX sera au moins égale à 65 535. size_t est le type retourné par sizeof opérateur, et est utilisé dans la bibliothèque standard (par exemple strlen retourne size_t). Comme Brendan dit, size_t n'a pas besoin d'être le même que unsigned int.
    • Long: Quand vous dites size_t n'est pas le même que unsigned int, je suppose que vous voulez dire qu'il n'est pas garanti d'être un int, mais il est en fait unsigned. Est-ce vrai?
    • oui, size_t est garanti d'être un type non signé.
    • merci!
    • s2 - s1 n'est pas toujours va être un nombre positif.
    • c'était mon point. Si s1 et s2 sont à la fois d'un type non signé (size_t par exemple), le résultat s1-s2 pas être négatif, même lorsque s1 < s2. C'est parce que les types non signés n'ont pas de valeurs négatives. Lorsque vous attribuer cette différence à une int, le résultat est la mise en œuvre définies. Qui était le point entier de dire que l'on ne veut pas prendre la différence des types non signés dans mon exemple, parce que l'on a d'être en mesure d'obtenir de façon portable la possible différence négative.
    • "Donc, il peut représenter des valeurs non négatives" ne pas vous dire ne peut pas?
    • non, je veux dire qu'un type non signé ne peuvent que représenter les valeurs non négatives. Je devrais probablement avoir dit: "Il ne peut pas représenter les valeurs négatives".
    • C'est parce que s2 - s1 est PAS va toujours être un nombre positif (par exemple, s2=5; s1=20; s2-s1=-15)
    • J'ai précisé qu'une partie de ma réponse.
    • Gardez à l'esprit que sur Linux 64-bit int est toujours en 32 bits, mais size_t est de 64 bits. Donc, size_t et int ne sont PAS interchangeables.
    • Si pour des raisons de ce que jamais vous avez besoin de taille à être signé, il y a ssize_t type sur Linux.
    • Ce n'est pas comment en complément à deux oeuvres! size_t s2 = 5, s1 = 20; int diff = s2 - s1; printf("%d: %x\n", diff, diff < 0); Cette affiche exactement ce que vous attendez: "-15: 1"
    • en complément à deux n'est pas une exigence de la norme. Si la valeur de s2 - s1 déborde un int, le comportement est indéfini.
    • Pour être pointilleux sur le C les spécifications, vous avez raison. La réalité est que le complément est limitée à un petit nombre de historique mainframes et quelques applications spécialisées comme la Can. En complément à deux est tellement répandue, en fait, que c'est un de facto standard. Des débordements d'entiers peuvent être dangereux, mais la portée va au-delà de mélange des signes.

    InformationsquelleAutor Alok Singhal
  3. 67

    size_t est un type qui peut contenir n'importe quel tableau d'index.

    En fonction de la mise en œuvre, il peut être tout de:

    unsigned char

    unsigned short

    unsigned int

    unsigned long

    unsigned long long

    Voici comment size_t est défini dans stddef.h de ma machine:

    typedef unsigned long size_t;
    • Certainement typedef unsigned long size_t est dépendant du compilateur. Ou êtes-vous croire qu'il est toujours ainsi?
    • En effet, juste parce que l'on définit la mise en œuvre en tant que telle ne signifie pas toutes les faire. Affaire au point: 64-bit de Windows. unsigned long est de 32 bits, size_t est de 64 bits.
    • quel est le but de size_t exactement? Quand je peux créer une variable pour moi-même comme: "int mysize_t;" ou "long mysize_t" ou "unsigned long mysize_t". Pourquoi quelqu'un devrait avoir créé cette variable pour moi?
    • n'est pas une variable. C'est un type que vous pouvez utiliser lorsque vous voulez vous représenter la taille d'un objet en mémoire.
    • est-il vrai que size_t est toujours 32bits sur 32 bits machine 64bits de même?
    • "Selon l'1999 ISO standard C (C99), size_t est un type entier non signé de 16 bits (voir les sections 7.17 et 7.18.3)." Donc il ne peut pas être un unsigned char?
    • Je ne suis pas sûr de la 16 bits de restriction est vrai. uint_least16_t est ce qu'au moins 16 bits. À propos, size_t, le standard dit "non signé intégrale type du résultat de l'opérateur sizeof" et "L'opérateur sizeof donne la taille (en octets) de son opérande".
    • qui dit unsigned char ne peut pas être de 16 bits?!
    • c'est un bon point; apparemment, la garantie est que unsigned char contient au moins les valeurs 0-255.

    InformationsquelleAutor Arjun Sreedharan
  4. 63

    Si vous êtes le empiriques de type,

    echo | gcc -E -xc -include 'stddef.h' - | grep size_t

    De sortie pour Ubuntu 14.04 64 bits GCC 4.8:

    typedef long unsigned int size_t;

    Noter que stddef.h est fourni par GCC et non de la glibc sous src/gcc/ginclude/stddef.h dans GCC 4.2.

    Intéressant C99 apparences

    • malloc prend size_t comme argument, il détermine la taille maximale pouvant être alloués.

      Et depuis il est également renvoyé par sizeof, je pense qu'il limite la taille maximale d'un tableau.

      Voir aussi: Quelle est la taille maximale d'un tableau en C?

    • J'ai le même environnement, cependant, je l'ai testé pour le 32 bits, le passage du CCG "-m32" option, le résultat a été: "typedef unsigned int size_t". Merci pour ce partage génial commande @Ciro, il m'a beaucoup aidé! 🙂
    • La matière elle-même n'est pas source de confusion. C'est la confusion de l'esprit qui tente de poser beaucoup de questions, et donner beaucoup de réponses. Je suis surpris de cette réponse et de l'un par Arjun Sreedharan toujours de ne pas empêcher les gens de poser et de répondre.
    • Super réponse, parce qu'elle vous dit ce size_t est, au moins sur la populaire distribution Linux.
    InformationsquelleAutor Ciro Santilli 新疆改造中心996ICU六四事件
  5. 21

    La page de manuel pour les types.h dit:

    size_t est un type entier non signé

    InformationsquelleAutor codaddict
  6. 15

    Puisque personne n'a encore mentionné, le principal linguistique de la signification de size_t est que le sizeof opérateur renvoie une valeur de ce type. De même, l'importance de ptrdiff_t est que la soustraction d'un pointeur à partir d'un autre donnera une valeur de ce type. Bibliothèque de fonctions qui acceptent de le faire, car il va permettre de telles fonctions pour travailler avec des objets dont la taille dépasse UINT_MAX sur les systèmes sur lesquels de tels objets existent, sans forcer les appelants pour le code déchets en passant d'une valeur supérieure à "unsigned int" sur les systèmes où le plus grand type suffirait pour que tous les objets possibles.

    • Ma question a toujours été: Si sizeof n'a jamais existé, aurait-il un besoin pour size_t?
    • Peut-être pas, mais il y aurait alors une question de ce type d'argument doit être utilisé pour des choses comme malloc(). Personnellement, j'aurais aimé avoir vu les versions qui prennent des arguments de type int, long, et long long, avec certaines implémentations de la promotion de la plus courte des types et des autres, la mise en œuvre par exemple lmalloc(long n) {return (n < 0 || n > 32767) ? 0 : imalloc(n);} [sur certaines plates-formes, appelant à imalloc(123) serait moins cher que d'appeler lmalloc(123);, et même sur une plate-forme où size_t est de 16 bits, le code qui souhaite allouer la taille calculée dans une "longue" de la valeur...
    • ...devrait être en mesure de s'appuyer sur l'allocation de défaut si la valeur est plus grande que l'allocateur peut gérer.
    InformationsquelleAutor supercat
  7. 7

    size_t et int ne sont pas interchangeables. Par exemple, sur Linux 64 bits size_t est de 64 bits (c'est à dire sizeof(void*)) mais int est de 32 bits.

    Également noter que size_t est pas signé. Si vous avez besoin signé, puis il est ssize_t sur certaines plates-formes et il serait plus pertinent de votre exemple.

    En règle générale, je voudrais suggérer à l'aide de int pour la plupart des cas généraux et d'utiliser uniquement size_t/ssize_t lorsqu'il existe un besoin pour elle (avec mmap() par exemple).

    InformationsquelleAutor dtoux
  8. 4

    Aller dans pourquoi size_t besoin d'exister et comment nous en sommes arrivés là:

    Pragmatique, size_t et ptrdiff_t sont garantis 64 bits sur une version 64 bits de mise en œuvre, 32 bits de large sur 32 bits et la mise en œuvre, et ainsi de suite. Ils ne pouvaient pas la force de tout type existant pour dire que, sur chaque compilateur, sans enfreindre le code de legs.

    Un size_t ou ptrdiff_t n'est pas nécessairement la même que pour un intptr_t ou uintptr_t. Ils étaient différents sur certaines architectures qui étaient encore en usage lors de la size_t et ptrdiff_t ont été ajoutées à la Norme à la fin des années ’80, et de devenir obsolète quand C99 a ajouté beaucoup de nouveaux types, mais pas encore parti (comme Windows 16 bits). Le x86 16 bits en mode protégé avait une segmentation de la mémoire, où le plus grand nombre possible de tableau ou de la structure pourrait être seulement de 65 536 octets la taille, mais un far pointeur nécessaires à 32 bits de large, plus large que les registres. Sur ceux, intptr_t aurait été de 32 bits de large, mais size_t et ptrdiff_t pourrait être de 16 bits de large et s'inscrire dans un registre. Et qui savait ce type de système d'exploitation peut être écrit dans l'avenir? En théorie, l'architecture i386 propose une version 32 bits de modèle de segmentation avec 48 bits pointeurs qu'aucun système d'exploitation n'a jamais réellement utilisé.

    Le type d'un décalage mémoire n'a pas pu être long parce que beaucoup trop de code hérité suppose que long est exactement 32 bits de large. Cette hypothèse a même été intégré dans les environnements UNIX et Windows Api. Malheureusement, beaucoup d'autres l'héritage de code suppose également qu'une long est assez large pour contenir un pointeur, un fichier de contrepartie, le nombre de secondes qui se sont écoulées depuis 1970, et ainsi de suite. POSIX maintenant fournit une méthode normalisée pour la force de cette dernière hypothèse soit vraie place de l'ancien, mais il n'est ni un portable hypothèse à faire.

    Il ne pouvait pas être int parce que seule une petite poignée de compilateurs dans les années ’90 fait int 64 bits de large. Puis ils vraiment se sont bizarres en gardant long 32 bits de large. La prochaine révision de la Norme déclaré illégal pour int à être plus large que long, mais int est toujours de 32 bits de large sur la plupart des systèmes 64 bits.

    Il ne pouvait pas être long long int, qui de toute façon a été ajoutée plus tard, depuis qu'a été créé pour être au moins 64 bits, même sur les systèmes 32 bits.

    Ainsi, un nouveau type a été nécessaire. Même si ce n'était pas le cas, tous ceux d'autres types signifiait autre chose que d'un décalage à l'intérieur d'un tableau ou d'un objet. Et si il y avait une leçon à tirer de l'fiasco de 32 à 64 bits de la migration, c'était d'être précis sur ce que les propriétés d'un type de besoin d'avoir, et de ne pas utiliser l'un qui signifie différentes choses dans différents programmes.

    InformationsquelleAutor Davislor
  9. 3

    En général, si vous êtes en commençant à 0 et allez vers le haut, toujours utiliser un type non signé afin d'éviter un débordement de vous emmenant à une valeur négative de la situation. Cela est extrêmement important, parce que si votre limites du tableau se trouve être inférieur au max de votre boucle, mais votre boucle max arrive à être plus grande que le maximum de votre type, vous enrouler autour de négatif et vous pouvez rencontrer un erreur de segmentation (SIGSEGV). Donc, en général, ne jamais utiliser d'int pour une boucle commençant à 0 et va vers le haut. Utiliser un unsigned.

    • Je ne peux pas accepter votre argumentation. Vous dites que c'est mieux que le bogue de dépassement silencieusement conduit à l'accès à des données valides au sein de votre tableau?
    • est correcte. si l'erreur passe inaperçue, elle la rend pire qu'un plantage du programme. pourquoi cette réponse a obtenu upvotes?
    • Si elle accède à la validité des données dans votre tableau puis c'est pas un bug car type non signé ne débordera pas à la limite signé type. Qu'est-ce que cette logique les gars? Disons que pour une raison quelconque vous utilisez char à itérer sur 256 élément de tableau... signé un débordement à 127 et 128e élément sigsegv, mais si vous utilisez non signé, alors il faudra passer par toute la gamme comme prévu. Puis, quand vous êtes à l'aide d'un int, vos tableaux ne sera pas vraiment plus de 2 milliards d'éléments, donc de toute façon c'est pas grave...
    • Je ne peux pas imaginer une situation dans laquelle débordement d'entier n'est pas un bug, qu'il enroule autour de positif ou de négatif. Juste parce que vous n'obtenez pas une erreur de segmentation ne signifie pas que vous voir le comportement correct! Et vous pouvez rencontrer une erreur de segmentation, ou pas, si votre décalage est positif ou négatif, tout dépend de votre disposition de la mémoire. @PurpleIce, je ne pense pas que vous êtes en train de dire la même chose que cette réponse; votre argument semble être que vous devez choisir un type de données suffisamment grand pour contenir la plus grande valeur que vous souhaitez y mettre, ce qui est tout simplement du bon sens.
    • Cela dit, je préfère à l'aide d'un type non signé pour les indices de boucle sémantique; si la variable n'est jamais négatif, alors vous pourriez aussi bien indiquer que, dans le type que vous choisissez. Elle pourrait aussi permettre au compilateur de détecter un bug où la valeur est terminé négatif, mais GCC au moins est assez terrible pour repérer cette erreur (un jour, j'ai initialisé un unsigned à -1 et ne pas obtenir un message d'avertissement). De même, un size_t est sémantiquement approprié pour les indices de tableau.
    InformationsquelleAutor Mark
  10. 2

    size_t est entier non signé de type de données. Sur les systèmes à l'aide de la Bibliothèque C de GNU, ce sera unsigned int ou unsigned longue int. size_t est couramment utilisé pour le tableau d'indexation et boucle de comptage.

    InformationsquelleAutor Prince
  11. 1

    size_t ou tout type non signé peut être vu utilisé comme variable de boucle en boucle variables sont généralement supérieur ou égal à 0.

    Lorsque nous utilisons un size_t objet, nous devons nous assurer que, dans tous les contextes, il est utilisé, y compris l'arithmétique, nous ne voulons que la non-valeurs négatives. Par exemple, à la suite du programme serait certainement donner le résultat inattendu:

    //C program to demonstrate that size_t or
//any unsigned int type should be used 
//carefully when used in a loop

#include<stdio.h>
int main()
{
const size_t N = 10;
int a[N];

//This is fine
for (size_t n = 0; n < N; ++n)
a[n] = n;

//But reverse cycles are tricky for unsigned 
//types as can lead to infinite loop
for (size_t n = N-1; n >= 0; --n)
printf("%d ", a[n]);
}

Output
Infinite loop and then segmentation fault
    InformationsquelleAutor bishwas pokharel
  12. -4

    À partir de ma compréhension, size_t est un unsigned entier dont la taille en bits est assez grand pour contenir un pointeur de l'architecture native.

    Donc:

    sizeof(size_t) >= sizeof(void*)
    • Pas vrai. La taille du pointeur peut être plus grand que le size_t. Plusieurs exemple: les compilateurs C sur x86 en mode réel peut avoir 32 bits FAR ou HUGE pointeurs mais size_t est encore en 16 bits. Un autre exemple: Watcom C permet d'avoir une graisse spéciale pointeur de la mémoire étendue qui était de 48 bits de large, mais size_t ne l'était pas. Sur le contrôleur embarqué avec Harvard architecture, vous n'avez pas de corrélation soit, parce que les deux préoccupations différentes des espaces d'adressage.
    • Et sur ce stackoverflow.com/questions/1572099/... il y a plus d'exemples sur l'as/400 avec 128 bits pointeurs et 32 bits size_t
    • C'est totalement faux. Cependant, nous allons le garder ici
    InformationsquelleAutor David Zechiel