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_VERSION
66 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
68 typedef unsigned long _Bit_type;
69 enum { _S_word_bit = int(__CHAR_BIT__ *
sizeof(_Bit_type)) };
76 _Bit_reference(_Bit_type * __x, _Bit_type __y)
77 : _M_p(__x), _M_mask(__y) { }
79 _Bit_reference() _GLIBCXX_NOEXCEPT : _M_p(0), _M_mask(0) { }
81 operator bool() const _GLIBCXX_NOEXCEPT
82 {
return !!(*_M_p & _M_mask); }
85 operator=(
bool __x) _GLIBCXX_NOEXCEPT
95 operator=(
const _Bit_reference& __x) _GLIBCXX_NOEXCEPT
96 {
return *
this = bool(__x); }
99 operator==(
const _Bit_reference& __x)
const 100 {
return bool(*
this) == bool(__x); }
103 operator<(
const _Bit_reference& __x)
const 104 {
return !bool(*
this) && bool(__x); }
107 flip() _GLIBCXX_NOEXCEPT
108 { *_M_p ^= _M_mask; }
111 #if __cplusplus >= 201103L 113 swap(_Bit_reference __x, _Bit_reference __y) noexcept
121 swap(_Bit_reference __x,
bool& __y) noexcept
129 swap(
bool& __x, _Bit_reference __y) noexcept
137 struct _Bit_iterator_base
138 :
public std::iterator<std::random_access_iterator_tag, bool>
141 unsigned int _M_offset;
143 _Bit_iterator_base(_Bit_type * __x,
unsigned int __y)
144 : _M_p(__x), _M_offset(__y) { }
149 if (_M_offset++ ==
int(_S_word_bit) - 1)
159 if (_M_offset-- == 0)
161 _M_offset = int(_S_word_bit) - 1;
167 _M_incr(ptrdiff_t __i)
170 _M_p += __n / int(_S_word_bit);
171 __n = __n % int(_S_word_bit);
174 __n += int(_S_word_bit);
177 _M_offset =
static_cast<unsigned int>(__n);
181 operator==(
const _Bit_iterator_base& __i)
const 182 {
return _M_p == __i._M_p && _M_offset == __i._M_offset; }
185 operator<(
const _Bit_iterator_base& __i)
const 187 return _M_p < __i._M_p
188 || (_M_p == __i._M_p && _M_offset < __i._M_offset);
192 operator!=(
const _Bit_iterator_base& __i)
const 193 {
return !(*
this == __i); }
196 operator>(
const _Bit_iterator_base& __i)
const 197 {
return __i < *
this; }
200 operator<=(
const _Bit_iterator_base& __i)
const 201 {
return !(__i < *
this); }
204 operator>=(
const _Bit_iterator_base& __i)
const 205 {
return !(*
this < __i); }
209 operator-(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
211 return (
int(_S_word_bit) * (__x._M_p - __y._M_p)
212 + __x._M_offset - __y._M_offset);
215 struct _Bit_iterator :
public _Bit_iterator_base
217 typedef _Bit_reference reference;
218 typedef _Bit_reference* pointer;
219 typedef _Bit_iterator iterator;
221 _Bit_iterator() : _Bit_iterator_base(0, 0) { }
223 _Bit_iterator(_Bit_type * __x,
unsigned int __y)
224 : _Bit_iterator_base(__x, __y) { }
227 _M_const_cast()
const 232 {
return reference(_M_p, 1UL << _M_offset); }
244 iterator __tmp = *
this;
259 iterator __tmp = *
this;
265 operator+=(difference_type __i)
272 operator-=(difference_type __i)
281 iterator __tmp = *
this;
288 iterator __tmp = *
this;
293 operator[](difference_type __i)
const 294 {
return *(*
this + __i); }
298 operator+(ptrdiff_t __n,
const _Bit_iterator& __x)
299 {
return __x + __n; }
301 struct _Bit_const_iterator :
public _Bit_iterator_base
303 typedef bool reference;
304 typedef bool const_reference;
305 typedef const bool* pointer;
306 typedef _Bit_const_iterator const_iterator;
308 _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
310 _Bit_const_iterator(_Bit_type * __x,
unsigned int __y)
311 : _Bit_iterator_base(__x, __y) { }
313 _Bit_const_iterator(
const _Bit_iterator& __x)
314 : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
317 _M_const_cast()
const 318 {
return _Bit_iterator(_M_p, _M_offset); }
322 {
return _Bit_reference(_M_p, 1UL << _M_offset); }
334 const_iterator __tmp = *
this;
349 const_iterator __tmp = *
this;
355 operator+=(difference_type __i)
362 operator-=(difference_type __i)
371 const_iterator __tmp = *
this;
378 const_iterator __tmp = *
this;
383 operator[](difference_type __i)
const 384 {
return *(*
this + __i); }
387 inline _Bit_const_iterator
388 operator+(ptrdiff_t __n,
const _Bit_const_iterator& __x)
389 {
return __x + __n; }
392 __fill_bvector(_Bit_type * __v,
393 unsigned int __first,
unsigned int __last,
bool __x)
395 const _Bit_type __fmask = ~0ul << __first;
396 const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last);
397 const _Bit_type __mask = __fmask & __lmask;
406 fill(_Bit_iterator __first, _Bit_iterator __last,
const bool& __x)
408 if (__first._M_p != __last._M_p)
410 _Bit_type* __first_p = __first._M_p;
411 if (__first._M_offset != 0)
412 __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x);
414 __builtin_memset(__first_p, __x ? ~0 : 0,
415 (__last._M_p - __first_p) *
sizeof(_Bit_type));
417 if (__last._M_offset != 0)
418 __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
420 else if (__first._M_offset != __last._M_offset)
421 __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x);
424 template<
typename _Alloc>
428 rebind<_Bit_type>::other _Bit_alloc_type;
431 typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
433 struct _Bvector_impl_data
435 _Bit_iterator _M_start;
436 _Bit_iterator _M_finish;
437 _Bit_pointer _M_end_of_storage;
439 _Bvector_impl_data() _GLIBCXX_NOEXCEPT
440 : _M_start(), _M_finish(), _M_end_of_storage()
443 #if __cplusplus >= 201103L 444 _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
445 : _M_start(__x._M_start), _M_finish(__x._M_finish)
446 , _M_end_of_storage(__x._M_end_of_storage)
450 _M_move_data(_Bvector_impl_data&& __x) noexcept
452 this->_M_start = __x._M_start;
453 this->_M_finish = __x._M_finish;
454 this->_M_end_of_storage = __x._M_end_of_storage;
460 _M_reset() _GLIBCXX_NOEXCEPT
462 _M_start = _M_finish = _Bit_iterator();
463 _M_end_of_storage = _Bit_pointer();
468 :
public _Bit_alloc_type,
public _Bvector_impl_data
472 _GLIBCXX_NOEXCEPT_IF( noexcept(_Bit_alloc_type()) )
476 _Bvector_impl(
const _Bit_alloc_type& __a) _GLIBCXX_NOEXCEPT
477 : _Bit_alloc_type(__a)
480 #if __cplusplus >= 201103L 481 _Bvector_impl(_Bvector_impl&&) =
default;
485 _M_end_addr() const _GLIBCXX_NOEXCEPT
487 if (this->_M_end_of_storage)
494 typedef _Alloc allocator_type;
497 _M_get_Bit_allocator() _GLIBCXX_NOEXCEPT
498 {
return this->_M_impl; }
500 const _Bit_alloc_type&
501 _M_get_Bit_allocator() const _GLIBCXX_NOEXCEPT
502 {
return this->_M_impl; }
505 get_allocator() const _GLIBCXX_NOEXCEPT
506 {
return allocator_type(_M_get_Bit_allocator()); }
508 #if __cplusplus >= 201103L 509 _Bvector_base() =
default;
514 _Bvector_base(
const allocator_type& __a)
517 #if __cplusplus >= 201103L 518 _Bvector_base(_Bvector_base&&) =
default;
522 { this->_M_deallocate(); }
525 _Bvector_impl _M_impl;
528 _M_allocate(
size_t __n)
534 if (_M_impl._M_start._M_p)
536 const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
538 _M_impl._M_end_of_storage - __n,
544 #if __cplusplus >= 201103L 546 _M_move_data(_Bvector_base&& __x) noexcept
547 { _M_impl._M_move_data(std::move(__x._M_impl)); }
552 {
return (__n +
int(_S_word_bit) - 1) / int(_S_word_bit); }
555 _GLIBCXX_END_NAMESPACE_CONTAINER
556 _GLIBCXX_END_NAMESPACE_VERSION
562 namespace std _GLIBCXX_VISIBILITY(default)
564 _GLIBCXX_BEGIN_NAMESPACE_VERSION
565 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
586 template<
typename _Alloc>
587 class vector<bool, _Alloc> :
protected _Bvector_base<_Alloc>
589 typedef _Bvector_base<_Alloc> _Base;
590 typedef typename _Base::_Bit_pointer _Bit_pointer;
593 #if __cplusplus >= 201103L 594 template<
typename>
friend struct hash;
598 typedef bool value_type;
599 typedef size_t size_type;
600 typedef ptrdiff_t difference_type;
601 typedef _Bit_reference reference;
602 typedef bool const_reference;
603 typedef _Bit_reference* pointer;
604 typedef const bool* const_pointer;
605 typedef _Bit_iterator iterator;
606 typedef _Bit_const_iterator const_iterator;
609 typedef _Alloc allocator_type;
612 get_allocator()
const 613 {
return _Base::get_allocator(); }
616 using _Base::_M_allocate;
617 using _Base::_M_deallocate;
618 using _Base::_S_nword;
619 using _Base::_M_get_Bit_allocator;
622 #if __cplusplus >= 201103L 629 vector(
const allocator_type& __a)
632 #if __cplusplus >= 201103L 634 vector(size_type __n,
const allocator_type& __a = allocator_type())
638 vector(size_type __n,
const bool& __value,
639 const allocator_type& __a = allocator_type())
642 vector(size_type __n,
const bool& __value =
bool(),
643 const allocator_type& __a = allocator_type())
648 _M_initialize_value(__value);
652 : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
654 _M_initialize(__x.
size());
655 _M_copy_aligned(__x.
begin(), __x.
end(), this->_M_impl._M_start);
658 #if __cplusplus >= 201103L 662 noexcept(_Bit_alloc_traits::_S_always_equal())
666 this->_M_move_data(std::move(__x));
669 _M_initialize(__x.
size());
678 _M_initialize(__x.
size());
679 _M_copy_aligned(__x.
begin(), __x.
end(), this->_M_impl._M_start);
683 const allocator_type& __a = allocator_type())
686 _M_initialize_range(__l.begin(), __l.end(),
691 #if __cplusplus >= 201103L 692 template<
typename _InputIterator,
693 typename = std::_RequireInputIter<_InputIterator>>
694 vector(_InputIterator __first, _InputIterator __last,
695 const allocator_type& __a = allocator_type())
697 { _M_initialize_dispatch(__first, __last, __false_type()); }
699 template<
typename _InputIterator>
700 vector(_InputIterator __first, _InputIterator __last,
701 const allocator_type& __a = allocator_type())
704 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
705 _M_initialize_dispatch(__first, __last, _Integral());
709 ~vector() _GLIBCXX_NOEXCEPT { }
716 #if __cplusplus >= 201103L 717 if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
719 if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
721 this->_M_deallocate();
722 std::__alloc_on_copy(_M_get_Bit_allocator(),
723 __x._M_get_Bit_allocator());
724 _M_initialize(__x.
size());
727 std::__alloc_on_copy(_M_get_Bit_allocator(),
728 __x._M_get_Bit_allocator());
733 this->_M_deallocate();
734 _M_initialize(__x.
size());
736 this->_M_impl._M_finish = _M_copy_aligned(__x.
begin(), __x.
end(),
741 #if __cplusplus >= 201103L 745 if (_Bit_alloc_traits::_S_propagate_on_move_assign()
746 || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
748 this->_M_deallocate();
749 this->_M_move_data(std::move(__x));
750 std::__alloc_on_move(_M_get_Bit_allocator(),
751 __x._M_get_Bit_allocator());
757 this->_M_deallocate();
758 _M_initialize(__x.
size());
760 this->_M_impl._M_finish = _M_copy_aligned(__x.
begin(), __x.
end(),
770 this->
assign (__l.begin(), __l.end());
780 assign(size_type __n,
const bool& __x)
781 { _M_fill_assign(__n, __x); }
783 #if __cplusplus >= 201103L 784 template<
typename _InputIterator,
785 typename = std::_RequireInputIter<_InputIterator>>
787 assign(_InputIterator __first, _InputIterator __last)
790 template<
typename _InputIterator>
792 assign(_InputIterator __first, _InputIterator __last)
794 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
795 _M_assign_dispatch(__first, __last, _Integral());
799 #if __cplusplus >= 201103L 806 begin() _GLIBCXX_NOEXCEPT
807 {
return this->_M_impl._M_start; }
810 begin()
const _GLIBCXX_NOEXCEPT
811 {
return this->_M_impl._M_start; }
814 end() _GLIBCXX_NOEXCEPT
815 {
return this->_M_impl._M_finish; }
818 end()
const _GLIBCXX_NOEXCEPT
819 {
return this->_M_impl._M_finish; }
822 rbegin() _GLIBCXX_NOEXCEPT
826 rbegin()
const _GLIBCXX_NOEXCEPT
830 rend() _GLIBCXX_NOEXCEPT
834 rend()
const _GLIBCXX_NOEXCEPT
837 #if __cplusplus >= 201103L 840 {
return this->_M_impl._M_start; }
843 cend()
const noexcept
844 {
return this->_M_impl._M_finish; }
851 crend()
const noexcept
856 size()
const _GLIBCXX_NOEXCEPT
857 {
return size_type(
end() -
begin()); }
862 const size_type __isize =
863 __gnu_cxx::__numeric_traits<difference_type>::__max
864 - int(_S_word_bit) + 1;
865 const size_type __asize
866 = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
867 return (__asize <= __isize /
int(_S_word_bit)
868 ? __asize *
int(_S_word_bit) : __isize);
873 {
return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
877 empty()
const _GLIBCXX_NOEXCEPT
883 return *iterator(this->_M_impl._M_start._M_p
884 + __n /
int(_S_word_bit), __n %
int(_S_word_bit));
890 return *const_iterator(this->_M_impl._M_start._M_p
891 + __n /
int(_S_word_bit), __n %
int(_S_word_bit));
898 if (__n >= this->
size())
899 __throw_out_of_range_fmt(__N(
"vector<bool>::_M_range_check: __n " 900 "(which is %zu) >= this->size() " 911 at(size_type __n)
const 918 __throw_length_error(__N(
"vector::reserve"));
933 {
return *(
end() - 1); }
937 {
return *(
end() - 1); }
945 data() _GLIBCXX_NOEXCEPT { }
950 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
951 *this->_M_impl._M_finish++ = __x;
953 _M_insert_aux(
end(), __x);
959 std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
960 std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
961 std::swap(this->_M_impl._M_end_of_storage,
962 __x._M_impl._M_end_of_storage);
963 _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
964 __x._M_get_Bit_allocator());
969 swap(reference __x, reference __y) _GLIBCXX_NOEXCEPT
977 #if __cplusplus >= 201103L 978 insert(const_iterator __position,
const bool& __x =
bool())
980 insert(iterator __position,
const bool& __x =
bool())
983 const difference_type __n = __position -
begin();
984 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
985 && __position ==
end())
986 *this->_M_impl._M_finish++ = __x;
988 _M_insert_aux(__position._M_const_cast(), __x);
989 return begin() + __n;
992 #if __cplusplus >= 201103L 993 template<
typename _InputIterator,
994 typename = std::_RequireInputIter<_InputIterator>>
996 insert(const_iterator __position,
997 _InputIterator __first, _InputIterator __last)
999 difference_type __offset = __position -
cbegin();
1000 _M_insert_dispatch(__position._M_const_cast(),
1001 __first, __last, __false_type());
1002 return begin() + __offset;
1005 template<
typename _InputIterator>
1007 insert(iterator __position,
1008 _InputIterator __first, _InputIterator __last)
1010 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
1011 _M_insert_dispatch(__position, __first, __last, _Integral());
1015 #if __cplusplus >= 201103L 1017 insert(const_iterator __position, size_type __n,
const bool& __x)
1019 difference_type __offset = __position -
cbegin();
1020 _M_fill_insert(__position._M_const_cast(), __n, __x);
1021 return begin() + __offset;
1025 insert(iterator __position, size_type __n,
const bool& __x)
1026 { _M_fill_insert(__position, __n, __x); }
1029 #if __cplusplus >= 201103L 1032 {
return this->
insert(__p, __l.begin(), __l.end()); }
1037 { --this->_M_impl._M_finish; }
1040 #if __cplusplus >= 201103L 1041 erase(const_iterator __position)
1043 erase(iterator __position)
1045 {
return _M_erase(__position._M_const_cast()); }
1048 #if __cplusplus >= 201103L 1049 erase(const_iterator __first, const_iterator __last)
1051 erase(iterator __first, iterator __last)
1053 {
return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
1056 resize(size_type __new_size,
bool __x =
bool())
1058 if (__new_size <
size())
1059 _M_erase_at_end(
begin() + difference_type(__new_size));
1064 #if __cplusplus >= 201103L 1067 { _M_shrink_to_fit(); }
1071 flip() _GLIBCXX_NOEXCEPT
1073 _Bit_type *
const __end = this->_M_impl._M_end_addr();
1074 for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
1079 clear() _GLIBCXX_NOEXCEPT
1080 { _M_erase_at_end(
begin()); }
1082 #if __cplusplus >= 201103L 1083 template<
typename... _Args>
1084 #if __cplusplus > 201402L 1089 emplace_back(_Args&&... __args)
1092 #if __cplusplus > 201402L 1097 template<
typename... _Args>
1099 emplace(const_iterator __pos, _Args&&... __args)
1100 {
return insert(__pos,
bool(__args...)); }
1106 _M_copy_aligned(const_iterator __first, const_iterator __last,
1109 _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
1110 return std::copy(const_iterator(__last._M_p, 0), __last,
1115 _M_initialize(size_type __n)
1119 _Bit_pointer __q = this->_M_allocate(__n);
1120 this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
1125 this->_M_impl._M_end_of_storage = _Bit_pointer();
1126 this->_M_impl._M_start = iterator(0, 0);
1128 this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
1133 _M_initialize_value(
bool __x)
1135 if (_Bit_type* __p = this->_M_impl._M_start._M_p)
1136 __builtin_memset(__p, __x ? ~0 : 0,
1137 (this->_M_impl._M_end_addr() - __p)
1138 *
sizeof(_Bit_type));
1142 _M_reallocate(size_type __n);
1144 #if __cplusplus >= 201103L 1153 template<
typename _Integer>
1155 _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
1157 _M_initialize(static_cast<size_type>(__n));
1158 _M_initialize_value(__x);
1161 template<
typename _InputIterator>
1163 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1165 { _M_initialize_range(__first, __last,
1168 template<
typename _InputIterator>
1170 _M_initialize_range(_InputIterator __first, _InputIterator __last,
1173 for (; __first != __last; ++__first)
1177 template<
typename _ForwardIterator>
1179 _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
1184 std::copy(__first, __last, this->_M_impl._M_start);
1187 #if __cplusplus < 201103L 1190 template<
typename _Integer>
1192 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
1193 { _M_fill_assign(__n, __val); }
1195 template<
class _InputIterator>
1197 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
1203 _M_fill_assign(
size_t __n,
bool __x)
1207 _M_initialize_value(__x);
1212 _M_erase_at_end(
begin() + __n);
1213 _M_initialize_value(__x);
1217 template<
typename _InputIterator>
1219 _M_assign_aux(_InputIterator __first, _InputIterator __last,
1222 iterator __cur =
begin();
1223 for (; __first != __last && __cur !=
end(); ++__cur, ++__first)
1225 if (__first == __last)
1226 _M_erase_at_end(__cur);
1231 template<
typename _ForwardIterator>
1233 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1238 _M_erase_at_end(std::copy(__first, __last,
begin()));
1241 _ForwardIterator __mid = __first;
1243 std::copy(__first, __mid,
begin());
1252 template<
typename _Integer>
1254 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
1256 { _M_fill_insert(__pos, __n, __x); }
1258 template<
typename _InputIterator>
1260 _M_insert_dispatch(iterator __pos,
1261 _InputIterator __first, _InputIterator __last,
1263 { _M_insert_range(__pos, __first, __last,
1267 _M_fill_insert(iterator __position, size_type __n,
bool __x);
1269 template<
typename _InputIterator>
1271 _M_insert_range(iterator __pos, _InputIterator __first,
1274 for (; __first != __last; ++__first)
1276 __pos =
insert(__pos, *__first);
1281 template<
typename _ForwardIterator>
1283 _M_insert_range(iterator __position, _ForwardIterator __first,
1287 _M_insert_aux(iterator __position,
bool __x);
1290 _M_check_len(size_type __n,
const char* __s)
const 1293 __throw_length_error(__N(__s));
1300 _M_erase_at_end(iterator __pos)
1301 { this->_M_impl._M_finish = __pos; }
1304 _M_erase(iterator __pos);
1307 _M_erase(iterator __first, iterator __last);
1310 _GLIBCXX_END_NAMESPACE_CONTAINER
1311 _GLIBCXX_END_NAMESPACE_VERSION
1314 #if __cplusplus >= 201103L 1318 namespace std _GLIBCXX_VISIBILITY(default)
1320 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1324 template<
typename _Alloc>
1326 :
public __hash_base<size_t, _GLIBCXX_STD_C::vector<bool, _Alloc>>
1329 operator()(
const _GLIBCXX_STD_C::vector<bool, _Alloc>&)
const noexcept;
1332 _GLIBCXX_END_NAMESPACE_VERSION
void push_back(const value_type &__x)
Add data to the end of the vector.
void resize(size_type __new_size)
Resizes the vector to the specified number of elements.
Primary class template hash.
void swap(vector &__x) noexcept
Swaps data with another vector.
reference operator[](size_type __n) noexcept
Subscript access to the data contained in the vector.
const_iterator cbegin() const noexcept
reverse_iterator rbegin() noexcept
complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
size_type max_size() const noexcept
void pop_back() noexcept
Removes last element.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
reference front() noexcept
bool empty() const noexcept
iterator erase(const_iterator __position)
Remove element at given position.
void reserve(size_type __n)
Attempt to preallocate enough memory for specified number of elements.
static pointer allocate(_Alloc &__a, size_type __n)
Allocate memory.
void assign(size_type __n, const value_type &__val)
Assigns a given value to a vector.
reference back() noexcept
Forward iterators support a superset of input iterator operations.
reverse_iterator rend() noexcept
ISO C++ entities toplevel namespace is std.
const_reverse_iterator crend() const noexcept
_GLIBCXX17_CONSTEXPR iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
const_reverse_iterator crbegin() const noexcept
size_type size() const noexcept
iterator insert(const_iterator __position, const value_type &__x)
Inserts given value into vector before specified iterator.
A standard container which offers fixed time access to individual elements in any order...
Random-access iterators support a superset of bidirectional iterator operations.
vector & operator=(const vector &__x)
Vector assignment operator.
void _M_range_check(size_type __n) const
Safety check used only from at().
iterator begin() noexcept
vector() noexcept(is_nothrow_default_constructible< _Alloc >::value)
Creates a vector with no elements.
Uniform interface to C++98 and C++11 allocators.
size_type capacity() const noexcept
_GLIBCXX17_CONSTEXPR void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
static void deallocate(_Alloc &__a, pointer __p, size_type __n)
Deallocate memory.
reference at(size_type __n)
Provides access to the data contained in the vector.
constexpr iterator_traits< _Iter >::iterator_category __iterator_category(const _Iter &)
_GLIBCXX14_CONSTEXPR const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
allocator_type get_allocator() const noexcept
Get a copy of the memory allocation object.
ptrdiff_t difference_type
Distance between iterators is represented as this type.
complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
iterator emplace(const_iterator __position, _Args &&... __args)
Inserts an object in vector before specified iterator.
const_iterator cend() const noexcept