std:: size_t

std::size_t est le type entier non signé du résultat des opérateurs suivants :

• sizeof

Si un programme tente de former un type de taille excessive (c'est-à-dire que le nombre d'octets dans sa représentation d'objet dépasse la valeur maximale représentable dans std::size_t ), le programme est mal formé.

Notes

std::size_t peut stocker la taille maximale d'un objet théoriquement possible de n'importe quel type (y compris les tableaux). Sur de nombreuses plateformes (à l'exception des systèmes avec adressage segmenté) std::size_t peut stocker en toute sécurité la valeur de n'importe quel pointeur non-membre, auquel cas il est synonyme de std::uintptr_t .

std::size_t est couramment utilisé pour l'indexation de tableaux et le comptage de boucles. Les programmes qui utilisent d'autres types, tels que unsigned int , pour l'indexation de tableaux peuvent échouer, par exemple sur des systèmes 64 bits lorsque l'index dépasse UINT_MAX ou s'il repose sur une arithmétique modulaire 32 bits.

Lors de l'indexation des conteneurs C++, tels que std::string , std::vector , etc., le type approprié est le type imbriqué size_type fourni par ces conteneurs. Il est généralement défini comme un synonyme de std::size_t .

Il n'est pas spécifié si la déclaration de std::size_t est disponible dans tout autre en-tête de la bibliothèque standard. Une implémentation peut éviter d'introduire ce nom même lorsque la norme exige l'utilisation de std::size_t .

Implémentation possible

using size_t = decltype ( sizeof 0 ) ;

Exemple

#include <array>
#include <cstddef>
#include <iostream>
int main()
{
    std::array<std::size_t, 10> a;
    // Exemple avec le littéral std::size_t de C++23
    for (auto i = 0uz; i != a.size(); ++i)
        std::cout << (a[i] = i) << ' ';
    std::cout << '\n';
    // Exemple de boucle de décrémentation
    for (std::size_t i = a.size(); i--;)
        std::cout << a[i] << ' ';
    std::cout << '\n';
    // Notez que la boucle de décrémentation naïve :
    //  for (std::size_t i = a.size() - 1; i >= 0; --i) ...
    // est une boucle infinie, car les nombres non signés sont toujours non négatifs
}

0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 0

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

1. ↑ La définition de std::size_t était exactement la même que la définition de size_t en C, qui est « le type résultant de sizeof ». Il n'y a pas de définition circulaire en C car le type résultant de sizeof en C est un type entier non signé défini par l'implémentation.

Références

Voir aussi