std::ranges::size

inline namespace /* unspecified */ {
    inline constexpr auto size = /* unspecified */;
}

template< class T >
    requires /* see below */
constexpr auto size( T&& t );

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é) sous le nom E, et le type de E sous le nom 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 équivalent à l'expression de decay-copy (std::extent_v<T>)(jusqu'à C++23)auto(std::extent_v<T>)(depuis C++23).
• Sinon, si toutes les conditions suivantes sont satisfaites, ranges::size(E) est équivalent à l'expression de decay-copy (t.size())(jusqu'à C++23)auto(t.size())(depuis C++23):
  • ranges::disable_sized_range<std::remove_cv_t<T>> est false.
  • decay-copy (t.size())(jusqu'à C++23)auto(t.size())(depuis C++23) est une expression valide de type semblable à un entier.
• Sinon, si toutes les conditions suivantes sont satisfaites, ranges::size(E) est équivalent à l'expression de decay-copy (size(t))(jusqu'à 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'à C++23)auto(size(t))(depuis C++23) est une expression valide de type semblable à un entier, où la signification de size est établie comme si par recherche dépendante des arguments uniquement.
• Sinon, si toutes les conditions suivantes sont satisfaites, ranges::size(E) est équivalent à l'expression de to-unsigned-like (ranges::end(t) - ranges::begin(t)):
  • T modélise forward_range.
  • Étant donné le type de ranges::begin(t) sous le nom I et le type de ranges::end(t) sous le nom S, à la fois 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 diagnosticables 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