std::ranges::views::concat, std::ranges::concat_view

template< ranges::input_range... Views >
    requires (ranges::view<Views> && ...) && (sizeof...(Views) > 0) &&
              /*concatable*/<Views...>
class concat_view
    : public ranges::view_interface<concat_view<Views...>>

namespace views {
    inline constexpr /* unspecified */ concat = /* unspecified */;
}

template< ranges::viewable_range... Rs >
    requires /* see below */
constexpr ranges::view auto concat( Rs&&... rs );

template< class... Rs >
using /*concat-reference-t*/ =
    ranges::common_reference_t<ranges::range_reference_t<Rs>...>;

template< class... Rs >
using /*concat-value-t*/ = std::common_type_t<ranges::range_value_t<Rs>...>;

template< class... Rs >
using /*concat-rvalue-reference-t*/ =
    ranges::common_reference_t<ranges::range_rvalue_reference_t<Rs>...>;

template< class Ref, class RRef, class It >
concept /*concat-indirectly-readable-impl*/ = /* see description */;

template< class... Rs >
concept /*concatable*/ = /* see description */;

concat_view представляет собой фабрику view, принимающую в качестве списка аргументов произвольное количество диапазонов и предоставляющую представление, начинающееся с первого элемента первого диапазона и заканчивающееся последним элементом последнего диапазона; все элементы диапазонов при этом следуют друг за другом в порядке, заданном аргументами, фактически объединяя переданные диапазоны в цепочку.

Для набора подвыражений exprs выражение views::concat(exprs...) эквивалентно выражению

• views::all(exprs...), если exprs — это набор только с одним элементом, тип которого моделирует input_range,
• concat_view(exprs...) в противном случае.

template< class... Rs >
concept /*concat-indirectly-readable*/ = // exposition only
    std::common_reference_with</*concat-reference-t*/<Rs...>&&,
                               /*concat-value-t*/<Rs...>&> &&
    std::common_reference_with</*concat-reference-t*/<Rs...>&&,
                               /*concat-rvalue-reference-t*/<Rs...>&&> &&
    std::common_reference_with</*concat-rvalue-reference-t*/<Rs...>&&,
                               /*concat-value-t*/<Rs...> const&> &&
    (/*concat-indirectly-readable-impl*/</*concat-reference-t*/<Rs...>,
                                         /*concat-rvalue-reference-t*/<Rs...>,
                                         ranges::iterator_t<Rs>> && ...);

template< class Ref, class RRef, class It >
concept /*concat-indirectly-readable-impl*/ = // exposition only
    requires(const It it) {
        { *it } -> std::convertible_to<Ref>;
        { ranges::iter_move(it)} -> std::convertible_to<RRef>;
    };

template< class... Rs >
concept /*concatable*/ = requires { // exposition only
        typename /*concat-reference-t*/<Rs...>;
        typename /*concat-value-t*/<Rs...>;
        typename /*concat-rvalue-reference-t*/<Rs...>;
    } && /*concat-indirectly-readable*/<Rs...>;

concat_view всегда моделирует input_range, а также моделирует forward_range, bidirectional_range, random_access_range или sized_range, если каждый тип адаптированного view моделирует соответствующий концепт.

concat_view может быть common_range, если последний базовый диапазон моделирует common_range.

Объекты-точки настройки

Имя views::concat обозначает объект-точку настройки — константный функциональный объект литерального типа класса semiregular. Подробности см. в разделе CustomizationPointObject.

Члены данных

Функции-члены

Руководства по выводу типов

Вложенные классы

Вспомогательные шаблоны

Для concat_view не предусмотрена специализация ranges::enable_borrowed_range, поскольку для этого реализация итератора должна была бы постоянно содержать копии всех итераторов и сентинелов всех базовых диапазонов.

Примечания

Вызов views::concat() без аргументов некорректен, поскольку невозможно разумным образом определить тип элемента T. Вызов views::concat(r) с одним аргументом эквивалентен выражению views::all(r).

Пример

#include <cassert>
#include <list>
#include <print>
#include <ranges>
#include <vector>

int main()
{
    std::vector<int> v0{1, 2, 3}, v1{4, 5};
    int a[]{6, 7};
    int i{8};
    auto ie{std::views::single(i)};
    
    auto con = std::views::concat(v0, v1, a, ie);
    assert(con.size() == v0.size() + v1.size() + std::size(a) + ie.size());
    std::println("con.size(): {}", con.size());
    std::println("con: {}", con);
    con[6] = 42; // con is random_access_range, operator[] returns a reference
    assert(a[1] == 42); // a[1] was modified via con[6]
    std::println("con: {}", con);
    
    std::list<int> l{7, 8}; // list is bidirectional range
    auto cat = std::views::concat(v0, l);
    std::println("cat: {}", cat);
    // cat[0] = 13; // compile-time error: cat is bidirectional => no operator[]
}

con.size(): 8
con: [1, 2, 3, 4, 5, 6, 7, 8]
con: [1, 2, 3, 4, 5, 6, 42, 8]
cat: [1, 2, 3, 7, 8]

Ссылки

• Стандарт C++26 (ISO/IEC 14882:2026):
• 26.7.18 Представление concat [range.concat]

См. также