770 lines · plain
1// -*- C++ -*-2//===----------------------------------------------------------------------===//3//4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCPP_ITERATOR11#define _LIBCPP_ITERATOR12 13/*14 iterator synopsis15 16#include <concepts>17 18namespace std19{20template<class> struct incrementable_traits; // since C++2021template<class T>22 using iter_difference_t = see below; // since C++2023 24template<class> struct indirectly_readable_traits; // since C++2025template<class T>26 using iter_value_t = see below; // since C++2027 28template<class Iterator>29struct iterator_traits;30 31template<class T>32 requires is_object_v<T> // since C++2033struct iterator_traits<T*>;34 35template<dereferenceable T>36 using iter_reference_t = decltype(*declval<T&>());37 38namespace ranges::inline unspecified {39 inline constexpr unspecified iter_move = unspecified; // since C++20, nodiscard as an extension40}}41 42template<dereferenceable T>43 requires ...44using iter_rvalue_reference_t = decltype(ranges::iter_move(declval<T&>())); // since C++2045 46// [iterator.concepts], iterator concepts47// [iterator.concept.readable], concept indirectly_readable48template<class In>49 concept indirectly_readable = see below; // since C++2050 51template<indirectly_readable T>52 using iter_common_reference_t =53 common_reference_t<iter_reference_t<T>, iter_value_t<T>&>; // since C++2054 55// [iterator.concept.writable], concept indirectly_writable56template<class Out, class T>57 concept indirectly_writable = see below; // since C++2058 59// [iterator.concept.winc], concept weakly_incrementable60template<class I>61 concept weakly_incrementable = see below; // since C++2062 63// [iterator.concept.inc], concept incrementable64template<class I>65 concept incrementable = see below; // since C++2066 67// [iterator.concept.iterator], concept input_or_output_iterator68 template<class I>69 concept input_or_output_iterator = see below; // since C++2070 71// [iterator.concept.sentinel], concept sentinel_for72template<class S, class I>73 concept sentinel_for = see below; // since C++2074 75// [iterator.concept.sizedsentinel], concept sized_sentinel_for76template<class S, class I>77 inline constexpr bool disable_sized_sentinel_for = false;78 79template<class S, class I>80 concept sized_sentinel_for = see below;81 82// [iterator.concept.input], concept input_iterator83template<class I>84 concept input_iterator = see below; // since C++2085 86// [iterator.concept.output], concept output_iterator87template<class I, class T>88 concept output_iterator = see below; // since C++2089 90// [iterator.concept.forward], concept forward_iterator91template<class I>92 concept forward_iterator = see below; // since C++2093 94// [iterator.concept.bidir], concept bidirectional_iterator95template<class I>96 concept bidirectional_iterator = see below; // since C++2097 98// [iterator.concept.random.access], concept random_access_iterator99template<class I>100 concept random_access_iterator = see below; // since C++20101 102// [indirectcallable]103// [indirectcallable.indirectinvocable]104template<class F, class I>105 concept indirectly_unary_invocable = see below; // since C++20106 107template<class F, class I>108 concept indirectly_regular_unary_invocable = see below; // since C++20109 110template<class F, class I>111 concept indirect_unary_predicate = see below; // since C++20112 113template<class F, class I1, class I2>114 concept indirect_binary_predicate = see below; // since C++20115 116template<class F, class I1, class I2 = I1>117 concept indirect_equivalence_relation = see below; // since C++20118 119template<class F, class I1, class I2 = I1>120 concept indirect_strict_weak_order = see below; // since C++20121 122template<class F, class... Is>123 using indirect_result_t = see below; // since C++20124 125// [projected], projected126template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>127 struct projected; // since C++20128 129template<weakly_incrementable I, indirectly_regular_unary_invocable<I> Proj>130 struct incrementable_traits<projected<I, Proj>>; // since C++20131 132// [alg.req.ind.move], concept indirectly_movable133template<class In, class Out>134 concept indirectly_movable = see below; // since C++20135 136template<class In, class Out>137 concept indirectly_movable_storable = see below; // since C++20138 139// [alg.req.ind.copy], concept indirectly_copyable140template<class In, class Out>141 concept indirectly_copyable = see below; // since C++20142 143template<class In, class Out>144 concept indirectly_copyable_storable = see below; // since C++20145 146// [alg.req.ind.swap], concept indirectly_swappable147template<class I1, class I2 = I1>148 concept indirectly_swappable = see below; // since C++20149 150template<class I1, class I2, class R, class P1 = identity,151 class P2 = identity>152 concept indirectly_comparable =153 indirect_binary_predicate<R, projected<I1, P1>, projected<I2, P2>>; // since C++20154 155// [alg.req.permutable], concept permutable156template<class I>157 concept permutable = see below; // since C++20158 159 // [alg.req.mergeable], concept mergeable160template<class I1, class I2, class Out,161 class R = ranges::less, class P1 = identity, class P2 = identity>162 concept mergeable = see below; // since C++20163 164// [alg.req.sortable], concept sortable165template<class I, class R = ranges::less, class P = identity>166 concept sortable = see below; // since C++20167 168template<input_or_output_iterator I, sentinel_for<I> S>169 requires (!same_as<I, S> && copyable<I>)170class common_iterator; // since C++20171 172template<class Category, class T, class Distance = ptrdiff_t,173 class Pointer = T*, class Reference = T&>174struct iterator // deprecated in C++17175{176 typedef T value_type;177 typedef Distance difference_type;178 typedef Pointer pointer;179 typedef Reference reference;180 typedef Category iterator_category;181};182 183struct input_iterator_tag {};184struct output_iterator_tag {};185struct forward_iterator_tag : public input_iterator_tag {};186struct bidirectional_iterator_tag : public forward_iterator_tag {};187struct random_access_iterator_tag : public bidirectional_iterator_tag {};188struct contiguous_iterator_tag : public random_access_iterator_tag {};189 190// 27.4.3, iterator operations191template <class InputIterator, class Distance> // constexpr in C++17192 constexpr void advance(InputIterator& i, Distance n);193 194template <class InputIterator> // constexpr in C++17195 constexpr typename iterator_traits<InputIterator>::difference_type196 distance(InputIterator first, InputIterator last);197 198template <class InputIterator> // constexpr in C++17199 constexpr InputIterator next(InputIterator x,200typename iterator_traits<InputIterator>::difference_type n = 1);201 202template <class BidirectionalIterator> // constexpr in C++17203 constexpr BidirectionalIterator prev(BidirectionalIterator x,204 typename iterator_traits<BidirectionalIterator>::difference_type n = 1);205 206// [range.iter.ops], range iterator operations207namespace ranges {208 // [range.iter.op.advance], ranges::advance209 template<input_or_output_iterator I>210 constexpr void advance(I& i, iter_difference_t<I> n); // since C++20211 template<input_or_output_iterator I, sentinel_for<I> S>212 constexpr void advance(I& i, S bound); // since C++20213 template<input_or_output_iterator I, sentinel_for<I> S>214 constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound); // since C++20215}216 217template <class Iterator>218class reverse_iterator219 : public iterator<typename iterator_traits<Iterator>::iterator_category, // until C++17220 typename iterator_traits<Iterator>::value_type,221 typename iterator_traits<Iterator>::difference_type,222 typename iterator_traits<Iterator>::pointer,223 typename iterator_traits<Iterator>::reference>224{225protected:226 Iterator current;227public:228 using iterator_type = Iterator;229 using iterator_concept = see below; // since C++20230 using iterator_category = typename iterator_traits<Iterator>::iterator_category; // since C++17, until C++20231 using iterator_category = see below; // since C++20232 using value_type = typename iterator_traits<Iterator>::value_type; // since C++17, until C++20233 using value_type = iter_value_t<Iterator>; // since C++20234 using difference_type = typename iterator_traits<Iterator>::difference_type; // until C++20235 using difference_type = iter_difference_t<Iterator>; // since C++20236 using pointer = typename iterator_traits<Iterator>::pointer;237 using reference = typename iterator_traits<Iterator>::reference; // until C++20238 using reference = iter_reference_t<Iterator>; // since C++20239 240 constexpr reverse_iterator();241 constexpr explicit reverse_iterator(Iterator x);242 template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u);243 template <class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u);244 constexpr Iterator base() const;245 constexpr reference operator*() const;246 constexpr pointer operator->() const; // until C++20247 constexpr pointer operator->() const requires see below; // since C++20248 constexpr reverse_iterator& operator++();249 constexpr reverse_iterator operator++(int);250 constexpr reverse_iterator& operator--();251 constexpr reverse_iterator operator--(int);252 constexpr reverse_iterator operator+ (difference_type n) const;253 constexpr reverse_iterator& operator+=(difference_type n);254 constexpr reverse_iterator operator- (difference_type n) const;255 constexpr reverse_iterator& operator-=(difference_type n);256 constexpr unspecified operator[](difference_type n) const;257 258 friend constexpr iter_rvalue_reference_t<Iterator>259 iter_move(const reverse_iterator& i) noexcept(see below);260 template<indirectly_swappable<Iterator> Iterator2>261 friend constexpr void262 iter_swap(const reverse_iterator& x,263 const reverse_iterator<Iterator2>& y) noexcept(see below);264};265 266template <class Iterator1, class Iterator2>267constexpr bool // constexpr in C++17268operator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);269 270template <class Iterator1, class Iterator2>271constexpr bool // constexpr in C++17272operator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);273 274template <class Iterator1, class Iterator2>275constexpr bool // constexpr in C++17276operator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);277 278template <class Iterator1, class Iterator2>279constexpr bool // constexpr in C++17280operator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);281 282template <class Iterator1, class Iterator2>283constexpr bool // constexpr in C++17284operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);285 286template <class Iterator1, class Iterator2>287constexpr bool // constexpr in C++17288operator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);289 290template<class Iterator1, three_way_comparable_with<Iterator1> Iterator2>291 constexpr compare_three_way_result_t<Iterator1, Iterator2>292 operator<=>(const reverse_iterator<Iterator1>& x,293 const reverse_iterator<Iterator2>& y);294 295template <class Iterator1, class Iterator2>296constexpr auto297operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y)298-> decltype(__y.base() - __x.base()); // constexpr in C++17299 300template <class Iterator>301constexpr reverse_iterator<Iterator>302operator+(typename reverse_iterator<Iterator>::difference_type n,303 const reverse_iterator<Iterator>& x); // constexpr in C++17304 305template <class Iterator>306constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17307 308template<class Iterator1, class Iterator2>309 requires (!sized_sentinel_for<Iterator1, Iterator2>)310 inline constexpr bool disable_sized_sentinel_for<reverse_iterator<Iterator1>,311 reverse_iterator<Iterator2>> = true;312 313template <class Container>314class back_insert_iterator315 : public iterator<output_iterator_tag, void, void, void, void> // until C++17316{317protected:318 Container* container;319public:320 typedef Container container_type;321 typedef void value_type;322 typedef void difference_type; // until C++20323 typedef ptrdiff_t difference_type; // since C++20324 typedef void reference;325 typedef void pointer;326 327 explicit back_insert_iterator(Container& x); // constexpr in C++20328 back_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20329 back_insert_iterator& operator*(); // constexpr in C++20330 back_insert_iterator& operator++(); // constexpr in C++20331 back_insert_iterator operator++(int); // constexpr in C++20332};333 334template <class Container> back_insert_iterator<Container> back_inserter(Container& x); // constexpr in C++20335 336template <class Container>337class front_insert_iterator338 : public iterator<output_iterator_tag, void, void, void, void> // until C++17339{340protected:341 Container* container;342public:343 typedef Container container_type;344 typedef void value_type;345 typedef void difference_type; // until C++20346 typedef ptrdiff_t difference_type; // since C++20347 typedef void reference;348 typedef void pointer;349 350 explicit front_insert_iterator(Container& x); // constexpr in C++20351 front_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20352 front_insert_iterator& operator*(); // constexpr in C++20353 front_insert_iterator& operator++(); // constexpr in C++20354 front_insert_iterator operator++(int); // constexpr in C++20355};356 357template <class Container> front_insert_iterator<Container> front_inserter(Container& x); // constexpr in C++20358 359template <class Container>360class insert_iterator361 : public iterator<output_iterator_tag, void, void, void, void> // until C++17362{363protected:364 Container* container;365 typename Container::iterator iter;366public:367 typedef Container container_type;368 typedef void value_type;369 typedef void difference_type; // until C++20370 typedef ptrdiff_t difference_type; // since C++20371 typedef void reference;372 typedef void pointer;373 374 insert_iterator(Container& x, typename Container::iterator i); // constexpr in C++20375 insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20376 insert_iterator& operator*(); // constexpr in C++20377 insert_iterator& operator++(); // constexpr in C++20378 insert_iterator& operator++(int); // constexpr in C++20379};380 381template <class Container>382insert_iterator<Container> inserter(Container& x, typename Container::iterator i); // until C++20383template <class Container>384constexpr insert_iterator<Container> inserter(Container& x, ranges::iterator_t<Container> i); // since C++20385 386template <class Iterator>387class move_iterator {388public:389 using iterator_type = Iterator;390 using iterator_concept = see below; // From C++20391 using iterator_category = see below; // not always present starting from C++20392 using value_type = iter_value_t<Iterator>; // Until C++20, iterator_traits<Iterator>::value_type393 using difference_type = iter_difference_t<Iterator>; // Until C++20, iterator_traits<Iterator>::difference_type;394 using pointer = Iterator;395 using reference = iter_rvalue_reference_t<Iterator>; // Until C++20, value_type&&396 397 constexpr move_iterator(); // all the constexprs are in C++17398 constexpr explicit move_iterator(Iterator i);399 template <class U>400 constexpr move_iterator(const move_iterator<U>& u);401 template <class U>402 constexpr move_iterator& operator=(const move_iterator<U>& u);403 404 constexpr iterator_type base() const; // Until C++20405 constexpr const Iterator& base() const & noexcept; // From C++20406 constexpr Iterator base() &&; // From C++20407 408 constexpr reference operator*() const;409 constexpr pointer operator->() const; // Deprecated in C++20410 constexpr move_iterator& operator++();411 constexpr auto operator++(int); // Return type was move_iterator until C++20412 constexpr move_iterator& operator--();413 constexpr move_iterator operator--(int);414 constexpr move_iterator operator+(difference_type n) const;415 constexpr move_iterator& operator+=(difference_type n);416 constexpr move_iterator operator-(difference_type n) const;417 constexpr move_iterator& operator-=(difference_type n);418 constexpr reference operator[](difference_type n) const; // Return type unspecified until C++20419 420 template<sentinel_for<Iterator> S>421 friend constexpr bool422 operator==(const move_iterator& x, const move_sentinel<S>& y); // Since C++20423 template<sized_sentinel_for<Iterator> S>424 friend constexpr iter_difference_t<Iterator>425 operator-(const move_sentinel<S>& x, const move_iterator& y); // Since C++20426 template<sized_sentinel_for<Iterator> S>427 friend constexpr iter_difference_t<Iterator>428 operator-(const move_iterator& x, const move_sentinel<S>& y); // Since C++20429 friend constexpr iter_rvalue_reference_t<Iterator>430 iter_move(const move_iterator& i)431 noexcept(noexcept(ranges::iter_move(i.current))); // Since C++20432 template<indirectly_swappable<Iterator> Iterator2>433 friend constexpr void434 iter_swap(const move_iterator& x, const move_iterator<Iterator2>& y)435 noexcept(noexcept(ranges::iter_swap(x.current, y.current))); // Since C++20436 437private:438 Iterator current; // exposition only439};440 441template <class Iterator1, class Iterator2>442constexpr bool // constexpr in C++17443operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);444 445template <class Iterator1, class Iterator2>446constexpr bool // constexpr in C++17447operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);448 449template <class Iterator1, class Iterator2>450constexpr bool // constexpr in C++17451operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);452 453template <class Iterator1, class Iterator2>454constexpr bool // constexpr in C++17455operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);456 457template <class Iterator1, class Iterator2>458constexpr bool // constexpr in C++17459operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);460 461template <class Iterator1, class Iterator2>462constexpr bool // constexpr in C++17463operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);464 465template <class Iterator1, class Iterator2>466constexpr auto // constexpr in C++17467operator-(const move_iterator<Iterator1>& x,468 const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());469 470template <class Iterator>471constexpr move_iterator<Iterator> operator+( // constexpr in C++17472 typename move_iterator<Iterator>::difference_type n,473 const move_iterator<Iterator>& x);474 475template <class Iterator> // constexpr in C++17476constexpr move_iterator<Iterator> make_move_iterator(const Iterator& i);477 478template<class Iterator1, class Iterator2>479 requires (!sized_sentinel_for<Iterator1, Iterator2>)480 inline constexpr bool disable_sized_sentinel_for<move_iterator<Iterator1>, // since C++20481 move_iterator<Iterator2>> = true;482 483template<semiregular S>484class move_sentinel {485public:486 constexpr move_sentinel();487 constexpr explicit move_sentinel(S s);488 template<class S2>489 requires convertible_to<const S2&, S>490 constexpr move_sentinel(const move_sentinel<S2>& s);491 template<class S2>492 requires assignable_from<S&, const S2&>493 constexpr move_sentinel& operator=(const move_sentinel<S2>& s);494 495 constexpr S base() const;496private:497 S last; // exposition only498};499 500// [default.sentinel], default sentinel501struct default_sentinel_t;502inline constexpr default_sentinel_t default_sentinel{};503 504// [iterators.counted], counted iterators505template<input_or_output_iterator I> class counted_iterator;506 507template<input_iterator I>508 requires see below509 struct iterator_traits<counted_iterator<I>>;510 511// [unreachable.sentinel], unreachable sentinel512struct unreachable_sentinel_t;513inline constexpr unreachable_sentinel_t unreachable_sentinel{};514 515template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t>516class istream_iterator517 : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17518{519public:520 typedef input_iterator_tag iterator_category;521 typedef T value_type;522 typedef Distance difference_type;523 typedef const T* pointer;524 typedef const T& reference;525 526 typedef charT char_type;527 typedef traits traits_type;528 typedef basic_istream<charT, traits> istream_type;529 530 istream_iterator(); // constexpr since C++11531 constexpr istream_iterator(default_sentinel_t); // since C++20532 istream_iterator(istream_type& s);533 constexpr istream_iterator(const istream_iterator& x) noexcept(see below);534 ~istream_iterator();535 536 const T& operator*() const;537 const T* operator->() const;538 istream_iterator& operator++();539 istream_iterator operator++(int);540 friend bool operator==(const istream_iterator& i, default_sentinel_t); // since C++20541};542 543template <class T, class charT, class traits, class Distance>544bool operator==(const istream_iterator<T,charT,traits,Distance>& x,545 const istream_iterator<T,charT,traits,Distance>& y);546template <class T, class charT, class traits, class Distance>547bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,548 const istream_iterator<T,charT,traits,Distance>& y); // until C++20549 550template <class T, class charT = char, class traits = char_traits<charT> >551class ostream_iterator552 : public iterator<output_iterator_tag, void, void, void, void> // until C++17553{554public:555 typedef output_iterator_tag iterator_category;556 typedef void value_type;557 typedef void difference_type; // until C++20558 typedef ptrdiff_t difference_type; // since C++20559 typedef void pointer;560 typedef void reference;561 562 typedef charT char_type;563 typedef traits traits_type;564 typedef basic_ostream<charT,traits> ostream_type;565 566 ostream_iterator(ostream_type& s);567 ostream_iterator(ostream_type& s, const charT* delimiter);568 ostream_iterator(const ostream_iterator& x);569 ~ostream_iterator();570 ostream_iterator& operator=(const T& value);571 572 ostream_iterator& operator*();573 ostream_iterator& operator++();574 ostream_iterator& operator++(int);575};576 577template<class charT, class traits = char_traits<charT> >578class istreambuf_iterator579 : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17580{581public:582 typedef input_iterator_tag iterator_category;583 typedef charT value_type;584 typedef traits::off_type difference_type;585 typedef unspecified pointer;586 typedef charT reference;587 588 typedef charT char_type;589 typedef traits traits_type;590 typedef traits::int_type int_type;591 typedef basic_streambuf<charT, traits> streambuf_type;592 typedef basic_istream<charT, traits> istream_type;593 594 istreambuf_iterator() noexcept; // constexpr since C++11595 constexpr istreambuf_iterator(default_sentinel_t) noexcept; // since C++20596 istreambuf_iterator(istream_type& s) noexcept;597 istreambuf_iterator(streambuf_type* s) noexcept;598 istreambuf_iterator(a-private-type) noexcept;599 600 charT operator*() const;601 pointer operator->() const;602 istreambuf_iterator& operator++();603 a-private-type operator++(int);604 605 bool equal(const istreambuf_iterator& b) const;606 friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s); // since C++20607};608 609template <class charT, class traits>610bool operator==(const istreambuf_iterator<charT,traits>& a,611 const istreambuf_iterator<charT,traits>& b);612template <class charT, class traits>613bool operator!=(const istreambuf_iterator<charT,traits>& a,614 const istreambuf_iterator<charT,traits>& b); // until C++20615 616template <class charT, class traits = char_traits<charT> >617class ostreambuf_iterator618 : public iterator<output_iterator_tag, void, void, void, void> // until C++17619{620public:621 typedef output_iterator_tag iterator_category;622 typedef void value_type;623 typedef void difference_type; // until C++20624 typedef ptrdiff_t difference_type; // since C++20625 typedef void pointer;626 typedef void reference;627 628 typedef charT char_type;629 typedef traits traits_type;630 typedef basic_streambuf<charT, traits> streambuf_type;631 typedef basic_ostream<charT, traits> ostream_type;632 633 ostreambuf_iterator(ostream_type& s) noexcept;634 ostreambuf_iterator(streambuf_type* s) noexcept;635 ostreambuf_iterator& operator=(charT c);636 ostreambuf_iterator& operator*();637 ostreambuf_iterator& operator++();638 ostreambuf_iterator& operator++(int);639 bool failed() const noexcept;640};641 642template <class C> constexpr auto begin(C& c) -> decltype(c.begin()); // constexpr since C++17643template <class C> constexpr auto begin(const C& c) -> decltype(c.begin()); // constexpr since C++17644template <class C> constexpr auto end(C& c) -> decltype(c.end()); // constexpr since C++17645template <class C> constexpr auto end(const C& c) -> decltype(c.end()); // constexpr since C++17646template <class T, size_t N> constexpr T* begin(T (&array)[N]) noexcept;647template <class T, size_t N> constexpr T* end(T (&array)[N]) noexcept;648 649template <class C> constexpr auto cbegin(const C& c) noexcept(see-below) -> decltype(std::begin(c)); // C++14650template <class C> constexpr auto cend(const C& c) noexcept(see-below) -> decltype(std::end(c)); // C++14651template <class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin()); // C++14, constexpr since C++17652template <class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin()); // C++14, constexpr since C++17653template <class C> constexpr auto rend(C& c) -> decltype(c.rend()); // C++14, constexpr since C++17654template <class C> constexpr auto rend(const C& c) -> decltype(c.rend()); // C++14, constexpr since C++17655template <class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il); // C++14, constexpr since C++17656template <class E> constexpr reverse_iterator<const E*> rend(initializer_list<E> il); // C++14, constexpr since C++17657template <class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N]); // C++14, constexpr since C++17658template <class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]); // C++14, constexpr since C++17659template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); // C++14, constexpr since C++17660template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c)); // C++14, constexpr since C++17661 662// 24.8, container access:663template <class C> constexpr auto size(const C& c) -> decltype(c.size()); // C++17664template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17665 666template <class C> constexpr auto ssize(const C& c)667 -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>; // C++20668template <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20669 670template <class C> constexpr auto empty(const C& c) -> decltype(c.empty()); // C++17671template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept; // C++17672template <class E> constexpr bool empty(initializer_list<E> il) noexcept; // C++17673template <class C> constexpr auto data(C& c) -> decltype(c.data()); // C++17674template <class C> constexpr auto data(const C& c) -> decltype(c.data()); // C++17675template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept; // C++17676template <class E> constexpr const E* data(initializer_list<E> il) noexcept; // C++17677 678} // std679 680*/681 682#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)683# include <__cxx03/iterator>684#else685# include <__config>686# include <__iterator/access.h>687# include <__iterator/advance.h>688# include <__iterator/back_insert_iterator.h>689# include <__iterator/distance.h>690# include <__iterator/front_insert_iterator.h>691# include <__iterator/insert_iterator.h>692# include <__iterator/istream_iterator.h>693# include <__iterator/istreambuf_iterator.h>694# include <__iterator/iterator.h>695# include <__iterator/iterator_traits.h>696# include <__iterator/move_iterator.h>697# include <__iterator/next.h>698# include <__iterator/ostream_iterator.h>699# include <__iterator/ostreambuf_iterator.h>700# include <__iterator/prev.h>701# include <__iterator/reverse_iterator.h>702# include <__iterator/wrap_iter.h>703 704# if _LIBCPP_STD_VER >= 14705# include <__iterator/reverse_access.h>706# endif707 708# if _LIBCPP_STD_VER >= 17709# include <__iterator/data.h>710# include <__iterator/empty.h>711# include <__iterator/size.h>712# endif713 714# if _LIBCPP_STD_VER >= 20715# include <__iterator/common_iterator.h>716# include <__iterator/concepts.h>717# include <__iterator/counted_iterator.h>718# include <__iterator/default_sentinel.h>719# include <__iterator/incrementable_traits.h>720# include <__iterator/indirectly_comparable.h>721# include <__iterator/iter_move.h>722# include <__iterator/iter_swap.h>723# include <__iterator/mergeable.h>724# include <__iterator/move_sentinel.h>725# include <__iterator/permutable.h>726# include <__iterator/projected.h>727# include <__iterator/readable_traits.h>728# include <__iterator/sortable.h>729# include <__iterator/unreachable_sentinel.h>730# endif731 732# include <version>733 734// standard-mandated includes735 736// [iterator.synopsis]737# include <compare>738# include <concepts>739 740// [range.access.general]741# if _LIBCPP_STD_VER >= 20742# include <__ranges/access.h>743# include <__ranges/data.h>744# include <__ranges/empty.h>745# include <__ranges/rbegin.h>746# include <__ranges/rend.h>747# include <__ranges/size.h>748# endif749 750# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)751# pragma GCC system_header752# endif753 754# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17755# include <variant>756# endif757 758# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20759# include <cstddef>760# include <cstdlib>761# include <exception>762# include <new>763# include <type_traits>764# include <typeinfo>765# include <utility>766# endif767#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)768 769#endif // _LIBCPP_ITERATOR770