56 #ifndef _STL_BVECTOR_H 57 #define _STL_BVECTOR_H 1 59 #if __cplusplus >= 201103L 63 namespace std _GLIBCXX_VISIBILITY(default)
65 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
67 typedef unsigned long _Bit_type;
68 enum { _S_word_bit = int(__CHAR_BIT__ *
sizeof(_Bit_type)) };
75 _Bit_reference(_Bit_type * __x, _Bit_type __y)
76 : _M_p(__x), _M_mask(__y) { }
78 _Bit_reference() _GLIBCXX_NOEXCEPT : _M_p(0), _M_mask(0) { }
80 operator bool() const _GLIBCXX_NOEXCEPT
81 {
return !!(*_M_p & _M_mask); }
84 operator=(
bool __x) _GLIBCXX_NOEXCEPT
94 operator=(
const _Bit_reference& __x) _GLIBCXX_NOEXCEPT
95 {
return *
this = bool(__x); }
98 operator==(
const _Bit_reference& __x)
const 99 {
return bool(*
this) == bool(__x); }
102 operator<(
const _Bit_reference& __x)
const 103 {
return !bool(*
this) && bool(__x); }
106 flip() _GLIBCXX_NOEXCEPT
107 { *_M_p ^= _M_mask; }
110 #if __cplusplus >= 201103L 112 swap(_Bit_reference __x, _Bit_reference __y) noexcept
120 swap(_Bit_reference __x,
bool& __y) noexcept
128 swap(
bool& __x, _Bit_reference __y) noexcept
136 struct _Bit_iterator_base
137 :
public std::iterator<std::random_access_iterator_tag, bool>
140 unsigned int _M_offset;
142 _Bit_iterator_base(_Bit_type * __x,
unsigned int __y)
143 : _M_p(__x), _M_offset(__y) { }
148 if (_M_offset++ ==
int(_S_word_bit) - 1)
158 if (_M_offset-- == 0)
160 _M_offset = int(_S_word_bit) - 1;
166 _M_incr(ptrdiff_t __i)
168 difference_type __n = __i + _M_offset;
169 _M_p += __n / int(_S_word_bit);
170 __n = __n % int(_S_word_bit);
173 __n += int(_S_word_bit);
176 _M_offset =
static_cast<unsigned int>(__n);
180 operator==(
const _Bit_iterator_base& __i)
const 181 {
return _M_p == __i._M_p && _M_offset == __i._M_offset; }
184 operator<(
const _Bit_iterator_base& __i)
const 186 return _M_p < __i._M_p
187 || (_M_p == __i._M_p && _M_offset < __i._M_offset);
191 operator!=(
const _Bit_iterator_base& __i)
const 192 {
return !(*
this == __i); }
195 operator>(
const _Bit_iterator_base& __i)
const 196 {
return __i < *
this; }
199 operator<=(
const _Bit_iterator_base& __i)
const 200 {
return !(__i < *
this); }
203 operator>=(
const _Bit_iterator_base& __i)
const 204 {
return !(*
this < __i); }
208 operator-(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
210 return (
int(_S_word_bit) * (__x._M_p - __y._M_p)
211 + __x._M_offset - __y._M_offset);
214 struct _Bit_iterator :
public _Bit_iterator_base
216 typedef _Bit_reference reference;
217 typedef _Bit_reference* pointer;
218 typedef _Bit_iterator iterator;
220 _Bit_iterator() : _Bit_iterator_base(0, 0) { }
222 _Bit_iterator(_Bit_type * __x,
unsigned int __y)
223 : _Bit_iterator_base(__x, __y) { }
226 _M_const_cast()
const 231 {
return reference(_M_p, 1UL << _M_offset); }
243 iterator __tmp = *
this;
258 iterator __tmp = *
this;
264 operator+=(difference_type __i)
271 operator-=(difference_type __i)
280 iterator __tmp = *
this;
287 iterator __tmp = *
this;
292 operator[](difference_type __i)
const 293 {
return *(*
this + __i); }
297 operator+(ptrdiff_t __n,
const _Bit_iterator& __x)
298 {
return __x + __n; }
300 struct _Bit_const_iterator :
public _Bit_iterator_base
302 typedef bool reference;
303 typedef bool const_reference;
304 typedef const bool* pointer;
305 typedef _Bit_const_iterator const_iterator;
307 _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
309 _Bit_const_iterator(_Bit_type * __x,
unsigned int __y)
310 : _Bit_iterator_base(__x, __y) { }
312 _Bit_const_iterator(
const _Bit_iterator& __x)
313 : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
316 _M_const_cast()
const 317 {
return _Bit_iterator(_M_p, _M_offset); }
321 {
return _Bit_reference(_M_p, 1UL << _M_offset); }
333 const_iterator __tmp = *
this;
348 const_iterator __tmp = *
this;
354 operator+=(difference_type __i)
361 operator-=(difference_type __i)
370 const_iterator __tmp = *
this;
377 const_iterator __tmp = *
this;
382 operator[](difference_type __i)
const 383 {
return *(*
this + __i); }
386 inline _Bit_const_iterator
387 operator+(ptrdiff_t __n,
const _Bit_const_iterator& __x)
388 {
return __x + __n; }
391 __fill_bvector(_Bit_iterator __first, _Bit_iterator __last,
bool __x)
393 for (; __first != __last; ++__first)
398 fill(_Bit_iterator __first, _Bit_iterator __last,
const bool& __x)
400 if (__first._M_p != __last._M_p)
402 std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
403 __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
404 __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
407 __fill_bvector(__first, __last, __x);
410 template<
typename _Alloc>
414 rebind<_Bit_type>::other _Bit_alloc_type;
417 typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
420 :
public _Bit_alloc_type
422 _Bit_iterator _M_start;
423 _Bit_iterator _M_finish;
424 _Bit_pointer _M_end_of_storage;
427 : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage()
430 _Bvector_impl(
const _Bit_alloc_type& __a)
431 : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
434 #if __cplusplus >= 201103L 435 _Bvector_impl(_Bit_alloc_type&& __a)
436 : _Bit_alloc_type(
std::move(__a)), _M_start(), _M_finish(),
442 _M_end_addr() const _GLIBCXX_NOEXCEPT
444 if (_M_end_of_storage)
451 typedef _Alloc allocator_type;
454 _M_get_Bit_allocator() _GLIBCXX_NOEXCEPT
455 {
return *
static_cast<_Bit_alloc_type*
>(&this->_M_impl); }
457 const _Bit_alloc_type&
458 _M_get_Bit_allocator() const _GLIBCXX_NOEXCEPT
459 {
return *
static_cast<const _Bit_alloc_type*
>(&this->_M_impl); }
462 get_allocator() const _GLIBCXX_NOEXCEPT
463 {
return allocator_type(_M_get_Bit_allocator()); }
468 _Bvector_base(
const allocator_type& __a)
471 #if __cplusplus >= 201103L 472 _Bvector_base(_Bvector_base&& __x) noexcept
473 : _M_impl(
std::move(__x._M_get_Bit_allocator()))
475 this->_M_impl._M_start = __x._M_impl._M_start;
476 this->_M_impl._M_finish = __x._M_impl._M_finish;
477 this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
478 __x._M_impl._M_start = _Bit_iterator();
479 __x._M_impl._M_finish = _Bit_iterator();
480 __x._M_impl._M_end_of_storage =
nullptr;
485 { this->_M_deallocate(); }
488 _Bvector_impl _M_impl;
491 _M_allocate(
size_t __n)
492 {
return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); }
497 if (_M_impl._M_start._M_p)
499 const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
500 _Bit_alloc_traits::deallocate(_M_impl,
501 _M_impl._M_end_of_storage - __n,
503 _M_impl._M_start = _M_impl._M_finish = _Bit_iterator();
504 _M_impl._M_end_of_storage = _Bit_pointer();
510 {
return (__n +
int(_S_word_bit) - 1) / int(_S_word_bit); }
513 _GLIBCXX_END_NAMESPACE_CONTAINER
519 namespace std _GLIBCXX_VISIBILITY(default)
521 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
542 template<
typename _Alloc>
543 class vector<bool, _Alloc> :
protected _Bvector_base<_Alloc>
545 typedef _Bvector_base<_Alloc> _Base;
546 typedef typename _Base::_Bit_pointer _Bit_pointer;
549 #if __cplusplus >= 201103L 550 template<
typename>
friend struct hash;
554 typedef bool value_type;
555 typedef size_t size_type;
556 typedef ptrdiff_t difference_type;
557 typedef _Bit_reference reference;
558 typedef bool const_reference;
559 typedef _Bit_reference* pointer;
560 typedef const bool* const_pointer;
561 typedef _Bit_iterator iterator;
562 typedef _Bit_const_iterator const_iterator;
565 typedef _Alloc allocator_type;
567 allocator_type get_allocator()
const 568 {
return _Base::get_allocator(); }
571 using _Base::_M_allocate;
572 using _Base::_M_deallocate;
573 using _Base::_S_nword;
574 using _Base::_M_get_Bit_allocator;
578 #if __cplusplus >= 201103L 579 noexcept(is_nothrow_default_constructible<allocator_type>::value)
584 vector(
const allocator_type& __a)
587 #if __cplusplus >= 201103L 589 vector(size_type __n,
const allocator_type& __a = allocator_type())
593 vector(size_type __n,
const bool& __value,
594 const allocator_type& __a = allocator_type())
598 std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_addr(),
603 vector(size_type __n,
const bool& __value =
bool(),
604 const allocator_type& __a = allocator_type())
608 std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_addr(),
613 vector(
const vector& __x)
614 : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
616 _M_initialize(__x.
size());
617 _M_copy_aligned(__x.
begin(), __x.
end(), this->_M_impl._M_start);
620 #if __cplusplus >= 201103L 621 vector(vector&& __x) noexcept
622 : _Base(std::move(__x)) { }
624 vector(vector&& __x,
const allocator_type& __a)
625 noexcept(_Bit_alloc_traits::_S_always_equal())
628 if (__x.get_allocator() == __a)
630 this->_M_impl._M_start = __x._M_impl._M_start;
631 this->_M_impl._M_finish = __x._M_impl._M_finish;
632 this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
633 __x._M_impl._M_start = _Bit_iterator();
634 __x._M_impl._M_finish = _Bit_iterator();
635 __x._M_impl._M_end_of_storage =
nullptr;
639 _M_initialize(__x.
size());
645 vector(
const vector& __x,
const allocator_type& __a)
648 _M_initialize(__x.
size());
649 _M_copy_aligned(__x.
begin(), __x.
end(), this->_M_impl._M_start);
653 const allocator_type& __a = allocator_type())
656 _M_initialize_range(__l.begin(), __l.end(),
661 #if __cplusplus >= 201103L 662 template<
typename _InputIterator,
663 typename = std::_RequireInputIter<_InputIterator>>
664 vector(_InputIterator __first, _InputIterator __last,
665 const allocator_type& __a = allocator_type())
667 { _M_initialize_dispatch(__first, __last, __false_type()); }
669 template<
typename _InputIterator>
670 vector(_InputIterator __first, _InputIterator __last,
671 const allocator_type& __a = allocator_type())
674 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
675 _M_initialize_dispatch(__first, __last, _Integral());
679 ~vector() _GLIBCXX_NOEXCEPT { }
682 operator=(
const vector& __x)
686 #if __cplusplus >= 201103L 687 if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
689 if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
691 this->_M_deallocate();
692 std::__alloc_on_copy(_M_get_Bit_allocator(),
693 __x._M_get_Bit_allocator());
694 _M_initialize(__x.
size());
697 std::__alloc_on_copy(_M_get_Bit_allocator(),
698 __x._M_get_Bit_allocator());
701 if (__x.
size() > capacity())
703 this->_M_deallocate();
704 _M_initialize(__x.
size());
706 this->_M_impl._M_finish = _M_copy_aligned(__x.
begin(), __x.
end(),
711 #if __cplusplus >= 201103L 713 operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
715 if (_Bit_alloc_traits::_S_propagate_on_move_assign()
716 || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
718 this->_M_deallocate();
719 this->_M_impl._M_start = __x._M_impl._M_start;
720 this->_M_impl._M_finish = __x._M_impl._M_finish;
721 this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
722 __x._M_impl._M_start = _Bit_iterator();
723 __x._M_impl._M_finish = _Bit_iterator();
724 __x._M_impl._M_end_of_storage =
nullptr;
725 std::__alloc_on_move(_M_get_Bit_allocator(),
726 __x._M_get_Bit_allocator());
730 if (__x.
size() > capacity())
732 this->_M_deallocate();
733 _M_initialize(__x.
size());
735 this->_M_impl._M_finish = _M_copy_aligned(__x.
begin(), __x.
end(),
745 this->assign (__l.begin(), __l.end());
755 assign(size_type __n,
const bool& __x)
756 { _M_fill_assign(__n, __x); }
758 #if __cplusplus >= 201103L 759 template<
typename _InputIterator,
760 typename = std::_RequireInputIter<_InputIterator>>
762 assign(_InputIterator __first, _InputIterator __last)
763 { _M_assign_dispatch(__first, __last, __false_type()); }
765 template<
typename _InputIterator>
767 assign(_InputIterator __first, _InputIterator __last)
769 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
770 _M_assign_dispatch(__first, __last, _Integral());
774 #if __cplusplus >= 201103L 777 { this->assign(__l.begin(), __l.end()); }
781 begin() _GLIBCXX_NOEXCEPT
782 {
return this->_M_impl._M_start; }
785 begin()
const _GLIBCXX_NOEXCEPT
786 {
return this->_M_impl._M_start; }
789 end() _GLIBCXX_NOEXCEPT
790 {
return this->_M_impl._M_finish; }
793 end()
const _GLIBCXX_NOEXCEPT
794 {
return this->_M_impl._M_finish; }
797 rbegin() _GLIBCXX_NOEXCEPT
798 {
return reverse_iterator(
end()); }
800 const_reverse_iterator
801 rbegin()
const _GLIBCXX_NOEXCEPT
802 {
return const_reverse_iterator(
end()); }
805 rend() _GLIBCXX_NOEXCEPT
806 {
return reverse_iterator(
begin()); }
808 const_reverse_iterator
809 rend()
const _GLIBCXX_NOEXCEPT
810 {
return const_reverse_iterator(
begin()); }
812 #if __cplusplus >= 201103L 815 {
return this->_M_impl._M_start; }
818 cend()
const noexcept
819 {
return this->_M_impl._M_finish; }
821 const_reverse_iterator
823 {
return const_reverse_iterator(
end()); }
825 const_reverse_iterator
826 crend()
const noexcept
827 {
return const_reverse_iterator(
begin()); }
831 size()
const _GLIBCXX_NOEXCEPT
832 {
return size_type(
end() -
begin()); }
835 max_size()
const _GLIBCXX_NOEXCEPT
837 const size_type __isize =
838 __gnu_cxx::__numeric_traits<difference_type>::__max
839 - int(_S_word_bit) + 1;
840 const size_type __asize
841 = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
842 return (__asize <= __isize /
int(_S_word_bit)
843 ? __asize *
int(_S_word_bit) : __isize);
847 capacity()
const _GLIBCXX_NOEXCEPT
848 {
return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
852 empty()
const _GLIBCXX_NOEXCEPT
856 operator[](size_type __n)
858 return *iterator(this->_M_impl._M_start._M_p
859 + __n /
int(_S_word_bit), __n %
int(_S_word_bit));
863 operator[](size_type __n)
const 865 return *const_iterator(this->_M_impl._M_start._M_p
866 + __n /
int(_S_word_bit), __n %
int(_S_word_bit));
871 _M_range_check(size_type __n)
const 873 if (__n >= this->size())
874 __throw_out_of_range_fmt(__N(
"vector<bool>::_M_range_check: __n " 875 "(which is %zu) >= this->size() " 883 { _M_range_check(__n);
return (*
this)[__n]; }
886 at(size_type __n)
const 887 { _M_range_check(__n);
return (*
this)[__n]; }
890 reserve(size_type __n)
892 if (__n > max_size())
893 __throw_length_error(__N(
"vector::reserve"));
894 if (capacity() < __n)
908 {
return *(
end() - 1); }
912 {
return *(
end() - 1); }
920 data() _GLIBCXX_NOEXCEPT { }
925 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
926 *this->_M_impl._M_finish++ = __x;
928 _M_insert_aux(
end(), __x);
932 swap(vector& __x) _GLIBCXX_NOEXCEPT
934 std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
935 std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
936 std::swap(this->_M_impl._M_end_of_storage,
937 __x._M_impl._M_end_of_storage);
938 _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
939 __x._M_get_Bit_allocator());
944 swap(reference __x, reference __y) _GLIBCXX_NOEXCEPT
952 #if __cplusplus >= 201103L 953 insert(const_iterator __position,
const bool& __x =
bool())
955 insert(iterator __position,
const bool& __x =
bool())
958 const difference_type __n = __position -
begin();
959 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
960 && __position ==
end())
961 *this->_M_impl._M_finish++ = __x;
963 _M_insert_aux(__position._M_const_cast(), __x);
964 return begin() + __n;
967 #if __cplusplus >= 201103L 968 template<
typename _InputIterator,
969 typename = std::_RequireInputIter<_InputIterator>>
971 insert(const_iterator __position,
972 _InputIterator __first, _InputIterator __last)
974 difference_type __offset = __position -
cbegin();
975 _M_insert_dispatch(__position._M_const_cast(),
976 __first, __last, __false_type());
977 return begin() + __offset;
980 template<
typename _InputIterator>
982 insert(iterator __position,
983 _InputIterator __first, _InputIterator __last)
985 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
986 _M_insert_dispatch(__position, __first, __last, _Integral());
990 #if __cplusplus >= 201103L 992 insert(const_iterator __position, size_type __n,
const bool& __x)
994 difference_type __offset = __position -
cbegin();
995 _M_fill_insert(__position._M_const_cast(), __n, __x);
996 return begin() + __offset;
1000 insert(iterator __position, size_type __n,
const bool& __x)
1001 { _M_fill_insert(__position, __n, __x); }
1004 #if __cplusplus >= 201103L 1007 {
return this->insert(__p, __l.begin(), __l.end()); }
1012 { --this->_M_impl._M_finish; }
1015 #if __cplusplus >= 201103L 1016 erase(const_iterator __position)
1018 erase(iterator __position)
1020 {
return _M_erase(__position._M_const_cast()); }
1023 #if __cplusplus >= 201103L 1024 erase(const_iterator __first, const_iterator __last)
1026 erase(iterator __first, iterator __last)
1028 {
return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
1031 resize(size_type __new_size,
bool __x =
bool())
1033 if (__new_size < size())
1034 _M_erase_at_end(
begin() + difference_type(__new_size));
1036 insert(
end(), __new_size - size(), __x);
1039 #if __cplusplus >= 201103L 1042 { _M_shrink_to_fit(); }
1046 flip() _GLIBCXX_NOEXCEPT
1048 _Bit_type *
const __end = this->_M_impl._M_end_addr();
1049 for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
1054 clear() _GLIBCXX_NOEXCEPT
1055 { _M_erase_at_end(
begin()); }
1057 #if __cplusplus >= 201103L 1058 template<
typename... _Args>
1059 #if __cplusplus > 201402L 1064 emplace_back(_Args&&... __args)
1066 push_back(
bool(__args...));
1067 #if __cplusplus > 201402L 1072 template<
typename... _Args>
1074 emplace(const_iterator __pos, _Args&&... __args)
1075 {
return insert(__pos,
bool(__args...)); }
1081 _M_copy_aligned(const_iterator __first, const_iterator __last,
1084 _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
1085 return std::copy(const_iterator(__last._M_p, 0), __last,
1090 _M_initialize(size_type __n)
1092 _Bit_pointer __q = this->_M_allocate(__n);
1093 this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
1095 this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
1099 _M_reallocate(size_type __n);
1101 #if __cplusplus >= 201103L 1110 template<
typename _Integer>
1112 _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
1114 _M_initialize(static_cast<size_type>(__n));
1115 std::fill(this->_M_impl._M_start._M_p,
1116 this->_M_impl._M_end_addr(), __x ? ~0 : 0);
1119 template<
typename _InputIterator>
1121 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1123 { _M_initialize_range(__first, __last,
1126 template<
typename _InputIterator>
1128 _M_initialize_range(_InputIterator __first, _InputIterator __last,
1131 for (; __first != __last; ++__first)
1132 push_back(*__first);
1135 template<
typename _ForwardIterator>
1137 _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
1142 std::copy(__first, __last, this->_M_impl._M_start);
1147 template<
typename _Integer>
1149 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
1150 { _M_fill_assign(__n, __val); }
1152 template<
class _InputIterator>
1154 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
1159 _M_fill_assign(
size_t __n,
bool __x)
1163 std::fill(this->_M_impl._M_start._M_p,
1164 this->_M_impl._M_end_addr(), __x ? ~0 : 0);
1165 insert(
end(), __n - size(), __x);
1169 _M_erase_at_end(
begin() + __n);
1170 std::fill(this->_M_impl._M_start._M_p,
1171 this->_M_impl._M_end_addr(), __x ? ~0 : 0);
1175 template<
typename _InputIterator>
1177 _M_assign_aux(_InputIterator __first, _InputIterator __last,
1180 iterator __cur =
begin();
1181 for (; __first != __last && __cur !=
end(); ++__cur, ++__first)
1183 if (__first == __last)
1184 _M_erase_at_end(__cur);
1186 insert(
end(), __first, __last);
1189 template<
typename _ForwardIterator>
1191 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1196 _M_erase_at_end(std::copy(__first, __last,
begin()));
1199 _ForwardIterator __mid = __first;
1201 std::copy(__first, __mid,
begin());
1202 insert(
end(), __mid, __last);
1210 template<
typename _Integer>
1212 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
1214 { _M_fill_insert(__pos, __n, __x); }
1216 template<
typename _InputIterator>
1218 _M_insert_dispatch(iterator __pos,
1219 _InputIterator __first, _InputIterator __last,
1221 { _M_insert_range(__pos, __first, __last,
1225 _M_fill_insert(iterator __position, size_type __n,
bool __x);
1227 template<
typename _InputIterator>
1229 _M_insert_range(iterator __pos, _InputIterator __first,
1232 for (; __first != __last; ++__first)
1234 __pos = insert(__pos, *__first);
1239 template<
typename _ForwardIterator>
1241 _M_insert_range(iterator __position, _ForwardIterator __first,
1245 _M_insert_aux(iterator __position,
bool __x);
1248 _M_check_len(size_type __n,
const char* __s)
const 1250 if (max_size() - size() < __n)
1251 __throw_length_error(__N(__s));
1253 const size_type __len = size() +
std::max(size(), __n);
1254 return (__len < size() || __len > max_size()) ? max_size() : __len;
1258 _M_erase_at_end(iterator __pos)
1259 { this->_M_impl._M_finish = __pos; }
1262 _M_erase(iterator __pos);
1265 _M_erase(iterator __first, iterator __last);
1268 _GLIBCXX_END_NAMESPACE_CONTAINER
1271 #if __cplusplus >= 201103L 1275 namespace std _GLIBCXX_VISIBILITY(default)
1277 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1281 template<
typename _Alloc>
1283 :
public __hash_base<size_t, _GLIBCXX_STD_C::vector<bool, _Alloc>>
1286 operator()(
const _GLIBCXX_STD_C::vector<bool, _Alloc>&)
const noexcept;
1289 _GLIBCXX_END_NAMESPACE_VERSION
iterator begin() noexcept
Uniform interface to C++98 and C++11 allocators.
complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
constexpr const _Tp * begin(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to the first element of the initializer_list.
_GLIBCXX17_CONSTEXPR auto crend(const _Container &__cont) -> decltype(std::rend(__cont))
Return a reverse iterator pointing one past the first element of the const container.
size_type size() const noexcept
iterator_traits< _Iter >::iterator_category __iterator_category(const _Iter &)
A standard container which offers fixed time access to individual elements in any order...
complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr const _Tp * end(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to one past the last element of the initializer_list. ...
constexpr auto cbegin(const _Container &__cont) noexcept(noexcept(std::begin(__cont))) -> decltype(std::begin(__cont))
Return an iterator pointing to the first element of the const container.
_GLIBCXX17_CONSTEXPR auto rend(_Container &__cont) -> decltype(__cont.rend())
Return a reverse iterator pointing one past the first element of the container.
ISO C++ entities toplevel namespace is std.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
_GLIBCXX17_CONSTEXPR iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
_GLIBCXX17_CONSTEXPR void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
Forward iterators support a superset of input iterator operations.
_GLIBCXX17_CONSTEXPR auto rbegin(_Container &__cont) -> decltype(__cont.rbegin())
Return a reverse iterator pointing to the last element of the container.
_GLIBCXX14_CONSTEXPR const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Random-access iterators support a superset of bidirectional iterator operations.
Primary class template hash.
constexpr auto cend(const _Container &__cont) noexcept(noexcept(std::end(__cont))) -> decltype(std::end(__cont))
Return an iterator pointing to one past the last element of the const container.
_GLIBCXX17_CONSTEXPR auto crbegin(const _Container &__cont) -> decltype(std::rbegin(__cont))
Return a reverse iterator pointing to the last element of the const container.