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 presenta una view fábrica que toma un número arbitrario de rangos como lista de argumentos, y proporciona una vista que comienza en el primer elemento del primer rango, termina en el último elemento del último rango, con todos los elementos de los rangos secuenciados en medio respectivamente en el orden dado en los argumentos, concatenando efectivamente, o encadenando, los rangos de argumentos.

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 siempre modela input_range, y modela forward_range, bidirectional_range, random_access_range, o sized_range si cada tipo de view adaptado modela el concepto correspondiente.

concat_view puede ser common_range si el último rango subyacente modela common_range.

Objetos de punto de personalización

El nombre views::concat denota un objeto de punto de personalización , que es un objeto función constante de un tipo de clase literal semiregular . Consulte CustomizationPointObject para más detalles.

Miembros de datos

Funciones miembro

Guías de deducción

Clases anidadas

Plantillas auxiliares

No existe una especialización de ranges:: enable_borrowed_range para concat_view , porque esto requeriría que la implementación del iterador contuviera una copia de todos los iteradores y centinelas de todos los rangos subyacentes en todo momento.

Notas

Sin argumentos views :: concat ( ) está mal formado, porque no existe una forma razonable de determinar un tipo de elemento T . Con un solo argumento views :: concat ( r ) es una expresión equivalente a views:: all ( r ) .

Ejemplo

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

Referencias

Véase también