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

concat_view 提供了一种 view 工厂，该工厂接受任意数量的范围作为参数列表，并生成一个视图。该视图从第一个范围的第一个元素开始，到最后一个范围的最后一个元素结束，中间按参数顺序依次包含所有范围的元素，实际上相当于将参数范围进行串联或链式拼接。

template< class... Rs >
concept /*concat-indirectly-readable*/ = // 仅用于说明
    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*/ = // 仅用于说明
    requires(const It it) {
        { *it } -> std::convertible_to<Ref>;
        { ranges::iter_move(it)} -> std::convertible_to<RRef>;
    };

template< class... Rs >
concept /*concatable*/ = requires { // 仅用于说明
        typename /*concat-reference-t*/<Rs...>;
        typename /*concat-value-t*/<Rs...>;
        typename /*concat-rvalue-reference-t*/<Rs...>;
    } && /*concat-indirectly-readable*/<Rs...>;

concat_view 始终满足 input_range 概念要求，并且当每个被适配的 view 类型满足相应概念时，该视图还会满足 forward_range 、 bidirectional_range 、 random_access_range 或 sized_range 概念要求。

concat_view 可以是 common_range ，当且仅当最后一个底层范围满足 common_range 概念。

定制点对象

名称 views::concat 表示一个 定制点对象 ，这是一个字面量 semiregular 类类型的常量 函数对象 。有关详细信息，请参阅 定制点对象 。

数据成员

成员函数

推导指引

嵌套类

辅助模板

不存在对 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]

参考文献

参见