实验性库头文件 <experimental/ranges/iterator>

See More

 

C++

编译器支持

自立实现与有宿主实现

语言

标准库

标准库标头

具名要求

功能特性测试宏 (C++20)

语言支持库

概念库 (C++20)

诊断库

内存管理库

元编程库 (C++11)

通用工具库

容器库

迭代器库

范围库 (C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库 (C++17)

并发支持库 (C++11)

执行控制库 (C++26)

技术规范

符号索引

外部库

 

标准库头

语言支持 <cfloat> <climits> <compare> (C++20) <contracts> (C++26) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) 概念 <concepts> (C++20) 诊断 <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) 内存管理 <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) 元编程 <type_traits> (C++11) <ratio> (C++11)

通用工具 <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <stdbit.h> (C++26) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) 容器 <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <hive> (C++26) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> 迭代器 <iterator> 范围 <generator> (C++23) <ranges> (C++20)

算法 <algorithm> <numeric> 字符串 <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> 文本处理 <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    cpp/header#数值库数值 <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <stdckdint.h> (C++26) <valarray> 时间 <chrono> (C++11) <ctime> C 兼容性 <ccomplex> (C++11/17/20*) <ciso646> (C++20 前) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

输入/输出 <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) 并发支持 <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) 执行支持 <execution> (C++17)

 

实验性库头文件

执行 P2300
<experimental/execution>
文件系统 TS
<experimental/filesystem>
并行 TS (v1, v2)
experimental/algorithm experimental/execution_policy experimental/exception_list	experimental/numeric <experimental/simd> experimental/task_block
库基础 TS (v1, v2, v3)
experimental/algorithm <experimental/any> experimental/array experimental/chrono experimental/deque experimental/forward_list <experimental/functional> experimental/future experimental/iterator experimental/list experimental/map experimental/memory <experimental/memory_resource> experimental/numeric <experimental/optional> experimental/propagate_const	experimental/random experimental/ratio experimental/regex experimental/scope experimental/set experimental/source_location experimental/string <experimental/string_view> experimental/system_error experimental/tuple experimental/type_traits experimental/unordered_map experimental/unordered_set experimental/utility experimental/vector
并发 TS
experimental/atomic experimental/barrier	experimental/future experimental/latch
范围 TS
<experimental/ranges/algorithm> <experimental/ranges/concepts> <experimental/ranges/functional>         <experimental/ranges/iterator>	<experimental/ranges/random> <experimental/ranges/tuple> <experimental/ranges/type_traits> <experimental/ranges/utility>
协程TS
experimental/coroutine
网络 TS
experimental/buffer experimental/executor experimental/internet experimental/io_context	<experimental/net> experimental/netfwd experimental/socket experimental/timer
反射 TS
<experimental/reflect>

 

此头文件是范围库的一部分。

迭代器相关概念

在命名空间 std::experimental::ranges 定义

迭代器概念

Readable	指定类型通过应用运算符 * 可读 (概念)
Writable	指定可向迭代器所引用的对象写入值 (概念)
WeaklyIncrementable	指定 Semiregular 类型能以前后自增运算符自增 (概念)
Incrementable	指定 WeaklyIncrementable 类型上的自增操作保持相等性，而且该类型 EqualityComparable (概念)
Iterator	指定该类型对象能自增并解引用 (概念)
Sentinel	指定类型的对象是 Iterator 类型的哨位 (概念)
SizedSentinel	指定能应用 - 运算符到迭代器和哨位，以在常数时间计算其差 (概念)
InputIterator	指定类型为输入迭代器，即能读其所引用值，且它能前后自增 (概念)
OutputIterator	指定类型为给定值类型的输出迭代器，即能把该类型的值写入它，且它能前后自增 (概念)
ForwardIterator	指定 InputIterator 为向前迭代器，支持相等比较和多趟 (概念)
BidirectionalIterator	指定 ForwardIterator 为双向迭代器，支持向后移动 (概念)
RandomAccessIterator	指定 BidirectionalIterator 为随机访问迭代器，支持常数时间前进和下标访问 (概念)

