std::ranges::views::concat, std::ranges::concat_view - cppreference.com (original) (raw)

concat_view presents a view factory that takes an arbitrary number of ranges as an argument list, and provides a view that starts at the first element of the first range, ends at the last element of the last range, with all range elements sequenced in between respectively in the order given in the arguments, effectively concatenating, or chaining together the argument ranges.

1. The class template with a template parameter that is a non-empty pack of views each of which models at least input_range and is _[concatable](concat%5Fview.html#concatable)_ (7).

2. views::concat is a customization point object.

Given a pack of subexpressions exprs, the expression views::concat(exprs...) is expression-equivalent to

• views::all(exprs...) if exprs is a pack with only one element whose type models input_range,
• concat_view(exprs...) otherwise.

1. The iterator::value_type that additionally respects the underlying ranges’ value_type to support the cases when the underlying ranges have proxy iterators.

2. The rvalue reference that also correctly supports the cases where underlying iterators customize iter_move.

3. Defines the _indirectly-readable_ concept for the iterator so that concat_view can model input_range.

Equivalent to:

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> && ...);

where exposition-only concept /*concat-indirectly-readable-impl*/ is

1. Determines whether any two or more different ranges can be adapted into a sequence that itself models a range. Equivalent to:

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 type models the corresponding concept.

concat_view can be common_range if the last underlying range models common_range.

Contents

• 1 Customization point objects
• 2 Data members
• 3 Member functions
  • 3.1 Inherited from std::ranges::view_interface
• 4 Deduction guides
• 5 Nested classes
• 6 Helper templates
• 7 Notes
• 8 Example
• 9 References
• 10 See also

Customization point objects

The name views::concat denotes a customization point object, which is a const function object of a literal semiregular class type. See CustomizationPointObject for details.

[edit] Data members

[edit] Member functions

[edit] Deduction guides

[edit] Nested classes

[edit] Helper templates

There is no specialization of ranges::enable_borrowed_range for concat_view, because this would require the iterator implementation to contain a copy of all iterators and sentinels of all underlying ranges at all times.

[edit] 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).

[edit] Example

The preliminary version can be checked out on Compiler Explorer.

#include #include #include #include #include   int main() { std::vector 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 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[] }

Output:

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]

[edit] References

• C++26 standard (ISO/IEC 14882:2026):

• 26.7.18 Concat view [range.concat]

[edit] See also