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

concat_view presents a view

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 always models input_range, and models forward_range, bidirectional_range, random_access_range, or sized_range if each adapted view

concat_view can be common_range if the last underlying range models common_range

Customization point objects

The name views::concat denotes a customization point object, which is a const function object of a literal semiregular class type. For exposition purposes, the cv-unqualified version of its type is denoted as __concat_fn

All instances of __concat_fn are equal. The effects of invoking different instances of type __concat_fn on the same arguments are equivalent, regardless of whether the expression denoting the instance is an lvalue or rvalue, and is const-qualified or not (however, a volatile-qualified instance is not required to be invocable). Thus, views::concat

Given a set of types Args..., if std::declval <Args> ( ) meet the requirements for arguments to views::concat above, __concat_fn models

• std::invocable<__concat_fn, Args...>
• std::invocable < const __concat_fn, Args...>
• std::invocable <__concat_fn&, Args...>
• std::invocable < const __concat_fn&, Args...> .
  

Otherwise, no function call operator of __concat_fn participates in overload resolution.

Data members

Member functions

Deduction guides

Nested classes

Helper templates

There is no specialization of ranges::enable_borrowed_range for concat_view

Notes

No argument views::concat() is ill-formed, because there is no reasonable way to determine an element type T. Single argument views::concat(r) is expression equivalent to views::all(r)

Example

#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]

References

See also