1 // Iterators -*- C++ -*-
3 // Copyright (C) 2001-2014 Free Software Foundation, Inc.
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
28 * Hewlett-Packard Company
30 * Permission to use, copy, modify, distribute and sell this software
31 * and its documentation for any purpose is hereby granted without fee,
32 * provided that the above copyright notice appear in all copies and
33 * that both that copyright notice and this permission notice appear
34 * in supporting documentation. Hewlett-Packard Company makes no
35 * representations about the suitability of this software for any
36 * purpose. It is provided "as is" without express or implied warranty.
39 * Copyright (c) 1996-1998
40 * Silicon Graphics Computer Systems, Inc.
42 * Permission to use, copy, modify, distribute and sell this software
43 * and its documentation for any purpose is hereby granted without fee,
44 * provided that the above copyright notice appear in all copies and
45 * that both that copyright notice and this permission notice appear
46 * in supporting documentation. Silicon Graphics makes no
47 * representations about the suitability of this software for any
48 * purpose. It is provided "as is" without express or implied warranty.
51 /** @file bits/stl_iterator.h
52 * This is an internal header file, included by other library headers.
53 * Do not attempt to use it directly. @headername{iterator}
55 * This file implements reverse_iterator, back_insert_iterator,
56 * front_insert_iterator, insert_iterator, __normal_iterator, and their
57 * supporting functions and overloaded operators.
60 #ifndef _STL_ITERATOR_H
61 #define _STL_ITERATOR_H 1
63 #include <bits/cpp_type_traits.h>
64 #include <ext/type_traits.h>
65 #include <bits/move.h>
66 #include <bits/ptr_traits.h>
68 namespace std
_GLIBCXX_VISIBILITY(default)
70 _GLIBCXX_BEGIN_NAMESPACE_VERSION
73 * @addtogroup iterators
77 // 24.4.1 Reverse iterators
79 * Bidirectional and random access iterators have corresponding reverse
80 * %iterator adaptors that iterate through the data structure in the
81 * opposite direction. They have the same signatures as the corresponding
82 * iterators. The fundamental relation between a reverse %iterator and its
83 * corresponding %iterator @c i is established by the identity:
85 * &*(reverse_iterator(i)) == &*(i - 1)
88 * <em>This mapping is dictated by the fact that while there is always a
89 * pointer past the end of an array, there might not be a valid pointer
90 * before the beginning of an array.</em> [24.4.1]/1,2
92 * Reverse iterators can be tricky and surprising at first. Their
93 * semantics make sense, however, and the trickiness is a side effect of
94 * the requirement that the iterators must be safe.
96 template<typename _Iterator
>
97 class reverse_iterator
98 : public iterator
<typename iterator_traits
<_Iterator
>::iterator_category
,
99 typename iterator_traits
<_Iterator
>::value_type
,
100 typename iterator_traits
<_Iterator
>::difference_type
,
101 typename iterator_traits
<_Iterator
>::pointer
,
102 typename iterator_traits
<_Iterator
>::reference
>
107 typedef iterator_traits
<_Iterator
> __traits_type
;
110 typedef _Iterator iterator_type
;
111 typedef typename
__traits_type::difference_type difference_type
;
112 typedef typename
__traits_type::pointer pointer
;
113 typedef typename
__traits_type::reference reference
;
116 * The default constructor value-initializes member @p current.
117 * If it is a pointer, that means it is zero-initialized.
119 // _GLIBCXX_RESOLVE_LIB_DEFECTS
120 // 235 No specification of default ctor for reverse_iterator
121 reverse_iterator() : current() { }
124 * This %iterator will move in the opposite direction that @p x does.
127 reverse_iterator(iterator_type __x
) : current(__x
) { }
130 * The copy constructor is normal.
132 reverse_iterator(const reverse_iterator
& __x
)
133 : current(__x
.current
) { }
136 * A %reverse_iterator across other types can be copied if the
137 * underlying %iterator can be converted to the type of @c current.
139 template<typename _Iter
>
140 reverse_iterator(const reverse_iterator
<_Iter
>& __x
)
141 : current(__x
.base()) { }
144 * @return @c current, the %iterator used for underlying work.
151 * @return A reference to the value at @c --current
153 * This requires that @c --current is dereferenceable.
155 * @warning This implementation requires that for an iterator of the
156 * underlying iterator type, @c x, a reference obtained by
157 * @c *x remains valid after @c x has been modified or
158 * destroyed. This is a bug: http://gcc.gnu.org/PR51823
163 _Iterator __tmp
= current
;
168 * @return A pointer to the value at @c --current
170 * This requires that @c --current is dereferenceable.
174 { return &(operator*()); }
179 * Decrements the underlying iterator.
189 * @return The original value of @c *this
191 * Decrements the underlying iterator.
196 reverse_iterator __tmp
= *this;
204 * Increments the underlying iterator.
214 * @return A reverse_iterator with the previous value of @c *this
216 * Increments the underlying iterator.
221 reverse_iterator __tmp
= *this;
227 * @return A reverse_iterator that refers to @c current - @a __n
229 * The underlying iterator must be a Random Access Iterator.
232 operator+(difference_type __n
) const
233 { return reverse_iterator(current
- __n
); }
238 * Moves the underlying iterator backwards @a __n steps.
239 * The underlying iterator must be a Random Access Iterator.
242 operator+=(difference_type __n
)
249 * @return A reverse_iterator that refers to @c current - @a __n
251 * The underlying iterator must be a Random Access Iterator.
254 operator-(difference_type __n
) const
255 { return reverse_iterator(current
+ __n
); }
260 * Moves the underlying iterator forwards @a __n steps.
261 * The underlying iterator must be a Random Access Iterator.
264 operator-=(difference_type __n
)
271 * @return The value at @c current - @a __n - 1
273 * The underlying iterator must be a Random Access Iterator.
276 operator[](difference_type __n
) const
277 { return *(*this + __n
); }
282 * @param __x A %reverse_iterator.
283 * @param __y A %reverse_iterator.
284 * @return A simple bool.
286 * Reverse iterators forward many operations to their underlying base()
287 * iterators. Others are implemented in terms of one another.
290 template<typename _Iterator
>
292 operator==(const reverse_iterator
<_Iterator
>& __x
,
293 const reverse_iterator
<_Iterator
>& __y
)
294 { return __x
.base() == __y
.base(); }
296 template<typename _Iterator
>
298 operator<(const reverse_iterator
<_Iterator
>& __x
,
299 const reverse_iterator
<_Iterator
>& __y
)
300 { return __y
.base() < __x
.base(); }
302 template<typename _Iterator
>
304 operator!=(const reverse_iterator
<_Iterator
>& __x
,
305 const reverse_iterator
<_Iterator
>& __y
)
306 { return !(__x
== __y
); }
308 template<typename _Iterator
>
310 operator>(const reverse_iterator
<_Iterator
>& __x
,
311 const reverse_iterator
<_Iterator
>& __y
)
312 { return __y
< __x
; }
314 template<typename _Iterator
>
316 operator<=(const reverse_iterator
<_Iterator
>& __x
,
317 const reverse_iterator
<_Iterator
>& __y
)
318 { return !(__y
< __x
); }
320 template<typename _Iterator
>
322 operator>=(const reverse_iterator
<_Iterator
>& __x
,
323 const reverse_iterator
<_Iterator
>& __y
)
324 { return !(__x
< __y
); }
326 template<typename _Iterator
>
327 inline typename reverse_iterator
<_Iterator
>::difference_type
328 operator-(const reverse_iterator
<_Iterator
>& __x
,
329 const reverse_iterator
<_Iterator
>& __y
)
330 { return __y
.base() - __x
.base(); }
332 template<typename _Iterator
>
333 inline reverse_iterator
<_Iterator
>
334 operator+(typename reverse_iterator
<_Iterator
>::difference_type __n
,
335 const reverse_iterator
<_Iterator
>& __x
)
336 { return reverse_iterator
<_Iterator
>(__x
.base() - __n
); }
338 // _GLIBCXX_RESOLVE_LIB_DEFECTS
339 // DR 280. Comparison of reverse_iterator to const reverse_iterator.
340 template<typename _IteratorL
, typename _IteratorR
>
342 operator==(const reverse_iterator
<_IteratorL
>& __x
,
343 const reverse_iterator
<_IteratorR
>& __y
)
344 { return __x
.base() == __y
.base(); }
346 template<typename _IteratorL
, typename _IteratorR
>
348 operator<(const reverse_iterator
<_IteratorL
>& __x
,
349 const reverse_iterator
<_IteratorR
>& __y
)
350 { return __y
.base() < __x
.base(); }
352 template<typename _IteratorL
, typename _IteratorR
>
354 operator!=(const reverse_iterator
<_IteratorL
>& __x
,
355 const reverse_iterator
<_IteratorR
>& __y
)
356 { return !(__x
== __y
); }
358 template<typename _IteratorL
, typename _IteratorR
>
360 operator>(const reverse_iterator
<_IteratorL
>& __x
,
361 const reverse_iterator
<_IteratorR
>& __y
)
362 { return __y
< __x
; }
364 template<typename _IteratorL
, typename _IteratorR
>
366 operator<=(const reverse_iterator
<_IteratorL
>& __x
,
367 const reverse_iterator
<_IteratorR
>& __y
)
368 { return !(__y
< __x
); }
370 template<typename _IteratorL
, typename _IteratorR
>
372 operator>=(const reverse_iterator
<_IteratorL
>& __x
,
373 const reverse_iterator
<_IteratorR
>& __y
)
374 { return !(__x
< __y
); }
376 template<typename _IteratorL
, typename _IteratorR
>
377 #if __cplusplus >= 201103L
380 operator-(const reverse_iterator
<_IteratorL
>& __x
,
381 const reverse_iterator
<_IteratorR
>& __y
)
382 -> decltype(__y
.base() - __x
.base())
384 inline typename reverse_iterator
<_IteratorL
>::difference_type
385 operator-(const reverse_iterator
<_IteratorL
>& __x
,
386 const reverse_iterator
<_IteratorR
>& __y
)
388 { return __y
.base() - __x
.base(); }
391 // 24.4.2.2.1 back_insert_iterator
393 * @brief Turns assignment into insertion.
395 * These are output iterators, constructed from a container-of-T.
396 * Assigning a T to the iterator appends it to the container using
399 * Tip: Using the back_inserter function to create these iterators can
402 template<typename _Container
>
403 class back_insert_iterator
404 : public iterator
<output_iterator_tag
, void, void, void, void>
407 _Container
* container
;
410 /// A nested typedef for the type of whatever container you used.
411 typedef _Container container_type
;
413 /// The only way to create this %iterator is with a container.
415 back_insert_iterator(_Container
& __x
) : container(&__x
) { }
418 * @param __value An instance of whatever type
419 * container_type::const_reference is; presumably a
420 * reference-to-const T for container<T>.
421 * @return This %iterator, for chained operations.
423 * This kind of %iterator doesn't really have a @a position in the
424 * container (you can think of the position as being permanently at
425 * the end, if you like). Assigning a value to the %iterator will
426 * always append the value to the end of the container.
428 #if __cplusplus < 201103L
429 back_insert_iterator
&
430 operator=(typename
_Container::const_reference __value
)
432 container
->push_back(__value
);
436 back_insert_iterator
&
437 operator=(const typename
_Container::value_type
& __value
)
439 container
->push_back(__value
);
443 back_insert_iterator
&
444 operator=(typename
_Container::value_type
&& __value
)
446 container
->push_back(std::move(__value
));
451 /// Simply returns *this.
452 back_insert_iterator
&
456 /// Simply returns *this. (This %iterator does not @a move.)
457 back_insert_iterator
&
461 /// Simply returns *this. (This %iterator does not @a move.)
468 * @param __x A container of arbitrary type.
469 * @return An instance of back_insert_iterator working on @p __x.
471 * This wrapper function helps in creating back_insert_iterator instances.
472 * Typing the name of the %iterator requires knowing the precise full
473 * type of the container, which can be tedious and impedes generic
474 * programming. Using this function lets you take advantage of automatic
475 * template parameter deduction, making the compiler match the correct
478 template<typename _Container
>
479 inline back_insert_iterator
<_Container
>
480 back_inserter(_Container
& __x
)
481 { return back_insert_iterator
<_Container
>(__x
); }
484 * @brief Turns assignment into insertion.
486 * These are output iterators, constructed from a container-of-T.
487 * Assigning a T to the iterator prepends it to the container using
490 * Tip: Using the front_inserter function to create these iterators can
493 template<typename _Container
>
494 class front_insert_iterator
495 : public iterator
<output_iterator_tag
, void, void, void, void>
498 _Container
* container
;
501 /// A nested typedef for the type of whatever container you used.
502 typedef _Container container_type
;
504 /// The only way to create this %iterator is with a container.
505 explicit front_insert_iterator(_Container
& __x
) : container(&__x
) { }
508 * @param __value An instance of whatever type
509 * container_type::const_reference is; presumably a
510 * reference-to-const T for container<T>.
511 * @return This %iterator, for chained operations.
513 * This kind of %iterator doesn't really have a @a position in the
514 * container (you can think of the position as being permanently at
515 * the front, if you like). Assigning a value to the %iterator will
516 * always prepend the value to the front of the container.
518 #if __cplusplus < 201103L
519 front_insert_iterator
&
520 operator=(typename
_Container::const_reference __value
)
522 container
->push_front(__value
);
526 front_insert_iterator
&
527 operator=(const typename
_Container::value_type
& __value
)
529 container
->push_front(__value
);
533 front_insert_iterator
&
534 operator=(typename
_Container::value_type
&& __value
)
536 container
->push_front(std::move(__value
));
541 /// Simply returns *this.
542 front_insert_iterator
&
546 /// Simply returns *this. (This %iterator does not @a move.)
547 front_insert_iterator
&
551 /// Simply returns *this. (This %iterator does not @a move.)
552 front_insert_iterator
558 * @param __x A container of arbitrary type.
559 * @return An instance of front_insert_iterator working on @p x.
561 * This wrapper function helps in creating front_insert_iterator instances.
562 * Typing the name of the %iterator requires knowing the precise full
563 * type of the container, which can be tedious and impedes generic
564 * programming. Using this function lets you take advantage of automatic
565 * template parameter deduction, making the compiler match the correct
568 template<typename _Container
>
569 inline front_insert_iterator
<_Container
>
570 front_inserter(_Container
& __x
)
571 { return front_insert_iterator
<_Container
>(__x
); }
574 * @brief Turns assignment into insertion.
576 * These are output iterators, constructed from a container-of-T.
577 * Assigning a T to the iterator inserts it in the container at the
578 * %iterator's position, rather than overwriting the value at that
581 * (Sequences will actually insert a @e copy of the value before the
582 * %iterator's position.)
584 * Tip: Using the inserter function to create these iterators can
587 template<typename _Container
>
588 class insert_iterator
589 : public iterator
<output_iterator_tag
, void, void, void, void>
592 _Container
* container
;
593 typename
_Container::iterator iter
;
596 /// A nested typedef for the type of whatever container you used.
597 typedef _Container container_type
;
600 * The only way to create this %iterator is with a container and an
601 * initial position (a normal %iterator into the container).
603 insert_iterator(_Container
& __x
, typename
_Container::iterator __i
)
604 : container(&__x
), iter(__i
) {}
607 * @param __value An instance of whatever type
608 * container_type::const_reference is; presumably a
609 * reference-to-const T for container<T>.
610 * @return This %iterator, for chained operations.
612 * This kind of %iterator maintains its own position in the
613 * container. Assigning a value to the %iterator will insert the
614 * value into the container at the place before the %iterator.
616 * The position is maintained such that subsequent assignments will
617 * insert values immediately after one another. For example,
619 * // vector v contains A and Z
621 * insert_iterator i (v, ++v.begin());
626 * // vector v contains A, 1, 2, 3, and Z
629 #if __cplusplus < 201103L
631 operator=(typename
_Container::const_reference __value
)
633 iter
= container
->insert(iter
, __value
);
639 operator=(const typename
_Container::value_type
& __value
)
641 iter
= container
->insert(iter
, __value
);
647 operator=(typename
_Container::value_type
&& __value
)
649 iter
= container
->insert(iter
, std::move(__value
));
655 /// Simply returns *this.
660 /// Simply returns *this. (This %iterator does not @a move.)
665 /// Simply returns *this. (This %iterator does not @a move.)
672 * @param __x A container of arbitrary type.
673 * @return An instance of insert_iterator working on @p __x.
675 * This wrapper function helps in creating insert_iterator instances.
676 * Typing the name of the %iterator requires knowing the precise full
677 * type of the container, which can be tedious and impedes generic
678 * programming. Using this function lets you take advantage of automatic
679 * template parameter deduction, making the compiler match the correct
682 template<typename _Container
, typename _Iterator
>
683 inline insert_iterator
<_Container
>
684 inserter(_Container
& __x
, _Iterator __i
)
686 return insert_iterator
<_Container
>(__x
,
687 typename
_Container::iterator(__i
));
690 // @} group iterators
692 _GLIBCXX_END_NAMESPACE_VERSION
695 namespace __gnu_cxx
_GLIBCXX_VISIBILITY(default)
697 _GLIBCXX_BEGIN_NAMESPACE_VERSION
699 // This iterator adapter is @a normal in the sense that it does not
700 // change the semantics of any of the operators of its iterator
701 // parameter. Its primary purpose is to convert an iterator that is
702 // not a class, e.g. a pointer, into an iterator that is a class.
703 // The _Container parameter exists solely so that different containers
704 // using this template can instantiate different types, even if the
705 // _Iterator parameter is the same.
706 using std::iterator_traits
;
708 template<typename _Iterator
, typename _Container
>
709 class __normal_iterator
712 _Iterator _M_current
;
714 typedef iterator_traits
<_Iterator
> __traits_type
;
717 typedef _Iterator iterator_type
;
718 typedef typename
__traits_type::iterator_category iterator_category
;
719 typedef typename
__traits_type::value_type value_type
;
720 typedef typename
__traits_type::difference_type difference_type
;
721 typedef typename
__traits_type::reference reference
;
722 typedef typename
__traits_type::pointer pointer
;
724 _GLIBCXX_CONSTEXPR
__normal_iterator() _GLIBCXX_NOEXCEPT
725 : _M_current(_Iterator()) { }
728 __normal_iterator(const _Iterator
& __i
) _GLIBCXX_NOEXCEPT
729 : _M_current(__i
) { }
731 // Allow iterator to const_iterator conversion
732 template<typename _Iter
>
733 __normal_iterator(const __normal_iterator
<_Iter
,
734 typename __enable_if
<
735 (std::__are_same
<_Iter
, typename
_Container::pointer
>::__value
),
736 _Container
>::__type
>& __i
) _GLIBCXX_NOEXCEPT
737 : _M_current(__i
.base()) { }
739 #if __cplusplus >= 201103L
740 __normal_iterator
<typename
_Container::pointer
, _Container
>
741 _M_const_cast() const noexcept
743 using _PTraits
= std::pointer_traits
<typename
_Container::pointer
>;
744 return __normal_iterator
<typename
_Container::pointer
, _Container
>
745 (_PTraits::pointer_to(const_cast<typename
_PTraits::element_type
&>
750 _M_const_cast() const
754 // Forward iterator requirements
756 operator*() const _GLIBCXX_NOEXCEPT
757 { return *_M_current
; }
760 operator->() const _GLIBCXX_NOEXCEPT
761 { return _M_current
; }
764 operator++() _GLIBCXX_NOEXCEPT
771 operator++(int) _GLIBCXX_NOEXCEPT
772 { return __normal_iterator(_M_current
++); }
774 // Bidirectional iterator requirements
776 operator--() _GLIBCXX_NOEXCEPT
783 operator--(int) _GLIBCXX_NOEXCEPT
784 { return __normal_iterator(_M_current
--); }
786 // Random access iterator requirements
788 operator[](difference_type __n
) const _GLIBCXX_NOEXCEPT
789 { return _M_current
[__n
]; }
792 operator+=(difference_type __n
) _GLIBCXX_NOEXCEPT
793 { _M_current
+= __n
; return *this; }
796 operator+(difference_type __n
) const _GLIBCXX_NOEXCEPT
797 { return __normal_iterator(_M_current
+ __n
); }
800 operator-=(difference_type __n
) _GLIBCXX_NOEXCEPT
801 { _M_current
-= __n
; return *this; }
804 operator-(difference_type __n
) const _GLIBCXX_NOEXCEPT
805 { return __normal_iterator(_M_current
- __n
); }
808 base() const _GLIBCXX_NOEXCEPT
809 { return _M_current
; }
812 // Note: In what follows, the left- and right-hand-side iterators are
813 // allowed to vary in types (conceptually in cv-qualification) so that
814 // comparison between cv-qualified and non-cv-qualified iterators be
815 // valid. However, the greedy and unfriendly operators in std::rel_ops
816 // will make overload resolution ambiguous (when in scope) if we don't
817 // provide overloads whose operands are of the same type. Can someone
818 // remind me what generic programming is about? -- Gaby
820 // Forward iterator requirements
821 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
823 operator==(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
824 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
826 { return __lhs
.base() == __rhs
.base(); }
828 template<typename _Iterator
, typename _Container
>
830 operator==(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
831 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
833 { return __lhs
.base() == __rhs
.base(); }
835 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
837 operator!=(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
838 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
840 { return __lhs
.base() != __rhs
.base(); }
842 template<typename _Iterator
, typename _Container
>
844 operator!=(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
845 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
847 { return __lhs
.base() != __rhs
.base(); }
849 // Random access iterator requirements
850 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
852 operator<(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
853 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
855 { return __lhs
.base() < __rhs
.base(); }
857 template<typename _Iterator
, typename _Container
>
859 operator<(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
860 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
862 { return __lhs
.base() < __rhs
.base(); }
864 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
866 operator>(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
867 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
869 { return __lhs
.base() > __rhs
.base(); }
871 template<typename _Iterator
, typename _Container
>
873 operator>(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
874 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
876 { return __lhs
.base() > __rhs
.base(); }
878 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
880 operator<=(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
881 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
883 { return __lhs
.base() <= __rhs
.base(); }
885 template<typename _Iterator
, typename _Container
>
887 operator<=(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
888 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
890 { return __lhs
.base() <= __rhs
.base(); }
892 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
894 operator>=(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
895 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
897 { return __lhs
.base() >= __rhs
.base(); }
899 template<typename _Iterator
, typename _Container
>
901 operator>=(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
902 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
904 { return __lhs
.base() >= __rhs
.base(); }
906 // _GLIBCXX_RESOLVE_LIB_DEFECTS
907 // According to the resolution of DR179 not only the various comparison
908 // operators but also operator- must accept mixed iterator/const_iterator
910 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
911 #if __cplusplus >= 201103L
914 operator-(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
915 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
) noexcept
916 -> decltype(__lhs
.base() - __rhs
.base())
918 inline typename __normal_iterator
<_IteratorL
, _Container
>::difference_type
919 operator-(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
920 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
922 { return __lhs
.base() - __rhs
.base(); }
924 template<typename _Iterator
, typename _Container
>
925 inline typename __normal_iterator
<_Iterator
, _Container
>::difference_type
926 operator-(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
927 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
929 { return __lhs
.base() - __rhs
.base(); }
931 template<typename _Iterator
, typename _Container
>
932 inline __normal_iterator
<_Iterator
, _Container
>
933 operator+(typename __normal_iterator
<_Iterator
, _Container
>::difference_type
934 __n
, const __normal_iterator
<_Iterator
, _Container
>& __i
)
936 { return __normal_iterator
<_Iterator
, _Container
>(__i
.base() + __n
); }
938 _GLIBCXX_END_NAMESPACE_VERSION
941 #if __cplusplus >= 201103L
943 namespace std
_GLIBCXX_VISIBILITY(default)
945 _GLIBCXX_BEGIN_NAMESPACE_VERSION
948 * @addtogroup iterators
952 // 24.4.3 Move iterators
954 * Class template move_iterator is an iterator adapter with the same
955 * behavior as the underlying iterator except that its dereference
956 * operator implicitly converts the value returned by the underlying
957 * iterator's dereference operator to an rvalue reference. Some
958 * generic algorithms can be called with move iterators to replace
959 * copying with moving.
961 template<typename _Iterator
>
965 _Iterator _M_current
;
967 typedef iterator_traits
<_Iterator
> __traits_type
;
968 typedef typename
__traits_type::reference __base_ref
;
971 typedef _Iterator iterator_type
;
972 typedef typename
__traits_type::iterator_category iterator_category
;
973 typedef typename
__traits_type::value_type value_type
;
974 typedef typename
__traits_type::difference_type difference_type
;
976 typedef _Iterator pointer
;
977 // _GLIBCXX_RESOLVE_LIB_DEFECTS
978 // 2106. move_iterator wrapping iterators returning prvalues
979 typedef typename conditional
<is_reference
<__base_ref
>::value
,
980 typename remove_reference
<__base_ref
>::type
&&,
981 __base_ref
>::type reference
;
987 move_iterator(iterator_type __i
)
988 : _M_current(__i
) { }
990 template<typename _Iter
>
991 move_iterator(const move_iterator
<_Iter
>& __i
)
992 : _M_current(__i
.base()) { }
996 { return _M_current
; }
1000 { return static_cast<reference
>(*_M_current
); }
1004 { return _M_current
; }
1016 move_iterator __tmp
= *this;
1031 move_iterator __tmp
= *this;
1037 operator+(difference_type __n
) const
1038 { return move_iterator(_M_current
+ __n
); }
1041 operator+=(difference_type __n
)
1048 operator-(difference_type __n
) const
1049 { return move_iterator(_M_current
- __n
); }
1052 operator-=(difference_type __n
)
1059 operator[](difference_type __n
) const
1060 { return std::move(_M_current
[__n
]); }
1063 // Note: See __normal_iterator operators note from Gaby to understand
1064 // why there are always 2 versions for most of the move_iterator
1066 template<typename _IteratorL
, typename _IteratorR
>
1068 operator==(const move_iterator
<_IteratorL
>& __x
,
1069 const move_iterator
<_IteratorR
>& __y
)
1070 { return __x
.base() == __y
.base(); }
1072 template<typename _Iterator
>
1074 operator==(const move_iterator
<_Iterator
>& __x
,
1075 const move_iterator
<_Iterator
>& __y
)
1076 { return __x
.base() == __y
.base(); }
1078 template<typename _IteratorL
, typename _IteratorR
>
1080 operator!=(const move_iterator
<_IteratorL
>& __x
,
1081 const move_iterator
<_IteratorR
>& __y
)
1082 { return !(__x
== __y
); }
1084 template<typename _Iterator
>
1086 operator!=(const move_iterator
<_Iterator
>& __x
,
1087 const move_iterator
<_Iterator
>& __y
)
1088 { return !(__x
== __y
); }
1090 template<typename _IteratorL
, typename _IteratorR
>
1092 operator<(const move_iterator
<_IteratorL
>& __x
,
1093 const move_iterator
<_IteratorR
>& __y
)
1094 { return __x
.base() < __y
.base(); }
1096 template<typename _Iterator
>
1098 operator<(const move_iterator
<_Iterator
>& __x
,
1099 const move_iterator
<_Iterator
>& __y
)
1100 { return __x
.base() < __y
.base(); }
1102 template<typename _IteratorL
, typename _IteratorR
>
1104 operator<=(const move_iterator
<_IteratorL
>& __x
,
1105 const move_iterator
<_IteratorR
>& __y
)
1106 { return !(__y
< __x
); }
1108 template<typename _Iterator
>
1110 operator<=(const move_iterator
<_Iterator
>& __x
,
1111 const move_iterator
<_Iterator
>& __y
)
1112 { return !(__y
< __x
); }
1114 template<typename _IteratorL
, typename _IteratorR
>
1116 operator>(const move_iterator
<_IteratorL
>& __x
,
1117 const move_iterator
<_IteratorR
>& __y
)
1118 { return __y
< __x
; }
1120 template<typename _Iterator
>
1122 operator>(const move_iterator
<_Iterator
>& __x
,
1123 const move_iterator
<_Iterator
>& __y
)
1124 { return __y
< __x
; }
1126 template<typename _IteratorL
, typename _IteratorR
>
1128 operator>=(const move_iterator
<_IteratorL
>& __x
,
1129 const move_iterator
<_IteratorR
>& __y
)
1130 { return !(__x
< __y
); }
1132 template<typename _Iterator
>
1134 operator>=(const move_iterator
<_Iterator
>& __x
,
1135 const move_iterator
<_Iterator
>& __y
)
1136 { return !(__x
< __y
); }
1139 template<typename _IteratorL
, typename _IteratorR
>
1141 operator-(const move_iterator
<_IteratorL
>& __x
,
1142 const move_iterator
<_IteratorR
>& __y
)
1143 -> decltype(__x
.base() - __y
.base())
1144 { return __x
.base() - __y
.base(); }
1146 template<typename _Iterator
>
1148 operator-(const move_iterator
<_Iterator
>& __x
,
1149 const move_iterator
<_Iterator
>& __y
)
1150 -> decltype(__x
.base() - __y
.base())
1151 { return __x
.base() - __y
.base(); }
1153 template<typename _Iterator
>
1154 inline move_iterator
<_Iterator
>
1155 operator+(typename move_iterator
<_Iterator
>::difference_type __n
,
1156 const move_iterator
<_Iterator
>& __x
)
1157 { return __x
+ __n
; }
1159 template<typename _Iterator
>
1160 inline move_iterator
<_Iterator
>
1161 make_move_iterator(_Iterator __i
)
1162 { return move_iterator
<_Iterator
>(__i
); }
1164 template<typename _Iterator
, typename _ReturnType
1165 = typename conditional
<__move_if_noexcept_cond
1166 <typename iterator_traits
<_Iterator
>::value_type
>::value
,
1167 _Iterator
, move_iterator
<_Iterator
>>::type
>
1169 __make_move_if_noexcept_iterator(_Iterator __i
)
1170 { return _ReturnType(__i
); }
1172 // @} group iterators
1174 _GLIBCXX_END_NAMESPACE_VERSION
1177 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
1178 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
1179 std::__make_move_if_noexcept_iterator(_Iter)
1181 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
1182 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)