std::ranges::concat_view<Views...>:: size

Retourne le nombre d'éléments.

Équivalent à return std:: apply
(
[ ] ( auto ... sizes )
{
using CT = ranges:: common_type_t < decltype ( sizes ) ... > ;
return ( make-unsigned-like-t  < CT > ( sizes ) + ... ) ;
} ,
tuple-transform  ( ranges:: size , views_  )
) ; .

Valeur de retour

Comme décrit ci-dessus.

Complexité

Constante.

Notes

La complexité de concat_view est en temps constant (même si dans certains cas c'est une fonction linéaire du nombre de plages qu'il concatène, qui est un paramètre statiquement connu de cette vue) car la complexité temporelle, telle que requise par les concepts de plages, est formellement exprimée par rapport au nombre total d'éléments (la taille) d'une plage donnée, et non par rapport aux paramètres statiquement connus de cette plage.

Exemple

#include <cassert>
#include <forward_list>
#include <list>
#include <ranges>
int main()
{
    constexpr static auto a = {1, 2};
    constexpr static auto b = {1, 2, 3};
    constexpr static auto c = {1, 2, 3, 4};
    constexpr auto con{std::views::concat(a, b, c)};
    static_assert(std::ranges::sized_range<decltype(con)>);
    static_assert(con.size() == 2 + 3 + 4);
    std::forward_list d = b;
    static_assert(not std::ranges::sized_range<std::forward_list<int>>);
    const auto cat{std::views::concat(b, c, d)};
    static_assert(not std::ranges::sized_range<decltype(cat)>);
//  auto x = cat.size(); // error: cat is not sized_range because of d
    std::list e = c;
    const auto dog{std::views::concat(a, b, e)};
    static_assert(std::ranges::sized_range<decltype(dog)>);
    assert(dog.size() == 2 + 3 + 4);
}

Voir aussi