57#define _STL_BVECTOR_H 1
59#if __cplusplus >= 201103L
64namespace std _GLIBCXX_VISIBILITY(default)
66_GLIBCXX_BEGIN_NAMESPACE_VERSION
68 typedef unsigned long _Bit_type;
69 enum { _S_word_bit = int(__CHAR_BIT__ *
sizeof(_Bit_type)) };
71 __attribute__((__nonnull__))
74 __fill_bvector_n(_Bit_type*,
size_t,
bool) _GLIBCXX_NOEXCEPT;
76_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
84 _Bit_reference(_Bit_type * __x, _Bit_type __y)
85 : _M_p(__x), _M_mask(__y) { }
88 _Bit_reference() _GLIBCXX_NOEXCEPT : _M_p(0), _M_mask(0) { }
90#if __cplusplus >= 201103L
91 _Bit_reference(
const _Bit_reference&) =
default;
94 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
95 operator bool() const _GLIBCXX_NOEXCEPT
96 {
return !!(*_M_p & _M_mask); }
100 operator=(
bool __x) _GLIBCXX_NOEXCEPT
111 operator=(
const _Bit_reference& __x) _GLIBCXX_NOEXCEPT
112 {
return *
this = bool(__x); }
114 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
116 operator==(
const _Bit_reference& __x)
const
117 {
return bool(*
this) == bool(__x); }
119 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
121 operator<(
const _Bit_reference& __x)
const
122 {
return !bool(*
this) && bool(__x); }
126 flip() _GLIBCXX_NOEXCEPT
127 { *_M_p ^= _M_mask; }
129#if __cplusplus >= 201103L
132 swap(_Bit_reference __x, _Bit_reference __y)
noexcept
141 swap(_Bit_reference __x,
bool& __y)
noexcept
150 swap(
bool& __x, _Bit_reference __y)
noexcept
160#pragma GCC diagnostic push
161#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
162 struct _Bit_iterator_base
163 :
public std::iterator<std::random_access_iterator_tag, bool>
166 unsigned int _M_offset;
169 _Bit_iterator_base(_Bit_type * __x,
unsigned int __y)
170 : _M_p(__x), _M_offset(__y) { }
176 if (_M_offset++ ==
int(_S_word_bit) - 1)
187 if (_M_offset-- == 0)
189 _M_offset = int(_S_word_bit) - 1;
196 _M_incr(ptrdiff_t __i)
199 _M_p += __n / int(_S_word_bit);
200 __n = __n % int(_S_word_bit);
203 __n += int(_S_word_bit);
206 _M_offset =
static_cast<unsigned int>(__n);
210 friend _GLIBCXX20_CONSTEXPR
bool
211 operator==(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
212 {
return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; }
214#if __cpp_lib_three_way_comparison
216 friend constexpr strong_ordering
217 operator<=>(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
220 if (
const auto __cmp = __x._M_p <=> __y._M_p; __cmp != 0)
222 return __x._M_offset <=> __y._M_offset;
227 operator<(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
229 return __x._M_p < __y._M_p
230 || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset);
235 operator!=(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
236 {
return !(__x == __y); }
240 operator>(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
241 {
return __y < __x; }
245 operator<=(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
246 {
return !(__y < __x); }
250 operator>=(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
251 {
return !(__x < __y); }
254 friend _GLIBCXX20_CONSTEXPR ptrdiff_t
255 operator-(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
257 return (
int(_S_word_bit) * (__x._M_p - __y._M_p)
258 + __x._M_offset - __y._M_offset);
261#pragma GCC diagnostic pop
263 struct _Bit_iterator :
public _Bit_iterator_base
265 typedef _Bit_reference reference;
266#if __cplusplus > 201703L
267 typedef void pointer;
269 typedef _Bit_reference* pointer;
271 typedef _Bit_iterator iterator;
274 _Bit_iterator() : _Bit_iterator_base(0, 0) { }
277 _Bit_iterator(_Bit_type * __x,
unsigned int __y)
278 : _Bit_iterator_base(__x, __y) { }
282 _M_const_cast()
const
285 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
288 {
return reference(_M_p, 1UL << _M_offset); }
302 iterator __tmp = *
this;
319 iterator __tmp = *
this;
340 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
343 {
return *(*
this + __i); }
346 friend _GLIBCXX20_CONSTEXPR iterator
349 iterator __tmp = __x;
355 friend _GLIBCXX20_CONSTEXPR iterator
357 {
return __x + __n; }
360 friend _GLIBCXX20_CONSTEXPR iterator
363 iterator __tmp = __x;
369 struct _Bit_const_iterator :
public _Bit_iterator_base
371 typedef bool reference;
372 typedef bool const_reference;
373#if __cplusplus > 201703L
374 typedef void pointer;
376 typedef const bool* pointer;
378 typedef _Bit_const_iterator const_iterator;
381 _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
384 _Bit_const_iterator(_Bit_type * __x,
unsigned int __y)
385 : _Bit_iterator_base(__x, __y) { }
388 _Bit_const_iterator(
const _Bit_iterator& __x)
389 : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
393 _M_const_cast()
const
394 {
return _Bit_iterator(_M_p, _M_offset); }
396 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
399 {
return _Bit_reference(_M_p, 1UL << _M_offset); }
413 const_iterator __tmp = *
this;
430 const_iterator __tmp = *
this;
451 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
454 {
return *(*
this + __i); }
457 friend _GLIBCXX20_CONSTEXPR const_iterator
460 const_iterator __tmp = __x;
466 friend _GLIBCXX20_CONSTEXPR const_iterator
469 const_iterator __tmp = __x;
475 friend _GLIBCXX20_CONSTEXPR const_iterator
477 {
return __x + __n; }
480 template<
typename _Alloc>
484 rebind<_Bit_type>::other _Bit_alloc_type;
487 typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
489 struct _Bvector_impl_data
491#if !_GLIBCXX_INLINE_VERSION
492 _Bit_iterator _M_start;
499 void operator=(_Bit_iterator __it) { _M_p = __it._M_p; }
502 _Bit_iterator _M_finish;
503 _Bit_pointer _M_end_of_storage;
506 _Bvector_impl_data() _GLIBCXX_NOEXCEPT
507 : _M_start(), _M_finish(), _M_end_of_storage()
510#if __cplusplus >= 201103L
511 _Bvector_impl_data(
const _Bvector_impl_data&) =
default;
514 operator=(
const _Bvector_impl_data&) =
default;
517 _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
518 : _Bvector_impl_data(__x)
523 _M_move_data(_Bvector_impl_data&& __x)
noexcept
532 _M_reset() _GLIBCXX_NOEXCEPT
533 { *
this = _Bvector_impl_data(); }
537 _M_swap_data(_Bvector_impl_data& __x) _GLIBCXX_NOEXCEPT
546 :
public _Bit_alloc_type,
public _Bvector_impl_data
549 _Bvector_impl() _GLIBCXX_NOEXCEPT_IF(
550 is_nothrow_default_constructible<_Bit_alloc_type>::value)
552 requires is_default_constructible_v<_Bit_alloc_type>
558 _Bvector_impl(
const _Bit_alloc_type& __a) _GLIBCXX_NOEXCEPT
559 : _Bit_alloc_type(__a)
562#if __cplusplus >= 201103L
566 _Bvector_impl(_Bvector_impl&& __x) noexcept
571 _Bvector_impl(_Bit_alloc_type&& __a, _Bvector_impl&& __x) noexcept
578 _M_end_addr() const _GLIBCXX_NOEXCEPT
580 if (this->_M_end_of_storage)
587 typedef _Alloc allocator_type;
591 _M_get_Bit_allocator() _GLIBCXX_NOEXCEPT
592 {
return this->_M_impl; }
595 const _Bit_alloc_type&
596 _M_get_Bit_allocator() const _GLIBCXX_NOEXCEPT
597 {
return this->_M_impl; }
601 get_allocator() const _GLIBCXX_NOEXCEPT
602 {
return allocator_type(_M_get_Bit_allocator()); }
604#if __cplusplus >= 201103L
605 _Bvector_base() =
default;
611 _Bvector_base(
const allocator_type& __a)
614#if __cplusplus >= 201103L
615 _Bvector_base(_Bvector_base&&) =
default;
618 _Bvector_base(_Bvector_base&& __x,
const allocator_type& __a) noexcept
619 : _M_impl(_Bit_alloc_type(__a),
std::move(__x._M_impl))
625 { this->_M_deallocate(); }
628 _Bvector_impl _M_impl;
632 _M_allocate(
size_t __n)
635#if __cpp_lib_is_constant_evaluated && __cpp_constexpr_dynamic_alloc
639 for (
size_t __i = 0; __i < __n; ++__i)
650 if (_M_impl._M_start._M_p)
652 const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
654 _M_impl._M_end_of_storage - __n,
660#if __cplusplus >= 201103L
663 _M_move_data(_Bvector_base&& __x)
noexcept
664 { _M_impl._M_move_data(
std::move(__x._M_impl)); }
670 {
return (__n +
int(_S_word_bit) - 1) / int(_S_word_bit); }
694 template<
typename _Alloc>
695 class vector<bool, _Alloc> :
protected _Bvector_base<_Alloc>
701#if __cplusplus >= 201103L
706 typedef bool value_type;
707 typedef size_t size_type;
708 typedef ptrdiff_t difference_type;
709 typedef _Bit_reference reference;
710 typedef bool const_reference;
711 typedef _Bit_reference* pointer;
712 typedef const bool* const_pointer;
713 typedef _Bit_iterator iterator;
714 typedef _Bit_const_iterator const_iterator;
717 typedef _Alloc allocator_type;
722 {
return _Base::get_allocator(); }
725 using _Base::_M_allocate;
726 using _Base::_M_deallocate;
727 using _Base::_S_nword;
728 using _Base::_M_get_Bit_allocator;
731#if __cplusplus >= 201103L
739 vector(
const allocator_type& __a)
742#if __cplusplus >= 201103L
745 vector(size_type __n,
const allocator_type& __a = allocator_type())
750 vector(size_type __n,
const bool& __value,
751 const allocator_type& __a = allocator_type())
754 vector(size_type __n,
const bool& __value =
bool(),
755 const allocator_type& __a = allocator_type())
760 _M_initialize_value(__value);
765 : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
767 _M_initialize(__x.
size());
771#if __cplusplus >= 201103L
788 _M_initialize(__x.
size());
797 noexcept(_Bit_alloc_traits::_S_always_equal())
806 _M_initialize(__x.
size());
812 const allocator_type& __a = allocator_type())
815 _M_initialize_range(
__l.begin(),
__l.end(),
820#if __cplusplus >= 201103L
825 const allocator_type& __a = allocator_type())
828 _M_initialize_range(__first, __last,
832 template<
typename _InputIterator>
834 const allocator_type& __a = allocator_type())
838 typedef typename std::__is_integer<_InputIterator>::__type
_Integral;
839 _M_initialize_dispatch(__first, __last,
_Integral());
852#if __cplusplus >= 201103L
853 if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
855 if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
857 this->_M_deallocate();
859 __x._M_get_Bit_allocator());
860 _M_initialize(__x.
size());
864 __x._M_get_Bit_allocator());
869 this->_M_deallocate();
870 _M_initialize(__x.
size());
872 this->_M_impl._M_finish = _M_copy_aligned(__x.
begin(), __x.
end(),
877#if __cplusplus >= 201103L
882 if (_Bit_alloc_traits::_S_propagate_on_move_assign()
883 || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
885 this->_M_deallocate();
888 __x._M_get_Bit_allocator());
894 this->_M_deallocate();
895 _M_initialize(__x.
size());
897 this->_M_impl._M_finish = _M_copy_aligned(__x.
begin(), __x.
end(),
919 assign(size_type __n,
const bool& __x)
920 { _M_fill_assign(__n, __x); }
922#if __cplusplus >= 201103L
930 template<
typename _InputIterator>
935 typedef typename std::__is_integer<_InputIterator>::__type
_Integral;
936 _M_assign_dispatch(__first, __last,
_Integral());
940#if __cplusplus >= 201103L
950 {
return iterator(this->_M_impl._M_start._M_p, 0); }
955 {
return const_iterator(this->_M_impl._M_start._M_p, 0); }
960 {
return this->_M_impl._M_finish; }
965 {
return this->_M_impl._M_finish; }
987#if __cplusplus >= 201103L
991 {
return const_iterator(this->_M_impl._M_start._M_p, 0); }
995 cend()
const noexcept
996 {
return this->_M_impl._M_finish; }
1005 crend()
const noexcept
1012 {
return size_type(
end() -
begin()); }
1019 __gnu_cxx::__numeric_traits<difference_type>::__max
1020 - int(_S_word_bit) + 1;
1022 = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
1030 {
return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
1041 {
return begin()[__n]; }
1046 {
return begin()[__n]; }
1053 if (__n >= this->
size())
1054 __throw_out_of_range_fmt(__N(
"vector<bool>::_M_range_check: __n "
1055 "(which is %zu) >= this->size() "
1066 return (*
this)[__n];
1071 at(size_type __n)
const
1074 return (*
this)[__n];
1082 __throw_length_error(__N(
"vector::reserve"));
1090 {
return *
begin(); }
1095 {
return *
begin(); }
1100 {
return *(
end() - 1); }
1105 {
return *(
end() - 1); }
1111 if (this->_M_impl._M_finish._M_p !=
this->_M_impl._M_end_addr())
1112 *this->_M_impl._M_finish++ = __x;
1114 _M_insert_aux(
end(), __x);
1121#if __cplusplus >= 201103L
1122 __glibcxx_assert(_Bit_alloc_traits::propagate_on_container_swap::value
1123 || _M_get_Bit_allocator() == __x._M_get_Bit_allocator());
1125 this->_M_impl._M_swap_data(__x._M_impl);
1126 _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
1127 __x._M_get_Bit_allocator());
1142#if __cplusplus >= 201103L
1149 if (this->_M_impl._M_finish._M_p !=
this->_M_impl._M_end_addr()
1151 *this->_M_impl._M_finish++ = __x;
1153 _M_insert_aux(
__position._M_const_cast(), __x);
1154 return begin() + __n;
1157#if _GLIBCXX_USE_DEPRECATED
1158 _GLIBCXX_DEPRECATED_SUGGEST(
"insert(position, false)")
1161 {
return this->
insert(__position._M_const_cast(),
false); }
1164#if __cplusplus >= 201103L
1176 return begin() + __offset;
1179 template<
typename _InputIterator>
1185 typedef typename std::__is_integer<_InputIterator>::__type
_Integral;
1190#if __cplusplus >= 201103L
1196 _M_fill_insert(
__position._M_const_cast(), __n, __x);
1197 return begin() + __offset;
1205#if __cplusplus >= 201103L
1215 { --this->_M_impl._M_finish; }
1219#if __cplusplus >= 201103L
1224 {
return _M_erase(
__position._M_const_cast()); }
1228#if __cplusplus >= 201103L
1229 erase(const_iterator __first, const_iterator __last)
1231 erase(iterator __first, iterator __last)
1233 {
return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
1245#if __cplusplus >= 201103L
1249 { _M_shrink_to_fit(); }
1256 _Bit_type *
const __end = this->_M_impl._M_end_addr();
1257 for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
1264 { _M_erase_at_end(
begin()); }
1266#if __cplusplus >= 201103L
1267 template<
typename...
_Args>
1268#if __cplusplus > 201402L
1277#if __cplusplus > 201402L
1282 template<
typename...
_Args>
1293 _M_copy_aligned(const_iterator __first, const_iterator __last,
1296 _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
1297 return std::copy(const_iterator(__last._M_p, 0), __last,
1303 _M_initialize(size_type __n)
1308 this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
1310 this->_M_impl._M_start =
__start;
1311 this->_M_impl._M_finish =
__start + difference_type(__n);
1319 if (_Bit_type* __p = this->_M_impl._M_start._M_p)
1320 __fill_bvector_n(__p, this->_M_impl._M_end_addr() - __p, __x);
1325 _M_reallocate(size_type __n);
1327#if __cplusplus >= 201103L
1333#if __cplusplus < 201103L
1336 template<
typename _Integer>
1340 _M_initialize(
static_cast<size_type
>(__n));
1341 _M_initialize_value(__x);
1344 template<
typename _InputIterator>
1348 { _M_initialize_range(__first, __last,
1352 template<
typename _InputIterator>
1358 for (; __first != __last; ++__first)
1362 template<
typename _ForwardIterator>
1370 std::copy(__first, __last,
begin());
1373#if __cplusplus < 201103L
1376 template<
typename _Integer>
1379 { _M_fill_assign(__n, __val); }
1381 template<
class _InputIterator>
1390 _M_fill_assign(
size_t __n,
bool __x)
1394 _M_initialize_value(__x);
1399 _M_erase_at_end(
begin() + __n);
1400 _M_initialize_value(__x);
1404 template<
typename _InputIterator>
1413 if (__first == __last)
1414 _M_erase_at_end(
__cur);
1419 template<
typename _ForwardIterator>
1427 _M_erase_at_end(std::copy(__first, __last,
begin()));
1437#if __cplusplus < 201103L
1440 template<
typename _Integer>
1444 { _M_fill_insert(
__pos, __n, __x); }
1446 template<
typename _InputIterator>
1448 _M_insert_dispatch(iterator
__pos,
1451 { _M_insert_range(
__pos, __first, __last,
1457 _M_fill_insert(iterator
__position, size_type __n,
bool __x);
1459 template<
typename _InputIterator>
1465 for (; __first != __last; ++__first)
1472 template<
typename _ForwardIterator>
1480 _M_insert_aux(iterator
__position,
bool __x);
1484 _M_check_len(size_type __n,
const char*
__s)
const
1487 __throw_length_error(__N(
__s));
1495 _M_erase_at_end(iterator
__pos)
1496 { this->_M_impl._M_finish =
__pos; }
1500 _M_erase(iterator
__pos);
1504 _M_erase(iterator __first, iterator __last);
1512#if __cplusplus >= 201103L
1513 void data() =
delete;
1519_GLIBCXX_END_NAMESPACE_CONTAINER
1524 __fill_bvector(_Bit_type*
__v,
unsigned int __first,
unsigned int __last,
1527 const _Bit_type
__fmask = ~0
ul << __first;
1528 const _Bit_type
__lmask = ~0
ul >> (_S_word_bit - __last);
1538 __attribute__((__nonnull__))
1539 _GLIBCXX20_CONSTEXPR
1541 __fill_bvector_n(_Bit_type* __p,
size_t __n,
bool __x) _GLIBCXX_NOEXCEPT
1543#if __cpp_lib_is_constant_evaluated
1546 for (
size_t __i = 0; __i < __n; ++__i)
1547 __p[__i] = __x ? ~0ul : 0ul;
1551 __builtin_memset(__p, __x ? ~0 : 0, __n * sizeof(_Bit_type));
1555 _GLIBCXX20_CONSTEXPR
1557 __fill_a1(_GLIBCXX_STD_C::_Bit_iterator __first,
1558 _GLIBCXX_STD_C::_Bit_iterator __last,
const bool& __x)
1560 if (__first._M_p != __last._M_p)
1562 _Bit_type* __first_p = __first._M_p;
1563 if (__first._M_offset != 0)
1564 __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x);
1566 __fill_bvector_n(__first_p, __last._M_p - __first_p, __x);
1568 if (__last._M_offset != 0)
1569 __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
1571 else if (__first._M_offset != __last._M_offset)
1572 __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x);
1575#if __cplusplus >= 201103L
1578 template<
typename _Alloc>
1580 :
public __hash_base<size_t, _GLIBCXX_STD_C::vector<bool, _Alloc>>
1583 operator()(
const _GLIBCXX_STD_C::vector<bool, _Alloc>&)
const noexcept;
1587_GLIBCXX_END_NAMESPACE_VERSION
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
constexpr _Tp * to_address(_Tp *__ptr) noexcept
Obtain address referenced by a pointer to an object.
constexpr bool is_constant_evaluated() noexcept
Returns true only when called during constant evaluation.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
constexpr const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
constexpr iterator_traits< _Iter >::iterator_category __iterator_category(const _Iter &)
ISO C++ entities toplevel namespace is std.
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
Primary class template hash.
typename __detected_or_t< is_empty< _Alloc >, __equal, _Alloc >::type is_always_equal
Whether all instances of the allocator type compare equal.
Forward iterators support a superset of input iterator operations.
Random-access iterators support a superset of bidirectional iterator operations.
ptrdiff_t difference_type
Distance between iterators is represented as this type.
A standard container which offers fixed time access to individual elements in any order.
constexpr iterator insert(const_iterator __position, const value_type &__x)
Inserts given value into vector before specified iterator.
constexpr void push_back(const value_type &__x)
Add data to the end of the vector.
constexpr reverse_iterator rbegin() noexcept
constexpr iterator end() noexcept
vector()=default
Creates a vector with no elements.
constexpr iterator emplace(const_iterator __position, _Args &&... __args)
Inserts an object in vector before specified iterator.
constexpr iterator begin() noexcept
constexpr size_type capacity() const noexcept
constexpr ~vector() noexcept
constexpr void assign(size_type __n, const value_type &__val)
Assigns a given value to a vector.
constexpr void swap(vector &__x) noexcept
Swaps data with another vector.
constexpr _Tp * data() noexcept
constexpr vector & operator=(const vector &__x)
Vector assignment operator.
constexpr void pop_back() noexcept
Removes last element.
constexpr void reserve(size_type __n)
Attempt to preallocate enough memory for specified number of elements.
constexpr reference at(size_type __n)
Provides access to the data contained in the vector.
constexpr void resize(size_type __new_size)
Resizes the vector to the specified number of elements.
constexpr void _M_range_check(size_type __n) const
Safety check used only from at().
constexpr reference front() noexcept
constexpr iterator erase(const_iterator __position)
Remove element at given position.
constexpr bool empty() const noexcept
constexpr reverse_iterator rend() noexcept
constexpr const_reverse_iterator crbegin() const noexcept
constexpr const_iterator cbegin() const noexcept
constexpr void clear() noexcept
constexpr allocator_type get_allocator() const noexcept
Get a copy of the memory allocation object.
constexpr size_type size() const noexcept
constexpr reference back() noexcept
constexpr const_reverse_iterator crend() const noexcept
constexpr const_iterator cend() const noexcept
constexpr reference operator[](size_type __n) noexcept
Subscript access to the data contained in the vector.
constexpr void shrink_to_fit()
constexpr size_type max_size() const noexcept
Uniform interface to C++98 and C++11 allocators.
static constexpr pointer allocate(_Alloc &__a, size_type __n)
Allocate memory.
static constexpr void deallocate(_Alloc &__a, pointer __p, size_type __n)
Deallocate memory.