std::ranges:: size

Calcule le nombre d'éléments dans t en temps constant.

Étant donné la sous-expression dont t désigne l'objet résultat (éventuellement matérialisé ) comme E , et le type de E comme T :

• Si T est un tableau de taille inconnue, ranges :: size ( E ) est mal formé.
• Sinon, si T est un type tableau, ranges :: size ( E ) est expression-équivalent à decay-copy  ( std:: extent_v < T > ) (jusqu'en C++23) auto ( std:: extent_v < T > ) (depuis C++23) .
• Sinon, si toutes les conditions suivantes sont satisfaites, ranges :: size ( E ) est équivalent en expression à decay-copy  ( t. size ( ) ) (jusqu'en C++23) auto ( t. size ( ) ) (depuis C++23) :
  • ranges:: disable_sized_range < std:: remove_cv_t < T >> est false .
  • decay-copy  ( t. size ( ) ) (jusqu'en C++23) auto ( t. size ( ) ) (depuis C++23) est une expression valide de type entier-like .
• Sinon, si toutes les conditions suivantes sont satisfaites, ranges :: size ( E ) est équivalent en expression à decay-copy  ( size ( t ) ) (jusqu'en C++23) auto ( size ( t ) ) (depuis C++23) :
  • T est un type classe ou énumération.
  • ranges:: disable_sized_range < std:: remove_cv_t < T >> est false .
  • decay-copy  ( size ( t ) ) (jusqu'en C++23) auto ( size ( t ) ) (depuis C++23) est une expression valide de type similaire à un entier, où la signification de size est établie comme si on effectuait une recherche dépendante des arguments uniquement.
• Sinon, si toutes les conditions suivantes sont satisfaites, ranges :: size ( E ) est expression-équivalent à to-unsigned-like  ( ranges:: end ( t ) - ranges:: begin ( t ) ) :
  • T modélise forward_range .
  • Étant donné le type de ranges:: begin ( t ) comme I et le type de ranges:: end ( t ) comme S , les deux sized_sentinel_for < S, I > et forward_iterator < I > sont modélisés.
  • to-unsigned-like  ( ranges:: end ( t ) - ranges:: begin ( t ) ) est une expression valide.
• Sinon, ranges :: size ( E ) est mal formé.

Les cas mal formés diagnostiquables ci-dessus entraînent un échec de substitution lorsque ranges :: size ( E ) apparaît dans le contexte immédiat d'une instanciation de modèle.

Objets de point de personnalisation

Le nom ranges::size désigne un objet de point de personnalisation , qui est un objet fonction constant d'un type de classe littéral semiregular . Voir CustomizationPointObject pour plus de détails.

Notes

Chaque fois que ranges :: size ( e ) est valide pour une expression e , le type de retour est integer-like .

La norme C++20 exige que si l'appel sous-jacent à la fonction size retourne une prvalue, la valeur de retour soit construite par déplacement à partir de l'objet temporaire matérialisé. Toutes les implémentations retournent directement la prvalue à la place. L'exigence est corrigée par la proposition post-C++20 P0849R8 pour correspondre aux implémentations.

L'expression ranges:: distance ( e ) peut également être utilisée pour déterminer la taille d'une plage e . Contrairement à ranges :: size ( e ) , ranges:: distance ( e ) fonctionne même si e est une plage non dimensionnée, au prix d'une complexité linéaire dans ce cas.

Exemple

#include <iostream>
#include <ranges>
#include <type_traits>
#include <vector>
int main()
{
    auto v = std::vector<int>{};
    std::cout << "ranges::size(v) == " << std::ranges::size(v) << '\n';
    auto il = {7};     // std::initializer_list
    std::cout << "ranges::size(il) == " << std::ranges::size(il) << '\n';
    int array[]{4, 5}; // array has a known bound
    std::cout << "ranges::size(array) == " << std::ranges::size(array) << '\n';
    static_assert(std::is_signed_v<decltype(std::ranges::size(v))> == false);
}

ranges::size(v) == 0
ranges::size(il) == 1
ranges::size(array) == 2

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.

Voir aussi