1 // Iterators -*- C++ -*-
3 // Copyright (C) 2001-2013 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() : _M_current(_Iterator()) { }
727 __normal_iterator(const _Iterator
& __i
) : _M_current(__i
) { }
729 // Allow iterator to const_iterator conversion
730 template<typename _Iter
>
731 __normal_iterator(const __normal_iterator
<_Iter
,
732 typename __enable_if
<
733 (std::__are_same
<_Iter
, typename
_Container::pointer
>::__value
),
734 _Container
>::__type
>& __i
)
735 : _M_current(__i
.base()) { }
737 #if __cplusplus >= 201103L
738 __normal_iterator
<typename
_Container::pointer
, _Container
>
739 _M_const_cast() const
741 using _PTraits
= std::pointer_traits
<typename
_Container::pointer
>;
742 return __normal_iterator
<typename
_Container::pointer
, _Container
>
743 (_PTraits::pointer_to(const_cast<typename
_PTraits::element_type
&>
748 _M_const_cast() const
752 // Forward iterator requirements
755 { return *_M_current
; }
759 { return _M_current
; }
770 { return __normal_iterator(_M_current
++); }
772 // Bidirectional iterator requirements
782 { return __normal_iterator(_M_current
--); }
784 // Random access iterator requirements
786 operator[](difference_type __n
) const
787 { return _M_current
[__n
]; }
790 operator+=(difference_type __n
)
791 { _M_current
+= __n
; return *this; }
794 operator+(difference_type __n
) const
795 { return __normal_iterator(_M_current
+ __n
); }
798 operator-=(difference_type __n
)
799 { _M_current
-= __n
; return *this; }
802 operator-(difference_type __n
) const
803 { return __normal_iterator(_M_current
- __n
); }
807 { return _M_current
; }
810 // Note: In what follows, the left- and right-hand-side iterators are
811 // allowed to vary in types (conceptually in cv-qualification) so that
812 // comparison between cv-qualified and non-cv-qualified iterators be
813 // valid. However, the greedy and unfriendly operators in std::rel_ops
814 // will make overload resolution ambiguous (when in scope) if we don't
815 // provide overloads whose operands are of the same type. Can someone
816 // remind me what generic programming is about? -- Gaby
818 // Forward iterator requirements
819 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
821 operator==(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
822 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
823 { return __lhs
.base() == __rhs
.base(); }
825 template<typename _Iterator
, typename _Container
>
827 operator==(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
828 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
829 { return __lhs
.base() == __rhs
.base(); }
831 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
833 operator!=(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
834 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
835 { return __lhs
.base() != __rhs
.base(); }
837 template<typename _Iterator
, typename _Container
>
839 operator!=(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
840 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
841 { return __lhs
.base() != __rhs
.base(); }
843 // Random access iterator requirements
844 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
846 operator<(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
847 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
848 { return __lhs
.base() < __rhs
.base(); }
850 template<typename _Iterator
, typename _Container
>
852 operator<(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
853 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
854 { return __lhs
.base() < __rhs
.base(); }
856 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
858 operator>(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
859 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
860 { return __lhs
.base() > __rhs
.base(); }
862 template<typename _Iterator
, typename _Container
>
864 operator>(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
865 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
866 { return __lhs
.base() > __rhs
.base(); }
868 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
870 operator<=(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
871 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
872 { return __lhs
.base() <= __rhs
.base(); }
874 template<typename _Iterator
, typename _Container
>
876 operator<=(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
877 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
878 { return __lhs
.base() <= __rhs
.base(); }
880 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
882 operator>=(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
883 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
884 { return __lhs
.base() >= __rhs
.base(); }
886 template<typename _Iterator
, typename _Container
>
888 operator>=(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
889 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
890 { return __lhs
.base() >= __rhs
.base(); }
892 // _GLIBCXX_RESOLVE_LIB_DEFECTS
893 // According to the resolution of DR179 not only the various comparison
894 // operators but also operator- must accept mixed iterator/const_iterator
896 template<typename _IteratorL
, typename _IteratorR
, typename _Container
>
897 #if __cplusplus >= 201103L
900 operator-(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
901 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
902 -> decltype(__lhs
.base() - __rhs
.base())
904 inline typename __normal_iterator
<_IteratorL
, _Container
>::difference_type
905 operator-(const __normal_iterator
<_IteratorL
, _Container
>& __lhs
,
906 const __normal_iterator
<_IteratorR
, _Container
>& __rhs
)
908 { return __lhs
.base() - __rhs
.base(); }
910 template<typename _Iterator
, typename _Container
>
911 inline typename __normal_iterator
<_Iterator
, _Container
>::difference_type
912 operator-(const __normal_iterator
<_Iterator
, _Container
>& __lhs
,
913 const __normal_iterator
<_Iterator
, _Container
>& __rhs
)
914 { return __lhs
.base() - __rhs
.base(); }
916 template<typename _Iterator
, typename _Container
>
917 inline __normal_iterator
<_Iterator
, _Container
>
918 operator+(typename __normal_iterator
<_Iterator
, _Container
>::difference_type
919 __n
, const __normal_iterator
<_Iterator
, _Container
>& __i
)
920 { return __normal_iterator
<_Iterator
, _Container
>(__i
.base() + __n
); }
922 _GLIBCXX_END_NAMESPACE_VERSION
925 #if __cplusplus >= 201103L
927 namespace std
_GLIBCXX_VISIBILITY(default)
929 _GLIBCXX_BEGIN_NAMESPACE_VERSION
932 * @addtogroup iterators
936 // 24.4.3 Move iterators
938 * Class template move_iterator is an iterator adapter with the same
939 * behavior as the underlying iterator except that its dereference
940 * operator implicitly converts the value returned by the underlying
941 * iterator's dereference operator to an rvalue reference. Some
942 * generic algorithms can be called with move iterators to replace
943 * copying with moving.
945 template<typename _Iterator
>
949 _Iterator _M_current
;
951 typedef iterator_traits
<_Iterator
> __traits_type
;
954 typedef _Iterator iterator_type
;
955 typedef typename
__traits_type::iterator_category iterator_category
;
956 typedef typename
__traits_type::value_type value_type
;
957 typedef typename
__traits_type::difference_type difference_type
;
959 typedef _Iterator pointer
;
960 typedef value_type
&& reference
;
966 move_iterator(iterator_type __i
)
967 : _M_current(__i
) { }
969 template<typename _Iter
>
970 move_iterator(const move_iterator
<_Iter
>& __i
)
971 : _M_current(__i
.base()) { }
975 { return _M_current
; }
979 { return std::move(*_M_current
); }
983 { return _M_current
; }
995 move_iterator __tmp
= *this;
1010 move_iterator __tmp
= *this;
1016 operator+(difference_type __n
) const
1017 { return move_iterator(_M_current
+ __n
); }
1020 operator+=(difference_type __n
)
1027 operator-(difference_type __n
) const
1028 { return move_iterator(_M_current
- __n
); }
1031 operator-=(difference_type __n
)
1038 operator[](difference_type __n
) const
1039 { return std::move(_M_current
[__n
]); }
1042 // Note: See __normal_iterator operators note from Gaby to understand
1043 // why there are always 2 versions for most of the move_iterator
1045 template<typename _IteratorL
, typename _IteratorR
>
1047 operator==(const move_iterator
<_IteratorL
>& __x
,
1048 const move_iterator
<_IteratorR
>& __y
)
1049 { return __x
.base() == __y
.base(); }
1051 template<typename _Iterator
>
1053 operator==(const move_iterator
<_Iterator
>& __x
,
1054 const move_iterator
<_Iterator
>& __y
)
1055 { return __x
.base() == __y
.base(); }
1057 template<typename _IteratorL
, typename _IteratorR
>
1059 operator!=(const move_iterator
<_IteratorL
>& __x
,
1060 const move_iterator
<_IteratorR
>& __y
)
1061 { return !(__x
== __y
); }
1063 template<typename _Iterator
>
1065 operator!=(const move_iterator
<_Iterator
>& __x
,
1066 const move_iterator
<_Iterator
>& __y
)
1067 { return !(__x
== __y
); }
1069 template<typename _IteratorL
, typename _IteratorR
>
1071 operator<(const move_iterator
<_IteratorL
>& __x
,
1072 const move_iterator
<_IteratorR
>& __y
)
1073 { return __x
.base() < __y
.base(); }
1075 template<typename _Iterator
>
1077 operator<(const move_iterator
<_Iterator
>& __x
,
1078 const move_iterator
<_Iterator
>& __y
)
1079 { return __x
.base() < __y
.base(); }
1081 template<typename _IteratorL
, typename _IteratorR
>
1083 operator<=(const move_iterator
<_IteratorL
>& __x
,
1084 const move_iterator
<_IteratorR
>& __y
)
1085 { return !(__y
< __x
); }
1087 template<typename _Iterator
>
1089 operator<=(const move_iterator
<_Iterator
>& __x
,
1090 const move_iterator
<_Iterator
>& __y
)
1091 { return !(__y
< __x
); }
1093 template<typename _IteratorL
, typename _IteratorR
>
1095 operator>(const move_iterator
<_IteratorL
>& __x
,
1096 const move_iterator
<_IteratorR
>& __y
)
1097 { return __y
< __x
; }
1099 template<typename _Iterator
>
1101 operator>(const move_iterator
<_Iterator
>& __x
,
1102 const move_iterator
<_Iterator
>& __y
)
1103 { return __y
< __x
; }
1105 template<typename _IteratorL
, typename _IteratorR
>
1107 operator>=(const move_iterator
<_IteratorL
>& __x
,
1108 const move_iterator
<_IteratorR
>& __y
)
1109 { return !(__x
< __y
); }
1111 template<typename _Iterator
>
1113 operator>=(const move_iterator
<_Iterator
>& __x
,
1114 const move_iterator
<_Iterator
>& __y
)
1115 { return !(__x
< __y
); }
1118 template<typename _IteratorL
, typename _IteratorR
>
1120 operator-(const move_iterator
<_IteratorL
>& __x
,
1121 const move_iterator
<_IteratorR
>& __y
)
1122 -> decltype(__x
.base() - __y
.base())
1123 { return __x
.base() - __y
.base(); }
1125 template<typename _Iterator
>
1127 operator-(const move_iterator
<_Iterator
>& __x
,
1128 const move_iterator
<_Iterator
>& __y
)
1129 -> decltype(__x
.base() - __y
.base())
1130 { return __x
.base() - __y
.base(); }
1132 template<typename _Iterator
>
1133 inline move_iterator
<_Iterator
>
1134 operator+(typename move_iterator
<_Iterator
>::difference_type __n
,
1135 const move_iterator
<_Iterator
>& __x
)
1136 { return __x
+ __n
; }
1138 template<typename _Iterator
>
1139 inline move_iterator
<_Iterator
>
1140 make_move_iterator(_Iterator __i
)
1141 { return move_iterator
<_Iterator
>(__i
); }
1143 template<typename _Iterator
, typename _ReturnType
1144 = typename conditional
<__move_if_noexcept_cond
1145 <typename iterator_traits
<_Iterator
>::value_type
>::value
,
1146 _Iterator
, move_iterator
<_Iterator
>>::type
>
1148 __make_move_if_noexcept_iterator(_Iterator __i
)
1149 { return _ReturnType(__i
); }
1151 // @} group iterators
1153 _GLIBCXX_END_NAMESPACE_VERSION
1156 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
1157 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
1158 std::__make_move_if_noexcept_iterator(_Iter)
1160 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
1161 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)