C++
语言
标准库头文件
自立与有宿主实现
具名要求
语言支持库
概念库 (C++20)
诊断库
工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
原子操作库 (C++11)
线程支持库 (C++11)
技术规范
标准库头文件
语言支持
概念
诊断
通用工具
字符串
本地化
容器
迭代器
范围
算法
数值
输入/输出
正则表达式
文件系统
线程支持
C 兼容
此头文件是范围库的一部分。
命名空间别名
namespace std {
namespace views = ranges::views;
}
提供命名空间别名 std::views，作为 std::ranges::views 的简称。
概念
范围概念
定义于命名空间 std::ranges
range
指定类型为范围，即它同时提供 begin 迭代器和 end 哨位 (概念)
sized_range
指定范围可在常数时间内知晓其大小 (概念)
view
指定范围为视图，即它拥有常数时间的复制/移动/赋值 (概念)
input_range
指定范围的迭代器类型满足 input_iterator (概念)
output_range
指定范围的迭代器类型满足 output_iterator (概念)
forward_range
指定范围的迭代器类型满足 forward_iterator (概念)
bidirectional_range
指定范围的迭代器类型满足 bidirectional_iterator (概念)
random_access_range
指定范围的迭代器类型满足 random_access_iterator (概念)
contiguous_range
指定范围的迭代器类型满足 contiguous_iterator (概念)
common_range
指定范围拥有相同的迭代器和哨位类型 (概念)
viewable_range
指定针对 range 的要求，令其可安全转换为 view (概念)
类
范围原语
定义于命名空间 std::ranges
iterator_tsentinel_trange_difference_trange_size_t range_value_trange_reference_trange_rvalue_reference_t
获得范围的关联类型 (别名模板)
视图
定义于命名空间 std::ranges
view_interface
用于定义 view 的辅助类模板，使用奇特重现模板模式 (类模板)
subrange
将迭代器/哨位对结合为一个 view (类模板)
悬垂迭代器处理
定义于命名空间 std::ranges
dangling
占位类型，指示不应返回迭代器或子范围，因为它可能悬垂 (类)
borrowed_iterator_tborrowed_subrange_t
获得塑造 borrowed_range 的迭代器类型或子范围类型 (别名模板)
工厂
定义于命名空间 std::ranges
empty_viewviews::empty
无元素的空 view (类模板) (变量模板)
single_viewviews::single
含有具有指定值的单个元素的 view (类模板) (定制点对象)
iota_viewviews::iota
由通过重复对某个初值自增所生成的序列组成的 view (类模板) (定制点对象)
views::counted
从迭代器和计数创建子范围 (定制点对象)
适配器
定义于命名空间 std::ranges
views::all_tviews::all
包含 range 的所有元素的 view (别名模板) (范围适配器对象)
ref_view
某个其他 range 的元素的 view (类模板)
filter_viewviews::filter
由 range 中满足某个谓词的元素构成的 view (类模板) (范围适配器对象)
transform_viewviews::transform
对序列的每个元素应用某个变换函数的 view (类模板) (范围适配器对象)
take_viewviews::take
由另一 view 的前 N 个元素组成的 view (类模板) (范围适配器对象)
join_viewviews::join
由拉平 range 的 view 所获得的序列构成的 view (类模板) (范围适配器对象)
split_viewviews::split
用某个分隔符切割另一 view 所获得的子范围的 view (类模板) (范围适配器对象)
common_viewviews::common
转换 view 为 common_range (类模板) (范围适配器对象)
reverse_viewviews::reverse
以逆序迭代另一双向视图上的元素的 view (类模板) (范围适配器对象)
定制点对象
范围访问
定义于命名空间 std::ranges
ranges::begin(C++20)
返回指向范围起始的迭代器 (定制点对象)
ranges::end(C++20)
返回指示范围结尾的哨位 (定制点对象)
ranges::rbegin(C++20)
返回指向范围的逆向迭代器 (定制点对象)
ranges::rend(C++20)
返回指向范围的逆向尾迭代器 (定制点对象)
ranges::size(C++20)
获得能在常数时间内计算大小的范围的大小 (定制点对象)
ranges::empty(C++20)
检查范围是否为空 (定制点对象)
ranges::data(C++20)
获得指向连续范围的起始的指针 (定制点对象)
概要
#include
#include
namespace std::ranges {
inline namespace /* 未指明 */ {
// 范围访问
inline constexpr /* 未指明 */ begin = /* 未指明 */;
inline constexpr /* 未指明 */ end = /* 未指明 */;
inline constexpr /* 未指明 */ cbegin = /* 未指明 */;
inline constexpr /* 未指明 */ cend = /* 未指明 */;
inline constexpr /* 未指明 */ rbegin = /* 未指明 */;
inline constexpr /* 未指明 */ rend = /* 未指明 */;
inline constexpr /* 未指明 */ crbegin = /* 未指明 */;
inline constexpr /* 未指明 */ crend = /* 未指明 */;
inline constexpr /* 未指明 */ size = /* 未指明 */;
inline constexpr /* 未指明 */ empty = /* 未指明 */;
inline constexpr /* 未指明 */ data = /* 未指明 */;
inline constexpr /* 未指明 */ cdata = /* 未指明 */;
}
// 范围
template
using iterator_t = decltype(ranges::begin(declval
template
using sentinel_t = decltype(ranges::end(declval
template
concept Range = /* 见定义 */;
// 有大小范围
template
inline constexpr bool disable_sized_range = false;
template
concept SizedRange = /* 见定义 */;
// 视图
template
inline constexpr bool enable_view = /* 见定义 */;
struct view_base { };
template
concept View = /* 见定义 */;
// 其他范围细化
template
concept OutputRange = /* 见定义 */;
template
concept InputRange = /* 见定义 */;
template
concept ForwardRange = /* 见定义 */;
template
concept BidirectionalRange = /* 见定义 */;
template
concept RandomAccessRange = /* 见定义 */;
template
concept ContiguousRange = /* 见定义 */;
template
concept CommonRange = /* 见定义 */;
template
concept ViewableRange = /* 见定义 */;
// 类模板 view_interface
template
requires is_class_v
class view_interface;
// 子范围
enum class subrange_kind : bool { unsized, sized };
template
requires (K == subrange_kind::sized || !SizedSentinel
class subrange;
// 悬垂迭代器处理
struct dangling;
template
using safe_iterator_t = conditional_t<__ForwardingRange
template
using safe_subrange_t =
conditional_t<__ForwardingRange
// 空视图
template
requires is_object_v
class empty_view;
namespace view {
template
inline constexpr empty_view
}
// 单体视图
template
requires is_object_v
class single_view;
namespace view { inline constexpr /* 未指明 */ single = /* 未指明 */; }
// iota 视图
template
requires __WeaklyEqualityComparableWith
class iota_view;
namespace view { inline constexpr /* 未指明 */ iota = /* 未指明 */; }
// 全视图
namespace view { inline constexpr /* 未指明 */ all = /* 未指明 */; }
template
using all_view = decltype(view::all(declval
template
requires is_object_v
class ref_view;
// 过滤视图
template
requires View
class filter_view;
namespace view { inline constexpr /* 未指明 */ filter = /* 未指明 */; }
// 变换视图
template
requires View
RegularInvocable
class transform_view;
namespace view { inline constexpr /* 未指明 */ transform = /* 未指明 */; }
// 取部分视图
template
namespace view { inline constexpr /* 未指明 */ take = /* 未指明 */; }
// 连接视图
template
requires View
(is_reference_v
View
class join_view;
namespace view { inline constexpr /* 未指明 */ join = /* 未指明 */; }
// 分割视图
template
concept __TinyRange = /* 见定义 */; // 仅用于阐释
template
requires View
IndirectlyComparable
(ForwardRange
class split_view;
namespace view { inline constexpr /* 未指明 */ split = /* 未指明 */; }
// 计数视图
namespace view { inline constexpr /* 未指明 */ counted = /* 未指明 */; }
// 公共视图
template
requires (!CommonRange
class common_view;
namespace view { inline constexpr /* 未指明 */ common = /* 未指明 */; }
// 逆向视图
template
requires BidirectionalRange
class reverse_view;
namespace view { inline constexpr /* 未指明 */ reverse = /* 未指明 */; }
}
namespace std {
namespace view = ranges::view;
template
struct tuple_size
: integral_constant
template
struct tuple_element<0, ranges::subrange
using type = I;
};
template
struct tuple_element<1, ranges::subrange
using type = S;
};
}
概念 range
namespace std::ranges {
template
concept __RangeImpl = // 仅用于阐释
requires(T&& t) {
ranges::begin(std::forward
ranges::end(std::forward
};
template
concept Range = __RangeImpl
template
concept __ForwardingRange = // 仅用于阐释
Range
}
概念 sized_range
namespace std::ranges {
template
concept SizedRange =
Range
!disable_sized_range
requires(T& t) { ranges::size(t); };
}
概念 view
namespace std::ranges {
template
inline constexpr bool enable_view = /* 见定义 */;
template
concept View =
Range
}
概念 output_range
namespace std::ranges {
template
concept OutputRange =
Range
}
概念 input_range
namespace std::ranges {
template
concept InputRange =
Range
}
概念 forward_range
namespace std::ranges {
template
concept ForwardRange =
InputRange
}
概念 bidirectional_range
namespace std::ranges {
template
concept BidirectionalRange =
ForwardRange
}
概念 random_access_range
namespace std::ranges {
template
concept RandomAccessRange =
BidirectionalRange
}
概念 contiguous_range
namespace std::ranges {
template
concept ContiguousRange =
RandomAccessRange
requires(T& t) {
{ ranges::data(t) } -> Same
};
}
概念 common_range
namespace std::ranges {
template
concept CommonRange =
Range
}
概念 viewable_range
namespace std::ranges {
template
concept ViewableRange =
Range
}
辅助概念
namespace std::ranges { // 未指定，仅用于名字查找
template
concept __SimpleView = // 仅用于阐释
View
Same
Same
template
concept __HasArrow = // 仅用于阐释
is_pointer_v || requires(I i) { i.operator->(); };
template
concept __NotSameAs = // 仅用于阐释
!Same
template
concept _Decrementable = // 仅用于阐释
Incrementable && requires(I i) {
{ --i } -> Same
{ i-- } -> Same;
};
template
concept _Advanceable = // 仅用于阐释
_Decrementable && StrictTotallyOrdered &&
requires(I i, const I j, const iter_difference_t n) {
{ i += n } -> Same
{ i -= n } -> Same
{ j + n } -> Same;
{ n + j } -> Same;
{ j - n } -> Same;
{ j - j } -> Same
};
}
注意：这些名字仅用于阐释目的，它们不是接口的一部分。
类模板 std::ranges::view_interface
namespace std::ranges {
template
requires is_class_v
class view_interface : public view_base {
private:
constexpr D& derived() noexcept { // 仅用于阐释
return static_cast
}
constexpr const D& derived() const noexcept { // 仅用于阐释
return static_cast
}
public:
constexpr bool empty() requires ForwardRange
return ranges::begin(derived()) == ranges::end(derived());
}
constexpr bool empty() const requires ForwardRange
return ranges::begin(derived()) == ranges::end(derived());
}
constexpr explicit operator bool()
requires requires { ranges::empty(derived()); } {
return !ranges::empty(derived());
}
constexpr explicit operator bool() const
requires requires { ranges::empty(derived()); } {
return !ranges::empty(derived());
}
constexpr auto data() requires ContiguousIterator
return ranges::empty(derived()) ? nullptr : addressof(*ranges::begin(derived()));
}
constexpr auto data() const
requires Range
return ranges::empty(derived()) ? nullptr : addressof(*ranges::begin(derived()));
}
constexpr auto size() requires ForwardRange
SizedSentinel
return ranges::end(derived()) - ranges::begin(derived());
}
constexpr auto size() const requires ForwardRange
SizedSentinel
return ranges::end(derived()) - ranges::begin(derived());
}
constexpr decltype(auto) front() requires ForwardRange
constexpr decltype(auto) front() const requires ForwardRange
constexpr decltype(auto) back() requires BidirectionalRange
constexpr decltype(auto) back() const
requires BidirectionalRange
template
constexpr decltype(auto) operator[](iter_difference_t
return ranges::begin(derived())[n];
}
template
constexpr decltype(auto) operator[](iter_difference_t
return ranges::begin(derived())[n];
}
};
}
类模板 std::ranges::subrange
namespace std::ranges {
template
concept __PairLike = // 仅用于阐释
!is_reference_v
typename tuple_size
requires DerivedFrom
typename tuple_element_t<0, remove_const_t
typename tuple_element_t<1, remove_const_t
{ get<0>(t) } -> const tuple_element_t<0, T>&;
{ get<1>(t) } -> const tuple_element_t<1, T>&;
};
template
concept __PairLikeConvertibleTo = // 仅用于阐释
!Range
requires(T&& t) {
{ get<0>(std::forward
{ get<1>(std::forward
};
template
concept __PairLikeConvertibleFrom = // 仅用于阐释
!Range
template
concept __IteratorSentinelPair = // 仅用于阐释
!Range
Sentinel
template
SizedSentinel
requires (K == subrange_kind::sized || !SizedSentinel
class subrange : public view_interface
private:
static constexpr bool StoreSize = // 仅用于阐释
K == subrange_kind::sized && !SizedSentinel
I begin_ = I(); // 仅用于阐释
S end_ = S(); // 仅用于阐释
iter_difference_t size_ = 0; // 仅用于阐释；
// 仅当 StoreSize 为 true 时才存在
public:
subrange() = default;
constexpr subrange(I i, S s) requires (!StoreSize);
constexpr subrange(I i, S s, iter_difference_t n)
requires (K == subrange_kind::sized);
template<__NotSameAs
requires __ForwardingRange
ConvertibleTo
constexpr subrange(R&& r) requires (!StoreSize || SizedRange
template<__ForwardingRange R>
requires ConvertibleTo
constexpr subrange(R&& r, iter_difference_t n)
requires (K == subrange_kind::sized)
: subrange{ranges::begin(r), ranges::end(r), n}
{}
template<__NotSameAs
requires __PairLikeConvertibleTo
constexpr subrange(PairLike&& r) requires (!StoreSize)
: subrange{std::get<0>(std::forward
std::get<1>(std::forward
{}
template<__PairLikeConvertibleTo
constexpr subrange(PairLike&& r, iter_difference_t n)
requires (K == subrange_kind::sized)
: subrange{std::get<0>(std::forward
std::get<1>(std::forward
{}
template<__NotSameAs
requires __PairLikeConvertibleFrom
constexpr operator PairLike() const;
constexpr I begin() const;
constexpr S end() const;
constexpr bool empty() const;
constexpr iter_difference_t size() const
requires (K == subrange_kind::sized);
[[nodiscard]] constexpr subrange next(iter_difference_t n = 1) const;
[[nodiscard]] constexpr subrange prev(iter_difference_t n = 1) const
requires BidirectionalIterator;
constexpr subrange& advance(iter_difference_t n);
friend constexpr I begin(subrange&& r) { return r.begin(); }
friend constexpr S end(subrange&& r) { return r.end(); }
};
template
subrange(I, S, iter_difference_t) -> subrange
template<__IteratorSentinelPair P>
subrange(P) -> subrange
template<__IteratorSentinelPair P>
subrange(P, iter_difference_t
subrange
template<__ForwardingRange R>
subrange(R&&) ->
subrange
(SizedRange
? subrange_kind::sized : subrange_kind::unsized>;
template<__ForwardingRange R>
subrange(R&&, iter_difference_t
subrange
template
requires (N < 2)
constexpr auto get(const subrange
}
namespace std {
using ranges::get;
}
类 std::ranges::dangling
namespace std::ranges {
struct dangling {
constexpr dangling() noexcept = default;
template
constexpr dangling(Args&&...) noexcept { }
};
}
类模板 std::ranges::empty_view
namespace std::ranges {
template
requires is_object_v
class empty_view : public view_interface
public:
static constexpr T* begin() noexcept { return nullptr; }
static constexpr T* end() noexcept { return nullptr; }
static constexpr T* data() noexcept { return nullptr; }
static constexpr ptrdiff_t size() noexcept { return 0; }
static constexpr bool empty() noexcept { return true; }
friend constexpr T* begin(empty_view) noexcept { return nullptr; }
friend constexpr T* end(empty_view) noexcept { return nullptr; }
};
}
类模板 std::ranges::empty_view
namespace std::ranges {
template
requires is_object_v
class single_view : public view_interface
private:
semiregular_box
public:
single_view() = default;
constexpr explicit single_view(const T& t);
constexpr explicit single_view(T&& t);
template
requires Constructible
constexpr single_view(in_place_t, Args&&... args);
constexpr T* begin() noexcept;
constexpr const T* begin() const noexcept;
constexpr T* end() noexcept;
constexpr const T* end() const noexcept;
static constexpr ptrdiff_t size() noexcept;
constexpr T* data() noexcept;
constexpr const T* data() const noexcept;
};
}
类模板 std::ranges::iota_view
namespace std::ranges {
template
concept _Decrementable = // 仅用于阐释
/* 见定义 */;
template
concept _Advanceable = // 仅用于阐释
/* 见定义 */;
template
requires __WeaklyEqualityComparableWith
class iota_view : public view_interface
private:
// 类 iota_view::iterator
struct iterator; // 仅用于阐释
// 类 iota_view::sentinel
struct sentinel; // 仅用于阐释
W value_ = W(); // 仅用于阐释
Bound bound_ = Bound(); // 仅用于阐释
public:
iota_view() = default;
constexpr explicit iota_view(W value);
constexpr iota_view(type_identity_t
type_identity_t
constexpr iterator begin() const;
constexpr sentinel end() const;
constexpr iterator end() const requires Same
constexpr auto size() const
requires (Same
(Integral
SizedSentinel
{ return bound_ - value_; }
};
template
requires (!Integral
iota_view(W, Bound) -> iota_view
}
类 std::ranges::iota_view::iterator
namespace std::ranges {
template
struct iota_view
private:
W value_ = W(); // 仅用于阐释
public:
using iterator_category = /* 见定义 */;
using value_type = W;
using difference_type = iter_difference_t
iterator() = default;
constexpr explicit iterator(W value);
constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v
constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires Incrementable
constexpr iterator& operator--() requires _Decrementable
constexpr iterator operator--(int) requires _Decrementable
constexpr iterator& operator+=(difference_type n)
requires _Advanceable
constexpr iterator& operator-=(difference_type n)
requires _Advanceable
constexpr W operator[](difference_type n) const
requires _Advanceable
friend constexpr bool operator==(const iterator& x, const iterator& y)
requires EqualityComparable
friend constexpr bool operator!=(const iterator& x, const iterator& y)
requires EqualityComparable
friend constexpr bool operator<(const iterator& x, const iterator& y)
requires StrictTotallyOrdered
friend constexpr bool operator>(const iterator& x, const iterator& y)
requires StrictTotallyOrdered
friend constexpr bool operator<=(const iterator& x, const iterator& y)
requires StrictTotallyOrdered
friend constexpr bool operator>=(const iterator& x, const iterator& y)
requires StrictTotallyOrdered
friend constexpr iterator operator+(iterator i, difference_type n)
requires _Advanceable
friend constexpr iterator operator+(difference_type n, iterator i)
requires _Advanceable
friend constexpr iterator operator-(iterator i, difference_type n)
requires _Advanceable
friend constexpr difference_type operator-(const iterator& x, const iterator& y)
requires _Advanceable
};
}
类 std::ranges::iota_view::sentinel
namespace std::ranges {
template
struct iota_view
private:
Bound bound_ = Bound(); // 仅用于阐释
public:
sentinel() = default;
constexpr explicit sentinel(Bound bound);
friend constexpr bool operator==(const iterator& x, const sentinel& y);
friend constexpr bool operator==(const sentinel& x, const iterator& y);
friend constexpr bool operator!=(const iterator& x, const sentinel& y);
friend constexpr bool operator!=(const sentinel& x, const iterator& y);
};
}
类模板 std::ranges::ref_view
namespace std::ranges {
template
requires is_object_v
class ref_view : public view_interface
private:
R* r_ = nullptr; // 仅用于阐释
public:
constexpr ref_view() noexcept = default;
template<__NotSameAs
requires /* 见定义 */
constexpr ref_view(T&& t);
constexpr R& base() const { return *r_; }
constexpr iterator_t
constexpr sentinel_t
constexpr bool empty() const
requires requires { ranges::empty(*r_); }
{ return ranges::empty(*r_); }
constexpr auto size() const requires SizedRange
{ return ranges::size(*r_); }
constexpr auto data() const requires ContiguousRange
{ return ranges::data(*r_); }
friend constexpr iterator_t
{ return r.begin(); }
friend constexpr sentinel_t
{ return r.end(); }
};
template
ref_view(R&) -> ref_view
}
类模板 std::ranges::filter_view
namespace std::ranges {
template
requires View
class filter_view : public view_interface
private:
V base_ = V(); // 仅用于阐释
semiregular_box
// 类 filter_view::iterator
class iterator; // 仅用于阐释
// 类 filter_view::sentinel
class sentinel; // 仅用于阐释
public:
filter_view() = default;
constexpr filter_view(V base, Pred pred);
template
requires ViewableRange
constexpr filter_view(R&& r, Pred pred);
constexpr V base() const;
constexpr iterator begin();
constexpr auto end() {
if constexpr (CommonRange
return iterator{*this, ranges::end(base_)};
else
return sentinel{*this};
}
};
template
filter_view(R&&, Pred) -> filter_view
}
类 std::ranges::filter_view::iterator
namespace std::ranges {
template
class filter_view
private:
iterator_t
filter_view* parent_ = nullptr; // 仅用于阐释
public:
using iterator_concept = /* 见定义 */;
using iterator_category = /* 见定义 */;
using value_type = iter_value_t
using difference_type = iter_difference_t
iterator() = default;
constexpr iterator(filter_view& parent, iterator_t
constexpr iterator_t
constexpr iter_reference_t
constexpr iterator_t
requires has-arrow
constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires ForwardRange
constexpr iterator& operator--() requires BidirectionalRange
constexpr iterator operator--(int) requires BidirectionalRange
friend constexpr bool operator==(const iterator& x, const iterator& y)
requires EqualityComparable
friend constexpr bool operator!=(const iterator& x, const iterator& y)
requires EqualityComparable
friend constexpr iter_rvalue_reference_t
noexcept(noexcept(ranges::iter_move(i.current_)));
friend constexpr void iter_swap(const iterator& x, const iterator& y)
noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
requires IndirectlySwappable
};
}
类 std::ranges::filter_view::sentinel
namespace std::ranges {
template
class filter_view
private:
sentinel_t
public:
sentinel() = default;
constexpr explicit sentinel(filter_view& parent);
constexpr sentinel_t
friend constexpr bool operator==(const iterator& x, const sentinel& y);
friend constexpr bool operator==(const sentinel& x, const iterator& y);
friend constexpr bool operator!=(const iterator& x, const sentinel& y);
friend constexpr bool operator!=(const sentinel& x, const iterator& y);
};
}
类模板 std::ranges::transform_view
namespace std::ranges {
template
requires View
RegularInvocable
class transform_view : public view_interface
private:
// 类模板 transform_view::iterator
template
// 类模板 transform_view::sentinel
template
V base_ = V(); // 仅用于阐释
semiregular_box
public:
transform_view() = default;
constexpr transform_view(V base, F fun);
template
requires ViewableRange
constexpr transform_view(R&& r, F fun);
constexpr V base() const;
constexpr iterator
constexpr iterator
requires Range
RegularInvocable
constexpr sentinel
constexpr iterator
constexpr sentinel
requires Range
RegularInvocable
constexpr iterator
requires CommonRange
RegularInvocable
constexpr auto size() requires SizedRange
constexpr auto size() const requires SizedRange
{ return ranges::size(base_); }
};
template
transform_view(R&&, F) -> transform_view
}
类模板 std::ranges::transform_view::iterator
namespace std::ranges {
template
template
class transform_view
private:
using Parent = // 仅用于阐释
conditional_t
using Base = // 仅用于阐释
conditional_t
iterator_t
iterator_t
Parent* parent_ = nullptr; // 仅用于阐释
public:
using iterator_concept = /* 见定义 */;
using iterator_category = /* 见定义 */;
using value_type =
remove_cvref_t
using difference_type = iter_difference_t
iterator() = default;
constexpr iterator(Parent& parent, iterator_t
constexpr iterator(iterator i)
requires Const && ConvertibleTo
constexpr iterator_t
constexpr decltype(auto) operator*() const
{ return invoke(*parent_->fun_, *current_); }
constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires ForwardRange
constexpr iterator& operator--() requires BidirectionalRange
constexpr iterator operator--(int) requires BidirectionalRange
constexpr iterator& operator+=(difference_type n)
requires RandomAccessRange
constexpr iterator& operator-=(difference_type n)
requires RandomAccessRange
constexpr decltype(auto) operator[](difference_type n) const
requires RandomAccessRange
{ return invoke(*parent_->fun_, current_[n]); }
friend constexpr bool operator==(const iterator& x, const iterator& y)
requires EqualityComparable
friend constexpr bool operator!=(const iterator& x, const iterator& y)
requires EqualityComparable
friend constexpr bool operator<(const iterator& x, const iterator& y)
requires RandomAccessRange
friend constexpr bool operator>(const iterator& x, const iterator& y)
requires RandomAccessRange
friend constexpr bool operator<=(const iterator& x, const iterator& y)
requires RandomAccessRange
friend constexpr bool operator>=(const iterator& x, const iterator& y)
requires RandomAccessRange
friend constexpr iterator operator+(iterator i, difference_type n)
requires RandomAccessRange
friend constexpr iterator operator+(difference_type n, iterator i)
requires RandomAccessRange
friend constexpr iterator operator-(iterator i, difference_type n)
requires RandomAccessRange
friend constexpr difference_type operator-(const iterator& x, const iterator& y)
requires RandomAccessRange
friend constexpr decltype(auto) iter_move(const iterator& i)
noexcept(noexcept(invoke(*i.parent_->fun_, *i.current_)))
{
if constexpr (is_lvalue_reference_v
return std::move(*i);
else
return *i;
}
friend constexpr void iter_swap(const iterator& x, const iterator& y)
noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
requires IndirectlySwappable
};
}
类模板 std::ranges::transform_view::sentinel
namespace std::ranges {
template
template
class transform_view
private:
using Parent = // 仅用于阐释
conditional_t
using Base = conditional_t
sentinel_t
public:
sentinel() = default;
constexpr explicit sentinel(sentinel_t
constexpr sentinel(sentinel i)
requires Const && ConvertibleTo
constexpr sentinel_t
friend constexpr bool operator==(const iterator
friend constexpr bool operator==(const sentinel& x, const iterator
friend constexpr bool operator!=(const iterator
friend constexpr bool operator!=(const sentinel& x, const iterator
friend constexpr iter_difference_t
operator-(const iterator
requires SizedSentinel
friend constexpr iter_difference_t
operator-(const sentinel& y, const iterator
requires SizedSentinel
};
}
类模板 std::ranges::take_view
namespace std::ranges {
template
class take_view : public view_interface
private:
V base_ = V(); // 仅用于阐释
iter_difference_t
// 类模板 take_view::sentinel
template
public:
take_view() = default;
constexpr take_view(V base, iter_difference_t
template
requires Constructible
constexpr take_view(R&& r, iter_difference_t
constexpr V base() const;
constexpr auto begin() requires (!__SimpleView
if constexpr (SizedRange
if constexpr (RandomAccessRange
return ranges::begin(base_);
else
return counted_iterator{ranges::begin(base_), size()};
} else
return counted_iterator{ranges::begin(base_), count_};
}
constexpr auto begin() const requires Range
if constexpr (SizedRange
if constexpr (RandomAccessRange
return ranges::begin(base_);
else
return counted_iterator{ranges::begin(base_), size()};
} else
return counted_iterator{ranges::begin(base_), count_};
}
constexpr auto end() requires (!__SimpleView
if constexpr (SizedRange
if constexpr (RandomAccessRange
return ranges::begin(base_) + size();
else
return default_sentinel;
} else
return sentinel
}
constexpr auto end() const requires Range
if constexpr (SizedRange
if constexpr (RandomAccessRange
return ranges::begin(base_) + size();
else
return default_sentinel;
} else
return sentinel
}
constexpr auto size() requires SizedRange
auto n = ranges::size(base_);
return ranges::min(n, static_cast
}
constexpr auto size() const requires SizedRange
auto n = ranges::size(base_);
return ranges::min(n, static_cast
}
};
template
take_view(R&&, iter_difference_t
-> take_view
}
类模板 std::ranges::take_view::sentinel
namespace std::ranges {
template
template
class take_view
private:
using Base = conditional_t
using CI = counted_iterator
sentinel_t
public:
sentinel() = default;
constexpr explicit sentinel(sentinel_t
constexpr sentinel(sentinel s)
requires Const && ConvertibleTo
constexpr sentinel_t
friend constexpr bool operator==(const sentinel& x, const CI& y);
friend constexpr bool operator==(const CI& y, const sentinel& x);
friend constexpr bool operator!=(const sentinel& x, const CI& y);
friend constexpr bool operator!=(const CI& y, const sentinel& x);
};
}
类模板 std::ranges::join_view
namespace std::ranges {
template
requires View
(is_reference_v
View
class join_view : public view_interface
private:
using InnerRng = // 仅用于阐释
iter_reference_t
// 类模板 join_view::iterator
template
struct iterator; // 仅用于阐释
// 类模板 join_view::sentinel
template
struct sentinel; // 仅用于阐释
V base_ = V(); // 仅用于阐释
all_view
all_view
public:
join_view() = default;
constexpr explicit join_view(V base);
template
requires ViewableRange
constexpr explicit join_view(R&& r);
constexpr auto begin() {
return iterator<__SimpleView
}
constexpr auto begin() const
requires InputRange
is_reference_v
return iterator
}
constexpr auto end() {
if constexpr (ForwardRange
is_reference_v
CommonRange
return iterator<__SimpleView
else
return sentinel<__SimpleView
}
constexpr auto end() const
requires InputRange
is_reference_v
if constexpr (ForwardRange
is_reference_v
ForwardRange
CommonRange
CommonRange
return iterator
else
return sentinel
}
};
template
explicit join_view(R&&) -> join_view
}
类模板 std::ranges::join_view::iterator
namespace std::ranges {
template
template
struct join_view
private:
using Parent = // 仅用于阐释
conditional_t
using Base = conditional_t
static constexpr bool ref_is_glvalue = // 仅用于阐释
is_reference_v
iterator_t
iterator_t
iterator_t
Parent* parent_ = nullptr; // 仅用于阐释
constexpr void satisfy(); // 仅用于阐释
public:
using iterator_concept = /* 见定义 */;
using iterator_category = /* 见定义 */;
using value_type =
iter_value_t
using difference_type = /* 见定义 */;
iterator() = default;
constexpr iterator(Parent& parent, iterator_t
constexpr iterator(iterator i)
requires Const &&
ConvertibleTo
ConvertibleTo
iterator_t
constexpr decltype(auto) operator*() const { return *inner_; }
constexpr iterator_t
requires __HasArrow
constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int)
requires ref_is_glvalue && ForwardRange
ForwardRange
constexpr iterator& operator--()
requires ref_is_glvalue && BidirectionalRange
BidirectionalRange
constexpr iterator operator--(int)
requires ref_is_glvalue && BidirectionalRange
BidirectionalRange
friend constexpr bool operator==(const iterator& x, const iterator& y)
requires ref_is_glvalue && EqualityComparable
EqualityComparable
friend constexpr bool operator!=(const iterator& x, const iterator& y)
requires ref_is_glvalue && EqualityComparable
EqualityComparable
friend constexpr decltype(auto) iter_move(const iterator& i)
noexcept(noexcept(ranges::iter_move(i.inner_))) {
return ranges::iter_move(i.inner_);
}
friend constexpr void iter_swap(const iterator& x, const iterator& y)
noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_)));
};
}
类模板 std::ranges::join_view::sentinel
namespace std::ranges {
template
template
struct join_view
private:
using Parent = // 仅用于阐释
conditional_t
using Base = conditional_t
sentinel_t
public:
sentinel() = default;
constexpr explicit sentinel(Parent& parent);
constexpr sentinel(sentinel s)
requires Const && ConvertibleTo
friend constexpr bool operator==(const iterator
friend constexpr bool operator==(const sentinel& x, const iterator
friend constexpr bool operator!=(const iterator
friend constexpr bool operator!=(const sentinel& x, const iterator
};
}
类模板 std::ranges::split_view
namespace std::ranges {
template
template
concept __TinyRange = // 仅用于阐释
SizedRange
requires { typename __require_constant
(remove_reference_t
template
requires View
IndirectlyComparable
(ForwardRange
class split_view : public view_interface
private:
V base_ = V(); // 仅用于阐释
Pattern pattern_ = Pattern(); // 仅用于阐释
iterator_t
// 仅当 !ForwardRange
// 类模板 split_view::outer_iterator
template
// 类模板 split_view::inner_iterator
template
public:
split_view() = default;
constexpr split_view(V base, Pattern pattern);
template
requires Constructible
Constructible
constexpr split_view(R&& r, P&& p);
template
requires Constructible
Constructible
constexpr split_view(R&& r, iter_value_t
constexpr auto begin() {
if constexpr (ForwardRange
return outer_iterator<__SimpleView
else {
current_ = ranges::begin(base_);
return outer_iterator
}
}
constexpr auto begin() const requires ForwardRange
return outer_iterator
}
constexpr auto end() requires ForwardRange
return outer_iterator<__SimpleView
}
constexpr auto end() const {
if constexpr (ForwardRange
return outer_iterator
else
return default_sentinel;
}
};
template
split_view(R&&, P&&) -> split_view >; template split_view(R&&, iter_value_t -> split_view } 类模板 std::ranges::split_view::outer_iterator namespace std::ranges { template template struct split_view private: using Parent = // 仅用于阐释 conditional_t using Base = // 仅用于阐释 conditional_t Parent* parent_ = nullptr; // 仅用于阐释 iterator_t iterator_t public: using iterator_concept = conditional_t using iterator_category = input_iterator_tag; struct value_type; using difference_type = iter_difference_t outer_iterator() = default; constexpr explicit outer_iterator(Parent& parent) requires (!ForwardRange constexpr outer_iterator(Parent& parent, iterator_t requires ForwardRange constexpr outer_iterator(outer_iterator i) requires Const && ConvertibleTo constexpr value_type operator*() const; constexpr outer_iterator& operator++(); constexpr decltype(auto) operator++(int) { if constexpr (ForwardRange auto tmp = *this; ++*this; return tmp; } else ++*this; } friend constexpr bool operator==(const outer_iterator& x, const outer_iterator& y) requires ForwardRange friend constexpr bool operator!=(const outer_iterator& x, const outer_iterator& y) requires ForwardRange friend constexpr bool operator==(const outer_iterator& x, default_sentinel_t); friend constexpr bool operator==(default_sentinel_t, const outer_iterator& x); friend constexpr bool operator!=(const outer_iterator& x, default_sentinel_t y); friend constexpr bool operator!=(default_sentinel_t y, const outer_iterator& x); }; } 类 std::ranges::split_view::outer_iterator::value_type namespace std::ranges { template template struct split_view private: outer_iterator i_ = outer_iterator(); // 仅用于阐释 public: value_type() = default; constexpr explicit value_type(outer_iterator i); constexpr inner_iterator constexpr default_sentinel_t end() const; }; } 类模板 std::ranges::split_view::inner_iterator namespace std::ranges { template template struct split_view private: using Base = conditional_t outer_iterator bool incremented_ = false; // 仅用于阐释 public: using iterator_concept = typename outer_iterator using iterator_category = /* 见定义 */; using value_type = iter_value_t using difference_type = iter_difference_t inner_iterator() = default; constexpr explicit inner_iterator(outer_iterator constexpr decltype(auto) operator*() const { return *i_.current; } constexpr inner_iterator& operator++(); constexpr decltype(auto) operator++(int) { if constexpr (ForwardRange auto tmp = *this; ++*this; return tmp; } else ++*this; } friend constexpr bool operator==(const inner_iterator& x, const inner_iterator& y) requires ForwardRange friend constexpr bool operator!=(const inner_iterator& x, const inner_iterator& y) requires ForwardRange friend constexpr bool operator==(const inner_iterator& x, default_sentinel_t); friend constexpr bool operator==(default_sentinel_t, const inner_iterator& x); friend constexpr bool operator!=(const inner_iterator& x, default_sentinel_t y); friend constexpr bool operator!=(default_sentinel_t y, const inner_iterator& x); friend constexpr decltype(auto) iter_move(const inner_iterator& i) noexcept(noexcept(ranges::iter_move(i.i_.current))) { return ranges::iter_move(i.i_.current); } friend constexpr void iter_swap(const inner_iterator& x, const inner_iterator& y) noexcept(noexcept(ranges::iter_swap(x.i_.current, y.i_.current))) requires IndirectlySwappable }; } 类模板 std::ranges::common_view namespace std::ranges { template requires (!CommonRange class common_view : public view_interface private: V base_ = V(); // 仅用于阐释 public: common_view() = default; constexpr explicit common_view(V r); template requires (!CommonRange constexpr explicit common_view(R&& r); constexpr V base() const; constexpr auto size() requires SizedRange return ranges::size(base_); } constexpr auto size() const requires SizedRange return ranges::size(base_); } constexpr auto begin() { if constexpr (RandomAccessRange return ranges::begin(base_); else return common_iterator } constexpr auto begin() const requires Range if constexpr (RandomAccessRange return ranges::begin(base_); else return common_iterator } constexpr auto end() { if constexpr (RandomAccessRange return ranges::begin(base_) + ranges::size(base_); else return common_iterator } constexpr auto end() const requires Range if constexpr (RandomAccessRange return ranges::begin(base_) + ranges::size(base_); else return common_iterator } }; template common_view(R&&) -> common_view } 类模板 std::ranges::reverse_view namespace std::ranges { template requires BidirectionalRange class reverse_view : public view_interface private: V base_ = V(); // 仅用于阐释 public: reverse_view() = default; constexpr explicit reverse_view(V r); template requires BidirectionalRange constexpr explicit reverse_view(R&& r); constexpr V base() const; constexpr reverse_iterator constexpr reverse_iterator constexpr reverse_iterator requires CommonRange constexpr reverse_iterator constexpr reverse_iterator requires CommonRange constexpr auto size() requires SizedRange return ranges::size(base_); } constexpr auto size() const requires SizedRange return ranges::size(base_); } }; template reverse_view(R&&) -> reverse_view }