间接可调用概念

IndirectUnaryInvocableIndirectRegularUnaryInvocable	指定可调用对象能以解引用一个 Readable 类型的结果调用 (概念)
IndirectUnaryPredicate	指定可调用对象，以解引用某个 Readable 类型的结果调用时，满足 Predicate (概念)
IndirectRelation	指定可调用对象以解引用某些 Readable 类型的结果调用时，满足 Relation (概念)
IndirectStrictWeakOrder	指定可调用对象，以解引用某些 Readable 类型的结果调用时，满足 StrictWeakOrder (概念)

常用算法要求

IndirectlyMovable	指定值可从 Readable 类型移动到 Writable 类型 (概念)
IndirectlyMovableStorable	指定类型可从 Readable 类型移动到 Writable 类型，且移动可以通过中间对象进行 (概念)
IndirectlyCopyable	指定值可从 Readable 类型复制到 Writable 类型 (概念)
IndirectlyCopyableStorable	指定值可从 Readable 类型复制到 Writable 类型，且该复制可能通过中间对象进行 (概念)
IndirectlySwappable	指定两个 Readable 类型所引用的值可交换 (概念)
IndirectlyComparable	指定两个 Readable 类型所引用的值能比较 (概念)
Permutable	指定原位重排元素的算法的公共要求 (概念)
Mergeable	指定算法的要求，该算法需要通过复制元素归并已排序序列到输出序列 (概念)
Sortable	指定重排元素为有序序列的算法的公共要求 (概念)

概念工具

indirect_result_of	计算在某 Readable 类型集合的解引用结果上调用可调用对象的结果 (类模板)
projected	用于指定接受投影的算法上的制约的辅助模板 (类模板)

迭代器原语

迭代器工具

在命名空间 std::experimental::ranges 定义
iter_move	转型解引用对象的结果为其所关联的右值引用类型 (定制点对象)
iter_swap	交换两个可解引用对象所引用的值 (定制点对象)

迭代器特征

在命名空间 std::experimental::ranges 定义
difference_type	获得 WeaklyIncrementable 类型的差类型 (类模板)
value_type	获得 Readable 类型的值类型 (类模板)
iterator_category	获得输入迭代器类型的迭代器类别 (类模板)
iterator_traits	汇集迭代器的关联类型的兼容性特征类 (别名模板)
reference_trvalue_reference_titer_common_reference_t	获得可解引用对象的关联引用类型 (别名模板)

迭代器类别标签

在命名空间 std::experimental::ranges 定义
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tag	用于指示迭代器类别的空类 (类)

std::iterator_traits 的特化

在命名空间 std 定义
std::iterator_traits<InputIterator>std::iterator_traits<OutputIterator>	为范围 TS 迭代器特化 std::iterator_traits (类模板特化)

迭代器操作

在命名空间 std::experimental::ranges 定义
advance	令迭代器前进给定的距离 (函数模板)
distance	返回迭代器和哨位之间的距离，或范围起始和结尾间的距离 (函数模板)
next	自增迭代器 (函数模板)
prev	自减迭代器 (函数模板)

迭代器适配器

在命名空间 std::experimental::ranges 定义
reverse_iterator	用于逆序遍历的迭代器适配器 (类模板)
back_insert_iterator	用于在容器尾插入的迭代器适配器 (类模板)
front_insert_iterator	用于在容器首插入的迭代器适配器 (类模板)
insert_iterator	用于插入元素到容器中的迭代器适配器 (类模板)
move_iterator	解引用为右值引用的迭代器适配器 (类模板)
move_sentinel	为 move_iterator 所用的哨位适配器 (类模板)
common_iterator	将迭代器-哨位对适配成公共迭代器类型，以用于遗留算法 (类模板)
counted_iterator	保持距起始位置距离踪迹的迭代器适配器 (类模板)
default_sentinel	知晓其范围的迭代器类型所用的空哨位类型 (类)
dangling	可能悬垂的迭代器的包装器 (类模板)
safe_iterator_t	以 dangling 包装右值范围的迭代器类型的别名模版 (别名模板)
unreachable	用于与任何迭代器一同指示无限范围的哨位类型 (类)

