Quand utiliser std :: size_t?

Question

Je me demande juste si je devrais utiliser std::size_t pour les boucles et le reste 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, quelle est la meilleure pratique pour savoir quand utiliser std::size_t ?

Answer 1

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 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 int ou unsigned int (si assez grand) comme cela devrait être naturel de la taille de la machine.

Answer 2

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

Utilisez size_t pour les variables qui modélisent la taille ou l’index dans un tableau. size_t transmet la sémantique: vous savez immédiatement qu'elle représente une taille en octets ou un index, plutôt qu'un simple entier.

De plus, utiliser size_t pour représenter une taille en octets aide à rendre le code portable.

Answer 3

L' size_t type est destiné à spécifier la 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; i < strlen (str); i++)
    doSomethingWith (str[i]);

Vous ne devez faire attention à 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 d'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 l' int.

Mais attention à des choses comme:

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

ce 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).

Answer 4

Par définition, size_t est le résultat de l' 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? intou 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, choisissez unsigned int.

Answer 5

Bientôt, la plupart des ordinateurs seront des architectures 64 bits avec un système d’exploitation 64 bits: ils exécutent des programmes fonctionnant sur des conteneurs de milliards d’éléments. Ensuite, vous devez utiliser size_t au lieu de int comme index de boucle, sinon votre index sera renvoyé à l'élément 1 ^ 32: e, sur les systèmes 32 et 64 bits.

Préparez-vous pour l'avenir!