Quand dois-je utiliser std::size_t?

Je me demande dois-je utiliser std::size_t pour des boucles et des trucs au lieu de int?
Par exemple:

#include <cstdint>

int main()
{
    for (std::size_t i = 0; i < 10; ++i) {
        //std::size_t OK here? Or should I use, say, unsigned int instead?
    }
}

En général, quelles sont les bonnes pratiques quant à l'utilisation std::size_t?

InformationsquelleAutor nhaa123 | 2009-12-23
  1. 163

    Une bonne règle de base est pour tout ce que vous avez besoin de comparer à la condition de la boucle contre quelque chose qui est naturellement un std::size_t lui-même.

    std::size_t est le type de tout sizeof expression et comme c'est la garantie d'être en mesure d'exprimer la taille maximale d'un objet (y compris toute matrice) en C++. Par extension, il est aussi la garantie d'être assez grand pour n'importe quel tableau de l'index de sorte qu'il est naturel pour un type de boucle par index sur un tableau.

    Si vous êtes juste en comptant jusqu'à un numéro, puis il peut être plus naturel d'utiliser le type de la variable qui contient le nombre ou une int ou unsigned int (si assez grand) comme cela devrait être naturel de la taille de la machine.

    • Il convient de mentionner que pas à l'aide de size_t quand vous devriez peut conduire à les failles de sécurité.
    • Non seulement est de type int "naturel", mais le mélange signés et non signés type peut conduire à des bogues de sécurité aussi bien. Unsigned indices sont une douleur à la poignée et une bonne raison d'utiliser un vecteur de classe.
    InformationsquelleAutor CB Bailey
  2. 68

    size_t est le type de résultat de la sizeof opérateur.

    Utilisation size_t pour les variables de la taille du modèle ou de l'index dans un tableau. size_t transmet sémantique: vous savez immédiatement qu'il représente une taille en octets ou d'un indice, plutôt que juste un autre nombre entier.

    Également, à l'aide de size_t pour représenter une taille en octets permet de faire du code portable.

    InformationsquelleAutor Gregory Pakosz
  3. 30

    La size_t type est destiné à spécifier le taille de quelque chose, de sorte qu'il est naturel de les utiliser, par exemple, obtenir la longueur d'une chaîne, puis le traitement de chaque personnage:

    for (size_t i = 0, max = strlen (str); i < max; i++)
    doSomethingWith (str[i]);

    Vous ne de regarder dehors pour des conditions aux limites bien sûr, puisque c'est un type non signé. La limite à l'extrémité supérieure est généralement pas important puisque le maximum est généralement de grande taille (bien qu'il est possible pour y arriver). La plupart des gens il suffit d'utiliser une int pour ce genre de chose, parce qu'ils ont rarement des structures ou des tableaux qui obtiennent assez grande pour dépasser la capacité de int.

    Mais attention à des choses comme:

    for (size_t i = strlen (str) - 1; i >= 0; i--)

    qui va provoquer une boucle infinie en raison de l'emballage du comportement des valeurs non signées (bien que j'ai vu les compilateurs en garde contre cette). Cela peut aussi être atténué par l' (un peu plus difficile à comprendre, mais au moins immunitaire à l'enrobage des problèmes):

    for (size_t i = strlen (str); i-- > 0; )

    Par le passage de la décrémenter post-vérifier les effets secondaires de la poursuite de son état, ce n'est la vérification de la poursuite sur la valeur avant de décrémentation, mais utilise toujours la valeur décrémentée à l'intérieur de la boucle (c'est pourquoi la boucle s'exécute de len .. 1 plutôt que len-1 .. 0).

    • En passant, c'est une mauvaise pratique d'appeler strlen à chaque itération d'une boucle. 🙂 Vous pouvez faire quelque chose comme ceci: for (size_t i = 0, len = strlen(str); i < len; i++) ...
    • Même si elle était un type signé, vous devez faire attention à des conditions aux limites, peut-être même plus depuis signé débordement d'entier est un comportement indéfini.
    • Le compte à rebours correctement peut être fait dans le suivant (infâme) moyen: for (size_t i = strlen (str); i --> 0;)
    • c'est vraiment un truc intéressant même si je ne suis pas sûr que j'aime l'introduction de la --> "va" de l'opérateur (voir stackoverflow.com/questions/1642028/...). Ont intégré votre suggestion dans la réponse.
    • Pouvez-vous faire un simple if (i == 0) break; à la fin de la boucle for (p. ex., for (size_t i = strlen(str) - 1; ; --i). (J'aime vôtre mieux, mais je me demandais si cela ne fonctionne tout aussi bien).
    InformationsquelleAutor paxdiablo
  4. 12

    Par définition, size_t est le résultat de la sizeof de l'opérateur. size_t a été créé pour désigner les tailles.

    Le nombre de fois que vous faites quelque chose (10, dans votre exemple) n'est pas sur les tailles, alors pourquoi utiliser size_t? int, ou unsigned int, devrait être ok.

    Bien sûr, il est pertinent de ce que vous faites avec i l'intérieur de la boucle. Si vous passez à une fonction qui prend un unsigned int, par exemple, choisir unsigned int.

    En tout cas, je vous recommande d'éviter les conversions de type implicites. Faire toutes les conversions de type explicite.

    InformationsquelleAutor Daniel Daranas
  5. 10

    size_t est très lisible moyen de spécifier la dimension de la taille d'un élément de longueur d'une chaîne, la quantité d'octets qu'un pointeur prend, etc.
    Il est également portable à travers les plates - formes, vous trouverez que la 64 bits et 32 bits à la fois se comporter correctement avec les fonctions du système et size_t - quelque chose qui unsigned int ne pourrait pas faire (par exemple, quand devez-vous utiliser unsigned long

    InformationsquelleAutor Ofir
  6. 8

    Utiliser std::size_t pour l'indexation de dénombrement et de style C tableaux.

    Pour les conteneurs STL, vous aurez (par exemple) vector<int>::size_type, qui devrait être utilisé pour l'indexation et le comptage des éléments vectoriels.

    Dans la pratique, ils sont généralement de deux entiers non signés, mais il n'est pas garanti, en particulier lors de l'utilisation de la coutume allocateurs.

    • Avec gcc sous linux, std::size_t est généralement unsigned long (8 octets, 64 bits des systèmes d') plutôt que de unisgned int (4 octets).
    • C-le style des tableaux ne sont pas indexés par size_t, mais, depuis l'index peut être négatif. On pourrait utiliser size_t pour sa propre instance d'un tel tableau, si l'on ne veut pas aller négative, si.
    • Sont des comparaisons sur les u64s aussi vite que des comparaisons sur les u32s? J'ai chronométré sévères de performance des sanctions pour l'utilisation u8s et u16s que la boucle des sentinelles, mais je ne sais pas si Intel a obtenu son acte ensemble sur 64s.
    • Depuis de style C tableau d'indexation est équivalent à l'utilisation de l'opérateur + sur les pointeurs, il semblerait que ptrdiff_t est celle à utiliser pour les indices.
    • Comme pour vector<T>::size_type (et idem pour tous les autres contenants), c'est plutôt inutile, car il est effectivement garanti à size_t - il de la définition de type d' Allocator::size_type, et pour les restrictions en ce qui concerne les contenants voir 20.1.5/4 - en particulier, size_type doit être size_t, et difference_type doit être ptrdiff_t. Bien sûr, la valeur par défaut std::allocator<T> satisfait à ces exigences. Utilisez donc la plus courte size_t et ne vous embêtez pas avec le reste du lot 🙂
    • J'ai ajouter un commentaire à propos de style C des tableaux et des indices négatifs. Oui vous peut, mais vous ne pas. L'accès en dehors des limites du tableau n'est pas défini. Et si vous avez des trucs louches avec des pointeurs, de le faire avec un index de tableau au lieu de pointeur de mathématiques (et beaucoup de commentaires dans le code) est une source de confusion, mauvaise idée.

    InformationsquelleAutor Peter Alexander
  7. 6

    Bientôt la plupart des ordinateurs seront les architectures 64 bits avec 64-bit OS:es les programmes en cours d'exploitation sur les contenants de milliards d'éléments. Ensuite, vous doit utilisation size_t au lieu de int comme indice de boucle, sinon, votre indice de enrouler autour de à la 2^32:élément th, sur les versions 32 et 64 bits des systèmes.

    Préparer l'avenir!

    • Votre argument va pas plus loin en ce sens on a besoin d'un long int plutôt qu'un int. Si size_t est pertinente sur un OS 64 bits, il était tout aussi pertinent sur un 32-bit OS.
    InformationsquelleAutor Nordlöw
  8. 6

    réponse courte:

    presque jamais

    réponse longue:

    Toutes les fois que vous besoin d'avoir un vecteur de char plus grand que 2 go sur un système 32 bits. Dans tous les autres cas d'utilisation, à l'aide d'un type signé est beaucoup plus sûr que d'utiliser un type non signé.

    exemple:

    std::vector<A> data;
[...]
//calculate the index that should be used;
size_t i = calc_index(param1, param2);
//doing calculations close to the underflow of an integer is already dangerous

//do some bounds checking
if( i - 1 < 0 ) {
    //always false, because 0-1 on unsigned creates an underflow
    return LEFT_BORDER;
} else if( i >= data.size() - 1 ) {
    //if i already had an underflow, this becomes true
    return RIGHT_BORDER;
}

//now you have a bug that is very hard to track, because you never 
//get an exception or anything anymore, to detect that you actually 
//return the false border case.

return calc_something(data[i-1], data[i], data[i+1]);

    La signature de l'équivalent de size_t est ptrdiff_t, pas int. Mais à l'aide de int est encore beaucoup mieux dans la plupart des cas que size_t. ptrdiff_t est long sur 32 bits et 64 bits des systèmes d'.

    Cela signifie que vous avez toujours pour convertir size_t chaque fois que vous interagissez avec un std::conteneurs, qui n'est pas très beau. Mais sur une native de la conférence, les auteurs de c++ mentionné que la conception de std::vector avec un unsigned size_t était une erreur.

    Si votre compilateur vous donne des avertissements sur les conversions implicites de ptrdiff_t à size_t, vous pouvez vous rendre explicite avec le constructeur de la syntaxe:

    calc_something(data[size_t(i-1)], data[size_t(i)], data[size_t(i+1)]);

    si voulez juste pour itérer sur une collection, sans limites cheque, utilisez la gamme de base pour:

    for(const auto& d : data) {
    [...]
}

    ici quelques mots de Bjarne Stroustrup (C++ auteur) à natifs

    Pour certaines personnes, cette signed/unsigned erreur de conception dans le TSL est une raison suffisante, à ne pas utiliser les std::vector, mais plutôt une mise en œuvre.

    • Je comprends d'où ils viennent, mais je pense toujours que c'est bizarre d'écrire for(int i = 0; i < get_size_of_stuff(); i++). Maintenant, c'est sûr, vous ne voulez pas vous faire beaucoup de cru de boucles, mais - allez, vous les utilisez trop.
    • La seule raison pour laquelle je utiliser des boucles, c'est parce que le c++ de l'algorithme de la bibliothèque est conçu assez mal. Il y a des langues, comme Scala, qui ont une bien meilleure et plus évolué de la bibliothèque pour fonctionner sur les collections. Ensuite, le cas d'utilisation de matières premières boucles est quasiment éliminé. Il existe également des approches pour améliorer c++ avec une nouvelle et meilleure STL, mais je doute que cela se passera dans la prochaine décennie.
    • Je reçois les unsigned i = 0; assert(i-1, MAX_INT); mais je ne comprends pas pourquoi tu dis "si j'avais déjà un dépassement de capacité, cela devient vrai" parce que le comportement de l'arithmétique sur les entiers non signés est toujours défini, c'est à dire. le résultat est le résultat modulo la taille du plus grand entier représentable. Donc, si i==0, alors i-- devient MAX_INT et puis i++ devient de nouveau 0.
    • J'ai regardé attentivement, et vous avez raison, mon code n'est pas le meilleur pour montrer le problème. Normalement, c'est x + 1 < y équivalent à x < y - 1, mais ils ne sont pas avec unsigend entiers. Qui peut facilement introduire des bugs quand les choses sont transformés qui sont supposés être équivalent.
    InformationsquelleAutor Arne
  9. 3

    Lors de l'utilisation de size_t être prudent avec l'expression suivante

    size_t i = containner.find("mytoken");
size_t x = 99;
if (i-x>-1 && i+x < containner.size()) {
    cout << containner[i-x] << " " << containner[i+x] << endl;
}

    Vous obtiendrez la valeur false dans le cas de l'expression, indépendamment de ce que la valeur de x.
    Il m'a fallu plusieurs jours pour réaliser cela (le code est tellement simple que je n'ai pas fait de test de l'unité), bien qu'il ne prend que quelques minutes pour comprendre la source du problème. Pas sûr que c'est mieux de faire un moulage ou de l'utilisation de zéro.

    if ((int)(i-x) > -1 or (i-x) >= 0)

    Deux façons devrait fonctionner. Voici mon essai

    size_t i = 5;
cerr << "i-7=" << i-7 << " (int)(i-7)=" << (int)(i-7) << endl;

    La sortie: i-7=18446744073709551614 (int)(i-7)=-2

    Je voudrais d'autres commentaires.

    • veuillez noter que (int)(i - 7) est un dépassement de capacité qui est jeté à l' int par la suite, tandis queint(i) - 7 n'est pas un dépassement de capacité depuis la première convertir i à un int, puis soustraire 7. En outre, j'ai trouvé votre exemple de la confusion.
    • Mon point est que l'int est généralement plus sûr lorsque vous ne les soustractions.
    InformationsquelleAutor Kemin Zhou
  10. 2

    size_t est retourné par les différentes bibliothèques pour indiquer que la taille du conteneur est non nul. Vous l'utilisez lorsque vous obtenez une fois de retour :0

    Cependant, dans l'exemple ci-dessus en boucle sur un size_t est un bug potentiel. Considérez les points suivants:

    for (size_t i = thing.size(); i >= 0; --i) {
  //this will never terminate because size_t is a typedef for
  //unsigned int which can not be negative by definition
  //therefore i will always be >= 0
  printf("the never ending story. la la la la");
}

    l'utilisation des entiers non signés a le potentiel de créer ces types de questions subtiles. Donc à mon humble avis, je préfère utiliser size_t seulement quand j'ai interagir avec les conteneurs/types qui en ont besoin.

    InformationsquelleAutor ascotan
  11. -1

    size_t est un type non signé qui peut contenir la valeur entière maximale pour votre architecture, de sorte qu'il est protégé contre les débordements d'entiers en raison de signer (signé int 0x7FFFFFFF incrémenté de 1 vous donne -1) ou de taille courte (unsigned short int 0xFFFF incrémenté de 1 vous donne 0).

    Il est principalement utilisé dans le tableau d'indexation/boucles/de l'adresse de l'arithmétique et ainsi de suite. Des fonctions comme memset() et autres, accepter size_t seulement, parce que, théoriquement, vous pourriez avoir un bloc de mémoire de taille 2^32-1 (sur 32 bits plate-forme).

    Pour la simple boucle n'est pas la peine et utiliser seulement int.

    InformationsquelleAutor Wizzard
  12. -3

    size_t est un type unsigned type intégral, qui peut représenter le plus grand entier sur votre système.
    À n'utiliser que si vous avez besoin de très grands tableaux,matrices, etc.

    Certaines fonctions renvoient un size_t et votre compilateur vous avertira si vous essayez de faire des comparaisons.

    Éviter que, par l'utilisation d'un approprié signed/unsigned type de données ou tout simplement enfermé pour un rapide hack.

    • À n'utiliser que si vous voulez éviter des bugs et des failles de sécurité.
    • Il peut ne pas être en mesure de représenter le plus grand entier sur votre système.
    InformationsquelleAutor monkeyking
  13. -4

    size_t est unsigned int. donc, chaque fois que vous voulez unsigned int vous pouvez l'utiliser.

    Je l'utilise quand je veux spécifier la taille du tableau , compteur ect...

    void * operator new (size_t size); is a good use of it.
    • En fait ce n'est pas nécessairement le même que unsigned int. est non signé, mais il pourrait être plus grande (ou je suppose que plus petit mais je ne sais pas du tout de plates-formes où ce qui est vrai) qu'un int.
    InformationsquelleAutor Ashish