std::ranges:: views::join_with, std::ranges::

Defined in header `<ranges>`
template < ranges::input_range V, ranges::forward_range Pattern > requires ranges::view <V> && ranges::input_range < ranges::range_reference_t <V>> && ranges::view <Pattern> && /concatable/ < ranges::range_reference_t <V>, Pattern> class join_with_view : ranges::view_interface <join_with_view<V, Pattern>>	(1)	(since C++23)
namespace views { inline constexpr /* unspecified / join_with = / unspecified */; }	(2)	(since C++23)
Call signature
template < ranges::viewable_range R, class Pattern > requires /* see below */ constexpr ranges::view auto join_with( R&& r, Pattern&& pattern ) ;		(since C++23)
template < class Pattern > constexpr /* range adaptor closure */ join_with( Pattern&& pattern ) ;		(since C++23)

1) A range adaptor that represents view

For the definition of /*concatable*/, see std::ranges::concat_view

2) RangeAdaptorObject. The expression views::join_with(e, f) is expression-equivalent to join_with_view(e, f) for any suitable subexpressions e and f

join_with_view models input_range.

join_with_view models forward_range when:

ranges::range_reference_t<V> is a reference, and
V and ranges::range_reference_t<V> each model forward_range

join_with_view models bidirectional_range when:

ranges::range_reference_t<V> is a reference,
V, ranges::range_reference_t<V>, and Pattern each models bidirectional_range
ranges::range_reference_t<V> and Pattern each model common_range

join_with_view models common_range when:

ranges::range_reference_t<V> is a reference, and
V and ranges::range_reference_t<V> each model forward_range and common_range

Nested types

Type	Definition
`InnerRng`	ranges::range_reference_t<V> (exposition-only member type*

Data members

Member	Definition
`V` `base_`	the underlying (adapted) view (exposition-only member object*
`Pattern` `pattern_`	the pattern object (exposition-only member object*
`non-propagating-cache` <ranges::iterator_t<V>> `outer_it_` (present only if `V` does not model `forward_range`)	the cache of the outer iterator (exposition-only member object*
`non-propagating-cache` <std::remove_cv_t< `InnerRng` >> `inner_` (present only if std::is_reference_v< `InnerRng` > is false	the cache of the inner range (exposition-only member object*

Member functions

(constructor)	constructs a `join_with_view` (public member function)
base	returns a copy of the underlying (adapted) view (public member function)
begin	returns an iterator to the beginning (public member function)
end	returns an iterator or a sentinel to the end (public member function)
Inherited from std::ranges::view_interface
empty	returns whether the derived view is empty. Provided if it satisfies `sized_range` or `forward_range`. (public member function of `std::ranges::view_interface<D>`)
cbegin (C++23)	returns a constant iterator to the beginning of the range. (public member function of `std::ranges::view_interface<D>`)
cend (C++23)	returns a sentinel for the constant iterator of the range. (public member function of `std::ranges::view_interface<D>`)
operator bool	returns whether the derived view is not empty. Provided if ranges::empty is applicable to it. (public member function of `std::ranges::view_interface<D>`)
front	returns the first element in the derived view. Provided if it satisfies `forward_range`. (public member function of `std::ranges::view_interface<D>`)
back	returns the last element in the derived view. Provided if it satisfies `bidirectional_range` and `common_range`. (public member function of `std::ranges::view_interface<D>`)

Deduction guides

Nested classes

iterator	the iterator type (exposition-only member class template*
sentinel	the sentinel type (exposition-only member class template*

Notes

Feature-test macro	Value	Std	Feature
`__cpp_lib_ranges_join_with`	`202202L`	(C++23)	`std::ranges::join_with_view`

Example

Run this code

#include <iostream>
#include <ranges>
#include <string_view>
#include <vector>
 
int main()
{
    using namespace std::literals;
 
    std::vector v{"This"sv, "is"sv, "a"sv, "test."sv};
    auto joined = v | std::views::join_with(' ');
 
    for (auto c : joined)
        std::cout << c;
    std::cout << '\n';
}

Output:

This is a test.

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 4074	C++23	`join_with_view` was underconstrained	updated the constraints

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Member functions
join_with_view::join_with_view
join_with_view::base
join_with_view::begin
join_with_view::end
Deduction guides
Iterator
Member functions
join_with_view::iterator::iterator
join_with_view::iterator::operator*
join_with_view::iterator::operator++ join_with_view::iterator::operator++(int) join_with_view::iterator::operator-- join_with_view::iterator::operator--(int)
Non-member functions
operator==(join_with_view::iterator) (C++23)
iter_move(join_with_view::iterator) (C++23)
iter_swap(join_with_view::iterator) (C++23)
Sentinel
join_with_view::sentinel::sentinel
operator==(join_with_view::sentinel) (C++23)

ranges::join_viewviews::join (C++20)	a `view` consisting of the sequence obtained from flattening a `view` of `range`s (class template) (range adaptor object)
ranges::concat_viewviews::concat (C++26)	a `view` consisting of concatenation of the adapted views (class template) (customization point object)