56 #ifndef _STL_BVECTOR_H
57 #define _STL_BVECTOR_H 1
59 #if __cplusplus >= 201103L
64 namespace std _GLIBCXX_VISIBILITY(default)
66 _GLIBCXX_BEGIN_NAMESPACE_VERSION
67 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
69 typedef unsigned long _Bit_type;
70 enum { _S_word_bit = int(__CHAR_BIT__ *
sizeof(_Bit_type)) };
77 _Bit_reference(_Bit_type * __x, _Bit_type __y)
78 : _M_p(__x), _M_mask(__y) { }
80 _Bit_reference() _GLIBCXX_NOEXCEPT : _M_p(0), _M_mask(0) { }
82 #if __cplusplus >= 201103L
83 _Bit_reference(
const _Bit_reference&) =
default;
86 operator bool() const _GLIBCXX_NOEXCEPT
87 {
return !!(*_M_p & _M_mask); }
90 operator=(
bool __x) _GLIBCXX_NOEXCEPT
100 operator=(
const _Bit_reference& __x) _GLIBCXX_NOEXCEPT
101 {
return *
this = bool(__x); }
104 operator==(
const _Bit_reference& __x)
const
105 {
return bool(*
this) == bool(__x); }
108 operator<(
const _Bit_reference& __x)
const
109 {
return !bool(*
this) && bool(__x); }
112 flip() _GLIBCXX_NOEXCEPT
113 { *_M_p ^= _M_mask; }
116 #if __cplusplus >= 201103L
118 swap(_Bit_reference __x, _Bit_reference __y) noexcept
126 swap(_Bit_reference __x,
bool& __y) noexcept
134 swap(
bool& __x, _Bit_reference __y) noexcept
142 struct _Bit_iterator_base
143 :
public std::iterator<std::random_access_iterator_tag, bool>
146 unsigned int _M_offset;
148 _Bit_iterator_base(_Bit_type * __x,
unsigned int __y)
149 : _M_p(__x), _M_offset(__y) { }
154 if (_M_offset++ ==
int(_S_word_bit) - 1)
164 if (_M_offset-- == 0)
166 _M_offset = int(_S_word_bit) - 1;
172 _M_incr(ptrdiff_t __i)
175 _M_p += __n / int(_S_word_bit);
176 __n = __n % int(_S_word_bit);
179 __n += int(_S_word_bit);
182 _M_offset =
static_cast<unsigned int>(__n);
186 operator==(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
187 {
return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; }
190 operator<(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
192 return __x._M_p < __y._M_p
193 || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset);
197 operator!=(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
198 {
return !(__x == __y); }
201 operator>(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
202 {
return __y < __x; }
205 operator<=(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
206 {
return !(__y < __x); }
209 operator>=(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
210 {
return !(__x < __y); }
213 operator-(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
215 return (
int(_S_word_bit) * (__x._M_p - __y._M_p)
216 + __x._M_offset - __y._M_offset);
220 struct _Bit_iterator :
public _Bit_iterator_base
222 typedef _Bit_reference reference;
223 #if __cplusplus > 201703L
224 typedef void pointer;
226 typedef _Bit_reference* pointer;
228 typedef _Bit_iterator iterator;
230 _Bit_iterator() : _Bit_iterator_base(0, 0) { }
232 _Bit_iterator(_Bit_type * __x,
unsigned int __y)
233 : _Bit_iterator_base(__x, __y) { }
236 _M_const_cast()
const
241 {
return reference(_M_p, 1UL << _M_offset); }
253 iterator __tmp = *
this;
268 iterator __tmp = *
this;
274 operator+=(difference_type __i)
281 operator-=(difference_type __i)
288 operator[](difference_type __i)
const
289 {
return *(*
this + __i); }
292 operator+(
const iterator& __x, difference_type __n)
294 iterator __tmp = __x;
300 operator+(difference_type __n,
const iterator& __x)
301 {
return __x + __n; }
304 operator-(
const iterator& __x, difference_type __n)
306 iterator __tmp = __x;
312 struct _Bit_const_iterator :
public _Bit_iterator_base
314 typedef bool reference;
315 typedef bool const_reference;
316 #if __cplusplus > 201703L
317 typedef void pointer;
319 typedef const bool* pointer;
321 typedef _Bit_const_iterator const_iterator;
323 _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
325 _Bit_const_iterator(_Bit_type * __x,
unsigned int __y)
326 : _Bit_iterator_base(__x, __y) { }
328 _Bit_const_iterator(
const _Bit_iterator& __x)
329 : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
332 _M_const_cast()
const
333 {
return _Bit_iterator(_M_p, _M_offset); }
337 {
return _Bit_reference(_M_p, 1UL << _M_offset); }
349 const_iterator __tmp = *
this;
364 const_iterator __tmp = *
this;
370 operator+=(difference_type __i)
377 operator-=(difference_type __i)
384 operator[](difference_type __i)
const
385 {
return *(*
this + __i); }
387 friend const_iterator
388 operator+(
const const_iterator& __x, difference_type __n)
390 const_iterator __tmp = __x;
395 friend const_iterator
396 operator-(
const const_iterator& __x, difference_type __n)
398 const_iterator __tmp = __x;
403 friend const_iterator
404 operator+(difference_type __n,
const const_iterator& __x)
405 {
return __x + __n; }
409 __fill_bvector(_Bit_type * __v,
410 unsigned int __first,
unsigned int __last,
bool __x)
412 const _Bit_type __fmask = ~0ul << __first;
413 const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last);
414 const _Bit_type __mask = __fmask & __lmask;
423 fill(_Bit_iterator __first, _Bit_iterator __last,
const bool& __x)
425 if (__first._M_p != __last._M_p)
427 _Bit_type* __first_p = __first._M_p;
428 if (__first._M_offset != 0)
429 __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x);
431 __builtin_memset(__first_p, __x ? ~0 : 0,
432 (__last._M_p - __first_p) *
sizeof(_Bit_type));
434 if (__last._M_offset != 0)
435 __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
437 else if (__first._M_offset != __last._M_offset)
438 __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x);
441 template<
typename _Alloc>
445 rebind<_Bit_type>::other _Bit_alloc_type;
448 typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
450 struct _Bvector_impl_data
452 _Bit_iterator _M_start;
453 _Bit_iterator _M_finish;
454 _Bit_pointer _M_end_of_storage;
456 _Bvector_impl_data() _GLIBCXX_NOEXCEPT
457 : _M_start(), _M_finish(), _M_end_of_storage()
460 #if __cplusplus >= 201103L
461 _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
462 : _M_start(__x._M_start), _M_finish(__x._M_finish)
463 , _M_end_of_storage(__x._M_end_of_storage)
467 _M_move_data(_Bvector_impl_data&& __x) noexcept
469 this->_M_start = __x._M_start;
470 this->_M_finish = __x._M_finish;
471 this->_M_end_of_storage = __x._M_end_of_storage;
477 _M_reset() _GLIBCXX_NOEXCEPT
479 _M_start = _M_finish = _Bit_iterator();
480 _M_end_of_storage = _Bit_pointer();
485 :
public _Bit_alloc_type,
public _Bvector_impl_data
488 _Bvector_impl() _GLIBCXX_NOEXCEPT_IF(
489 is_nothrow_default_constructible<_Bit_alloc_type>::value)
493 _Bvector_impl(
const _Bit_alloc_type& __a) _GLIBCXX_NOEXCEPT
494 : _Bit_alloc_type(__a)
497 #if __cplusplus >= 201103L
498 _Bvector_impl(_Bvector_impl&&) =
default;
502 _M_end_addr() const _GLIBCXX_NOEXCEPT
504 if (this->_M_end_of_storage)
511 typedef _Alloc allocator_type;
514 _M_get_Bit_allocator() _GLIBCXX_NOEXCEPT
515 {
return this->_M_impl; }
517 const _Bit_alloc_type&
518 _M_get_Bit_allocator() const _GLIBCXX_NOEXCEPT
519 {
return this->_M_impl; }
522 get_allocator() const _GLIBCXX_NOEXCEPT
523 {
return allocator_type(_M_get_Bit_allocator()); }
525 #if __cplusplus >= 201103L
526 _Bvector_base() =
default;
531 _Bvector_base(
const allocator_type& __a)
534 #if __cplusplus >= 201103L
535 _Bvector_base(_Bvector_base&&) =
default;
539 { this->_M_deallocate(); }
542 _Bvector_impl _M_impl;
545 _M_allocate(
size_t __n)
551 if (_M_impl._M_start._M_p)
553 const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
555 _M_impl._M_end_of_storage - __n,
561 #if __cplusplus >= 201103L
563 _M_move_data(_Bvector_base&& __x) noexcept
564 { _M_impl._M_move_data(
std::move(__x._M_impl)); }
569 {
return (__n +
int(_S_word_bit) - 1) / int(_S_word_bit); }
572 _GLIBCXX_END_NAMESPACE_CONTAINER
573 _GLIBCXX_END_NAMESPACE_VERSION
579 namespace std _GLIBCXX_VISIBILITY(default)
581 _GLIBCXX_BEGIN_NAMESPACE_VERSION
582 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
603 template<
typename _Alloc>
604 class vector<bool, _Alloc> :
protected _Bvector_base<_Alloc>
606 typedef _Bvector_base<_Alloc> _Base;
607 typedef typename _Base::_Bit_pointer _Bit_pointer;
610 #if __cplusplus >= 201103L
615 typedef bool value_type;
616 typedef size_t size_type;
617 typedef ptrdiff_t difference_type;
618 typedef _Bit_reference reference;
619 typedef bool const_reference;
620 typedef _Bit_reference* pointer;
621 typedef const bool* const_pointer;
622 typedef _Bit_iterator iterator;
623 typedef _Bit_const_iterator const_iterator;
626 typedef _Alloc allocator_type;
629 get_allocator()
const
630 {
return _Base::get_allocator(); }
633 using _Base::_M_allocate;
634 using _Base::_M_deallocate;
635 using _Base::_S_nword;
636 using _Base::_M_get_Bit_allocator;
639 #if __cplusplus >= 201103L
646 vector(
const allocator_type& __a)
649 #if __cplusplus >= 201103L
651 vector(size_type __n,
const allocator_type& __a = allocator_type())
655 vector(size_type __n,
const bool& __value,
656 const allocator_type& __a = allocator_type())
659 vector(size_type __n,
const bool& __value =
bool(),
660 const allocator_type& __a = allocator_type())
665 _M_initialize_value(__value);
669 : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
671 _M_initialize(__x.
size());
672 _M_copy_aligned(__x.
begin(), __x.
end(), this->_M_impl._M_start);
675 #if __cplusplus >= 201103L
679 noexcept(_Bit_alloc_traits::_S_always_equal())
686 _M_initialize(__x.
size());
695 _M_initialize(__x.
size());
696 _M_copy_aligned(__x.
begin(), __x.
end(), this->_M_impl._M_start);
700 const allocator_type& __a = allocator_type())
703 _M_initialize_range(__l.begin(), __l.end(),
708 #if __cplusplus >= 201103L
709 template<
typename _InputIterator,
710 typename = std::_RequireInputIter<_InputIterator>>
711 vector(_InputIterator __first, _InputIterator __last,
712 const allocator_type& __a = allocator_type())
714 { _M_initialize_dispatch(__first, __last, __false_type()); }
716 template<
typename _InputIterator>
717 vector(_InputIterator __first, _InputIterator __last,
718 const allocator_type& __a = allocator_type())
721 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
722 _M_initialize_dispatch(__first, __last, _Integral());
726 ~vector() _GLIBCXX_NOEXCEPT { }
733 #if __cplusplus >= 201103L
734 if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
736 if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
738 this->_M_deallocate();
739 std::__alloc_on_copy(_M_get_Bit_allocator(),
740 __x._M_get_Bit_allocator());
741 _M_initialize(__x.
size());
744 std::__alloc_on_copy(_M_get_Bit_allocator(),
745 __x._M_get_Bit_allocator());
750 this->_M_deallocate();
751 _M_initialize(__x.
size());
753 this->_M_impl._M_finish = _M_copy_aligned(__x.
begin(), __x.
end(),
758 #if __cplusplus >= 201103L
762 if (_Bit_alloc_traits::_S_propagate_on_move_assign()
763 || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
765 this->_M_deallocate();
767 std::__alloc_on_move(_M_get_Bit_allocator(),
768 __x._M_get_Bit_allocator());
774 this->_M_deallocate();
775 _M_initialize(__x.
size());
777 this->_M_impl._M_finish = _M_copy_aligned(__x.
begin(), __x.
end(),
787 this->
assign (__l.begin(), __l.end());
797 assign(size_type __n,
const bool& __x)
798 { _M_fill_assign(__n, __x); }
800 #if __cplusplus >= 201103L
801 template<
typename _InputIterator,
802 typename = std::_RequireInputIter<_InputIterator>>
804 assign(_InputIterator __first, _InputIterator __last)
807 template<
typename _InputIterator>
809 assign(_InputIterator __first, _InputIterator __last)
811 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
812 _M_assign_dispatch(__first, __last, _Integral());
816 #if __cplusplus >= 201103L
823 begin() _GLIBCXX_NOEXCEPT
824 {
return iterator(this->_M_impl._M_start._M_p, 0); }
827 begin()
const _GLIBCXX_NOEXCEPT
828 {
return const_iterator(this->_M_impl._M_start._M_p, 0); }
831 end() _GLIBCXX_NOEXCEPT
832 {
return this->_M_impl._M_finish; }
835 end()
const _GLIBCXX_NOEXCEPT
836 {
return this->_M_impl._M_finish; }
839 rbegin() _GLIBCXX_NOEXCEPT
843 rbegin()
const _GLIBCXX_NOEXCEPT
847 rend() _GLIBCXX_NOEXCEPT
851 rend()
const _GLIBCXX_NOEXCEPT
854 #if __cplusplus >= 201103L
857 {
return const_iterator(this->_M_impl._M_start._M_p, 0); }
860 cend()
const noexcept
861 {
return this->_M_impl._M_finish; }
868 crend()
const noexcept
873 size()
const _GLIBCXX_NOEXCEPT
874 {
return size_type(
end() -
begin()); }
879 const size_type __isize =
880 __gnu_cxx::__numeric_traits<difference_type>::__max
881 - int(_S_word_bit) + 1;
882 const size_type __asize
883 = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
884 return (__asize <= __isize /
int(_S_word_bit)
885 ? __asize *
int(_S_word_bit) : __isize);
890 {
return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
893 _GLIBCXX_NODISCARD
bool
894 empty()
const _GLIBCXX_NOEXCEPT
900 return *iterator(this->_M_impl._M_start._M_p
901 + __n /
int(_S_word_bit), __n %
int(_S_word_bit));
907 return *const_iterator(this->_M_impl._M_start._M_p
908 + __n /
int(_S_word_bit), __n %
int(_S_word_bit));
915 if (__n >= this->
size())
916 __throw_out_of_range_fmt(__N(
"vector<bool>::_M_range_check: __n "
917 "(which is %zu) >= this->size() "
928 at(size_type __n)
const
935 __throw_length_error(__N(
"vector::reserve"));
950 {
return *(
end() - 1); }
954 {
return *(
end() - 1); }
962 data() _GLIBCXX_NOEXCEPT { }
967 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
968 *this->_M_impl._M_finish++ = __x;
970 _M_insert_aux(
end(), __x);
976 std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
977 std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
978 std::swap(this->_M_impl._M_end_of_storage,
979 __x._M_impl._M_end_of_storage);
980 _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
981 __x._M_get_Bit_allocator());
986 swap(reference __x, reference __y) _GLIBCXX_NOEXCEPT
994 #if __cplusplus >= 201103L
995 insert(const_iterator __position,
const bool& __x =
bool())
997 insert(iterator __position,
const bool& __x =
bool())
1000 const difference_type __n = __position -
begin();
1001 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
1002 && __position ==
end())
1003 *this->_M_impl._M_finish++ = __x;
1005 _M_insert_aux(__position._M_const_cast(), __x);
1006 return begin() + __n;
1009 #if __cplusplus >= 201103L
1010 template<
typename _InputIterator,
1011 typename = std::_RequireInputIter<_InputIterator>>
1013 insert(const_iterator __position,
1014 _InputIterator __first, _InputIterator __last)
1016 difference_type __offset = __position -
cbegin();
1017 _M_insert_dispatch(__position._M_const_cast(),
1018 __first, __last, __false_type());
1019 return begin() + __offset;
1022 template<
typename _InputIterator>
1024 insert(iterator __position,
1025 _InputIterator __first, _InputIterator __last)
1027 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
1028 _M_insert_dispatch(__position, __first, __last, _Integral());
1032 #if __cplusplus >= 201103L
1034 insert(const_iterator __position, size_type __n,
const bool& __x)
1036 difference_type __offset = __position -
cbegin();
1037 _M_fill_insert(__position._M_const_cast(), __n, __x);
1038 return begin() + __offset;
1042 insert(iterator __position, size_type __n,
const bool& __x)
1043 { _M_fill_insert(__position, __n, __x); }
1046 #if __cplusplus >= 201103L
1049 {
return this->
insert(__p, __l.begin(), __l.end()); }
1054 { --this->_M_impl._M_finish; }
1057 #if __cplusplus >= 201103L
1058 erase(const_iterator __position)
1060 erase(iterator __position)
1062 {
return _M_erase(__position._M_const_cast()); }
1065 #if __cplusplus >= 201103L
1066 erase(const_iterator __first, const_iterator __last)
1068 erase(iterator __first, iterator __last)
1070 {
return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
1073 resize(size_type __new_size,
bool __x =
bool())
1075 if (__new_size <
size())
1076 _M_erase_at_end(
begin() + difference_type(__new_size));
1081 #if __cplusplus >= 201103L
1084 { _M_shrink_to_fit(); }
1088 flip() _GLIBCXX_NOEXCEPT
1090 _Bit_type *
const __end = this->_M_impl._M_end_addr();
1091 for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
1096 clear() _GLIBCXX_NOEXCEPT
1097 { _M_erase_at_end(
begin()); }
1099 #if __cplusplus >= 201103L
1100 template<
typename... _Args>
1101 #if __cplusplus > 201402L
1106 emplace_back(_Args&&... __args)
1109 #if __cplusplus > 201402L
1114 template<
typename... _Args>
1116 emplace(const_iterator __pos, _Args&&... __args)
1117 {
return insert(__pos,
bool(__args...)); }
1123 _M_copy_aligned(const_iterator __first, const_iterator __last,
1126 _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
1127 return std::copy(const_iterator(__last._M_p, 0), __last,
1132 _M_initialize(size_type __n)
1136 _Bit_pointer __q = this->_M_allocate(__n);
1137 this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
1142 this->_M_impl._M_end_of_storage = _Bit_pointer();
1143 this->_M_impl._M_start = iterator(0, 0);
1145 this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
1150 _M_initialize_value(
bool __x)
1152 if (_Bit_type* __p = this->_M_impl._M_start._M_p)
1153 __builtin_memset(__p, __x ? ~0 : 0,
1154 (this->_M_impl._M_end_addr() - __p)
1155 *
sizeof(_Bit_type));
1159 _M_reallocate(size_type __n);
1161 #if __cplusplus >= 201103L
1170 template<
typename _Integer>
1172 _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
1174 _M_initialize(
static_cast<size_type
>(__n));
1175 _M_initialize_value(__x);
1178 template<
typename _InputIterator>
1180 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1182 { _M_initialize_range(__first, __last,
1185 template<
typename _InputIterator>
1187 _M_initialize_range(_InputIterator __first, _InputIterator __last,
1190 for (; __first != __last; ++__first)
1194 template<
typename _ForwardIterator>
1196 _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
1201 std::copy(__first, __last, this->_M_impl._M_start);
1204 #if __cplusplus < 201103L
1207 template<
typename _Integer>
1209 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
1210 { _M_fill_assign(__n, __val); }
1212 template<
class _InputIterator>
1214 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
1220 _M_fill_assign(
size_t __n,
bool __x)
1224 _M_initialize_value(__x);
1229 _M_erase_at_end(
begin() + __n);
1230 _M_initialize_value(__x);
1234 template<
typename _InputIterator>
1236 _M_assign_aux(_InputIterator __first, _InputIterator __last,
1239 iterator __cur =
begin();
1240 for (; __first != __last && __cur !=
end(); ++__cur, (void)++__first)
1242 if (__first == __last)
1243 _M_erase_at_end(__cur);
1248 template<
typename _ForwardIterator>
1250 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1255 _M_erase_at_end(std::copy(__first, __last,
begin()));
1258 _ForwardIterator __mid = __first;
1260 std::copy(__first, __mid,
begin());
1269 template<
typename _Integer>
1271 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
1273 { _M_fill_insert(__pos, __n, __x); }
1275 template<
typename _InputIterator>
1277 _M_insert_dispatch(iterator __pos,
1278 _InputIterator __first, _InputIterator __last,
1280 { _M_insert_range(__pos, __first, __last,
1284 _M_fill_insert(iterator __position, size_type __n,
bool __x);
1286 template<
typename _InputIterator>
1288 _M_insert_range(iterator __pos, _InputIterator __first,
1291 for (; __first != __last; ++__first)
1293 __pos =
insert(__pos, *__first);
1298 template<
typename _ForwardIterator>
1300 _M_insert_range(iterator __position, _ForwardIterator __first,
1304 _M_insert_aux(iterator __position,
bool __x);
1307 _M_check_len(size_type __n,
const char* __s)
const
1310 __throw_length_error(__N(__s));
1317 _M_erase_at_end(iterator __pos)
1318 { this->_M_impl._M_finish = __pos; }
1321 _M_erase(iterator __pos);
1324 _M_erase(iterator __first, iterator __last);
1327 _GLIBCXX_END_NAMESPACE_CONTAINER
1328 _GLIBCXX_END_NAMESPACE_VERSION
1331 #if __cplusplus >= 201103L
1333 namespace std _GLIBCXX_VISIBILITY(default)
1335 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1339 template<
typename _Alloc>
1341 :
public __hash_base<size_t, _GLIBCXX_STD_C::vector<bool, _Alloc>>
1344 operator()(
const _GLIBCXX_STD_C::vector<bool, _Alloc>&)
const noexcept;
1347 _GLIBCXX_END_NAMESPACE_VERSION