流迭代器

在命名空间 std::experimental::ranges 定义
istream_iterator	从 std::basic_istream 读取的输入迭代器 (类模板)
ostream_iterator	写入 std::basic_ostream 的输出迭代器 (类模板)
istreambuf_iterator	从 std::basic_streambuf 读取的输入迭代器 (类模板)
ostreambuf_iterator	写入 std::basic_streambuf 的输出迭代器 (类模板)

概要

namespace std { namespace experimental { namespace ranges { inline namespace v1 {

template <class T> concept bool /* dereferenceable */ // 仅用于阐释
  = requires(T& t) { {*t} -> auto&&; };

namespace {
  constexpr /* 未指明 */ iter_move = /* 未指明 */;
  constexpr /* 未指明 */ iter_swap = /* 未指明 */;
}

template <class> struct difference_type;
template <class T> using difference_type_t
  = typename difference_type<T>::type;

template <class> struct value_type;
template <class T> using value_type_t
  = typename value_type<T>::type;

template <class> struct iterator_category;
template <class T> using iterator_category_t
  = typename iterator_category<T>::type;

template </* dereferenceable */ T> using reference_t
  = decltype(*declval<T&>());

template </* dereferenceable */ T>
    requires /* 见定义 */ using rvalue_reference_t
  = decltype(ranges::iter_move(declval<T&>()));

template <class In>
concept bool Readable = /* 见定义 */;

template <class Out, class T>
concept bool Writable = /* 见定义 */;

template <class I>
concept bool WeaklyIncrementable = /* 见定义 */;

template <class I>
concept bool Incrementable = /* 见定义 */;

template <class I>
concept bool Iterator = /* 见定义 */;

template <class S, class I>
concept bool Sentinel = /* 见定义 */;

template <class S, class I>
  constexpr bool disable_sized_sentinel = false;

template <class S, class I>
concept bool SizedSentinel = /* 见定义 */;

template <class I>
concept bool InputIterator = /* 见定义 */;

template <class I>
concept bool OutputIterator = /* 见定义 */;

template <class I>
concept bool ForwardIterator = /* 见定义 */;

template <class I>
concept bool BidirectionalIterator = /* 见定义 */;

template <class I>
concept bool RandomAccessIterator = /* 见定义 */;

template <class F, class I>
concept bool IndirectUnaryInvocable = /* 见定义 */;

template <class F, class I>
concept bool IndirectRegularUnaryInvocable = /* 见定义 */;

template <class F, class I>
concept bool IndirectUnaryPredicate = /* 见定义 */;

template <class F, class I1, class I2 = I1>
concept bool IndirectRelation = /* 见定义 */;

template <class F, class I1, class I2 = I1>
concept bool IndirectStrictWeakOrder = /* 见定义 */;

template <class> struct indirect_result_of;

template <class F, class... Is>
  requires Invocable<F, reference_t<Is>...>
struct indirect_result_of<F(Is...)>;

template <class F>
using indirect_result_of_t
  = typename indirect_result_of<F>::type;

template <Readable I, IndirectRegularUnaryInvocable<I> Proj>
struct projected;

template <WeaklyIncrementable I, class Proj>
struct difference_type<projected<I, Proj>>;

template <class In, class Out>
concept bool IndirectlyMovable = /* 见定义 */;

template <class In, class Out>
concept bool IndirectlyMovableStorable = /* 见定义 */;

template <class In, class Out>
concept bool IndirectlyCopyable = /* 见定义 */;

template <class In, class Out>
concept bool IndirectlyCopyableStorable = /* 见定义 */;

template <class I1, class I2 = I1>
concept bool IndirectlySwappable = /* 见定义 */;

template <class I1, class I2, class R = equal_to<>, class P1 = identity,
    class P2 = identity>
concept bool IndirectlyComparable = /* 见定义 */;

template <class I>
concept bool Permutable = /* 见定义 */;

template <class I1, class I2, class Out,
    class R = less<>, class P1 = identity, class P2 = identity>
concept bool Mergeable = /* 见定义 */;

template <class I, class R = less<>, class P = identity>
concept bool Sortable = /* 见定义 */;

template <class Iterator> using iterator_traits = /* 见定义 */;

template <Readable T> using iter_common_reference_t
  = common_reference_t<reference_t<T>, value_type_t<T>&>;

struct output_iterator_tag { };
struct input_iterator_tag { };
struct forward_iterator_tag : input_iterator_tag { };
struct bidirectional_iterator_tag : forward_iterator_tag { };
struct random_access_iterator_tag : bidirectional_iterator_tag { };

namespace {
  constexpr /* 未指明 */ advance = /* 未指明 */;
  constexpr /* 未指明 */ distance = /* 未指明 */;
  constexpr /* 未指明 */ next = /* 未指明 */;
  constexpr /* 未指明 */ prev = /* 未指明 */;
}

template <BidirectionalIterator I> class reverse_iterator;

template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator==(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator!=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);

template <class I1, class I2>
    requires SizedSentinel<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <RandomAccessIterator I>
  constexpr reverse_iterator<I> operator+(
    difference_type_t<I> n,
    const reverse_iterator<I>& x);

template <BidirectionalIterator I>
constexpr reverse_iterator<I> make_reverse_iterator(I i);

template <class Container> class back_insert_iterator;
template <class Container>
  back_insert_iterator<Container> back_inserter(Container& x);

template <class Container> class front_insert_iterator;
template <class Container>
  front_insert_iterator<Container> front_inserter(Container& x);

template <class Container> class insert_iterator;
template <class Container>
  insert_iterator<Container> inserter(Container& x, iterator_t<Container> i);

template <InputIterator I> class move_iterator;

template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator==(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator!=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);

template <class I1, class I2>
    requires SizedSentinel<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const move_iterator<I1>& x,
    const move_iterator<I2>& y);
template <RandomAccessIterator I>
  constexpr move_iterator<I> operator+(
    difference_type_t<I> n,
    const move_iterator<I>& x);

template <InputIterator I>
  constexpr move_iterator<I> make_move_iterator(I i);

template <Semiregular S> class move_sentinel;

template <class I, Sentinel<I> S>
  constexpr bool operator==(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
  constexpr bool operator==(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, Sentinel<I> S>
  constexpr bool operator!=(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
  constexpr bool operator!=(
    const move_sentinel<S>& s, const move_iterator<I>& i);

template <class I, SizedSentinel<I> S>
  constexpr difference_type_t<I> operator-(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, SizedSentinel<I> S>
  constexpr difference_type_t<I> operator-(
    const move_iterator<I>& i, const move_sentinel<S>& s);

template <Semiregular S>
  constexpr move_sentinel<S> make_move_sentinel(S s);

template <Iterator I, Sentinel<I> S>
  requires !Same<I, S>
class common_iterator;

template <Readable I, class S>
struct value_type<common_iterator<I, S>>;

template <InputIterator I, class S>
struct iterator_category<common_iterator<I, S>>;

template <ForwardIterator I, class S>
struct iterator_category<common_iterator<I, S>>;

template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator==(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
  requires EqualityComparableWith<I1, I2>
bool operator==(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator!=(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);

template <class I2, SizedSentinel<I2> I1, SizedSentinel<I2> S1, SizedSentinel<I1> S2>
difference_type_t<I2> operator-(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);

class default_sentinel;

template <Iterator I> class counted_iterator;

template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator==(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator==(
  const counted_iterator<auto>& x, default_sentinel);
constexpr bool operator==(
  default_sentinel, const counted_iterator<auto>& x);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator!=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator!=(
  const counted_iterator<auto>& x, default_sentinel y);
constexpr bool operator!=(
  default_sentinel x, const counted_iterator<auto>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator<(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator<=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator>(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator>=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);

template <class I1, class I2>
    requires Common<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I>
  constexpr difference_type_t<I> operator-(
    const counted_iterator<I>& x, default_sentinel y);
template <class I>
  constexpr difference_type_t<I> operator-(
    default_sentinel x, const counted_iterator<I>& y);
template <RandomAccessIterator I>
  constexpr counted_iterator<I>
    operator+(difference_type_t<I> n, const counted_iterator<I>& x);

template <Iterator I>
  constexpr counted_iterator<I> make_counted_iterator(I i, difference_type_t<I> n);

class unreachable;
template <Iterator I>
  constexpr bool operator==(const I&, unreachable) noexcept;
template <Iterator I>
  constexpr bool operator==(unreachable, const I&) noexcept;
template <Iterator I>
  constexpr bool operator!=(const I&, unreachable) noexcept;
template <Iterator I>
  constexpr bool operator!=(unreachable, const I&) noexcept;

template <class T> class dangling;

template <class T, class charT = char, class traits = char_traits<charT>,
    class Distance = ptrdiff_t>
  class istream_iterator;

template <class T, class charT, class traits, class Distance>
  bool operator==(const istream_iterator<T, charT, traits, Distance>& x,
    const istream_iterator<T, charT, traits, Distance>& y);
template <class T, class charT, class traits, class Distance>
  bool operator==(default_sentinel x,
    const istream_iterator<T, charT, traits, Distance>& y);
template <class T, class charT, class traits, class Distance>
  bool operator==(const istream_iterator<T, charT, traits, Distance>& x,
    default_sentinel y);
template <class T, class charT, class traits, class Distance>
  bool operator!=(const istream_iterator<T, charT, traits, Distance>& x,
    const istream_iterator<T, charT, traits, Distance>& y);
template <class T, class charT, class traits, class Distance>
  bool operator!=(default_sentinel x,
    const istream_iterator<T, charT, traits, Distance>& y);
template <class T, class charT, class traits, class Distance>
  bool operator!=(const istream_iterator<T, charT, traits, Distance>& x,
    default_sentinel y);

template <class T, class charT = char, class traits = char_traits<charT>>
  class ostream_iterator;

template <class charT, class traits = char_traits<charT> >
  class istreambuf_iterator;

template <class charT, class traits>
  bool operator==(const istreambuf_iterator<charT, traits>& a,
    const istreambuf_iterator<charT, traits>& b);
template <class charT, class traits>
  bool operator==(default_sentinel a,
    const istreambuf_iterator<charT, traits>& b);
template <class charT, class traits>
  bool operator==(const istreambuf_iterator<charT, traits>& a,
    default_sentinel b);
template <class charT, class traits>
  bool operator!=(const istreambuf_iterator<charT, traits>& a,
    const istreambuf_iterator<charT, traits>& b);
template <class charT, class traits>
  bool operator!=(default_sentinel a,
    const istreambuf_iterator<charT, traits>& b);
template <class charT, class traits>
  bool operator!=(const istreambuf_iterator<charT, traits>& a,
    default_sentinel b);

template <class charT, class traits = char_traits<charT> >
  class ostreambuf_iterator;

}}}}

namespace std {
  template <experimental::ranges::Iterator Out>
    struct iterator_traits<Out>;
  template <experimental::ranges::InputIterator In>
    struct iterator_traits<In>;
  template <experimental::ranges::InputIterator In>
      requires experimental::ranges::Sentinel<In, In>
    struct iterator_traits;
}