987 using _Base::get_allocator;
995 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
998 {
return iterator(this->_M_impl._M_start); }
1005 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1008 {
return const_iterator(this->_M_impl._M_start); }
1015 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1018 {
return iterator(this->_M_impl._M_finish); }
1025 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1028 {
return const_iterator(this->_M_impl._M_finish); }
1035 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1045 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1046 const_reverse_iterator
1055 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1065 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1066 const_reverse_iterator
1070#if __cplusplus >= 201103L
1076 [[__nodiscard__]] _GLIBCXX20_CONSTEXPR
1079 {
return const_iterator(this->_M_impl._M_start); }
1086 [[__nodiscard__]] _GLIBCXX20_CONSTEXPR
1089 {
return const_iterator(this->_M_impl._M_finish); }
1096 [[__nodiscard__]] _GLIBCXX20_CONSTEXPR
1097 const_reverse_iterator
1106 [[__nodiscard__]] _GLIBCXX20_CONSTEXPR
1107 const_reverse_iterator
1114 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1118 ptrdiff_t __dif = this->_M_impl._M_finish - this->_M_impl._M_start;
1120 __builtin_unreachable ();
1121 return size_type(__dif);
1125 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1128 {
return _S_max_size(_M_get_Tp_allocator()); }
1130#if __cplusplus >= 201103L
1140 _GLIBCXX20_CONSTEXPR
1144 if (__new_size >
size())
1145 _M_default_append(__new_size -
size());
1146 else if (__new_size <
size())
1147 _M_erase_at_end(this->_M_impl._M_start + __new_size);
1161 _GLIBCXX20_CONSTEXPR
1163 resize(size_type __new_size,
const value_type& __x)
1165 if (__new_size >
size())
1166 _M_fill_insert(
end(), __new_size -
size(), __x);
1167 else if (__new_size <
size())
1168 _M_erase_at_end(this->_M_impl._M_start + __new_size);
1182 _GLIBCXX20_CONSTEXPR
1184 resize(size_type __new_size, value_type __x = value_type())
1186 if (__new_size >
size())
1187 _M_fill_insert(
end(), __new_size -
size(), __x);
1188 else if (__new_size <
size())
1189 _M_erase_at_end(this->_M_impl._M_start + __new_size);
1193#if __cplusplus >= 201103L
1195 _GLIBCXX20_CONSTEXPR
1198 { _M_shrink_to_fit(); }
1205 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1209 ptrdiff_t __dif = this->_M_impl._M_end_of_storage
1210 - this->_M_impl._M_start;
1212 __builtin_unreachable ();
1213 return size_type(__dif);
1220 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1242 _GLIBCXX20_CONSTEXPR
1258 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1262 __glibcxx_requires_subscript(__n);
1263 return *(this->_M_impl._M_start + __n);
1277 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1281 __glibcxx_requires_subscript(__n);
1282 return *(this->_M_impl._M_start + __n);
1287 _GLIBCXX20_CONSTEXPR
1291 if (__n >= this->
size())
1292 __throw_out_of_range_fmt(__N(
"vector::_M_range_check: __n "
1293 "(which is %zu) >= this->size() "
1310 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1315 return (*
this)[__n];
1329 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1334 return (*
this)[__n];
1341 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1345 __glibcxx_requires_nonempty();
1353 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1357 __glibcxx_requires_nonempty();
1365 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1369 __glibcxx_requires_nonempty();
1370 return *(
end() - 1);
1377 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1381 __glibcxx_requires_nonempty();
1382 return *(
end() - 1);
1392 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1395 {
return _M_data_ptr(this->_M_impl._M_start); }
1397 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1399 data() const _GLIBCXX_NOEXCEPT
1400 {
return _M_data_ptr(this->_M_impl._M_start); }
1413 _GLIBCXX20_CONSTEXPR
1417 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
1419 _GLIBCXX_ASAN_ANNOTATE_GROW(1);
1420 _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
1422 ++this->_M_impl._M_finish;
1423 _GLIBCXX_ASAN_ANNOTATE_GREW(1);
1426 _M_realloc_append(__x);
1429#if __cplusplus >= 201103L
1430 _GLIBCXX20_CONSTEXPR
1435 template<
typename... _Args>
1436#if __cplusplus > 201402L
1437 _GLIBCXX20_CONSTEXPR
1442 emplace_back(_Args&&... __args);
1454 _GLIBCXX20_CONSTEXPR
1458 __glibcxx_requires_nonempty();
1459 --this->_M_impl._M_finish;
1460 _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
1461 _GLIBCXX_ASAN_ANNOTATE_SHRINK(1);
1464#if __cplusplus >= 201103L
1477 template<
typename... _Args>
1478 _GLIBCXX20_CONSTEXPR
1480 emplace(const_iterator __position, _Args&&... __args)
1481 {
return _M_emplace_aux(__position, std::forward<_Args>(__args)...); }
1494 _GLIBCXX20_CONSTEXPR
1496 insert(const_iterator __position,
const value_type& __x);
1513#if __cplusplus >= 201103L
1525 _GLIBCXX20_CONSTEXPR
1527 insert(const_iterator __position, value_type&& __x)
1528 {
return _M_insert_rval(__position,
std::move(__x)); }
1543 _GLIBCXX20_CONSTEXPR
1547 auto __offset = __position -
cbegin();
1548 _M_range_insert(
begin() + __offset, __l.begin(), __l.end(),
1550 return begin() + __offset;
1554#if __cplusplus >= 201103L
1569 _GLIBCXX20_CONSTEXPR
1571 insert(const_iterator __position, size_type __n,
const value_type& __x)
1573 difference_type __offset = __position -
cbegin();
1574 _M_fill_insert(
begin() + __offset, __n, __x);
1575 return begin() + __offset;
1592 insert(
iterator __position, size_type __n,
const value_type& __x)
1593 { _M_fill_insert(__position, __n, __x); }
1596#if __cplusplus >= 201103L
1612 template<
typename _InputIterator,
1613 typename = std::_RequireInputIter<_InputIterator>>
1614 _GLIBCXX20_CONSTEXPR
1616 insert(const_iterator __position, _InputIterator __first,
1617 _InputIterator __last)
1619 difference_type __offset = __position -
cbegin();
1620 _M_range_insert(
begin() + __offset, __first, __last,
1622 return begin() + __offset;
1639 template<
typename _InputIterator>
1642 _InputIterator __last)
1645 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
1646 _M_insert_dispatch(__position, __first, __last, _Integral());
1650#if __glibcxx_ranges_to_container
1655 template<__detail::__container_compatible_range<_Tp> _Rg>
1657 insert_range(const_iterator __pos, _Rg&& __rg);
1663 template<__detail::__container_compatible_range<_Tp> _Rg>
1665 append_range(_Rg&& __rg)
1667 if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
1669 const auto __n = size_type(ranges::distance(__rg));
1671 _GLIBCXX_ASAN_ANNOTATE_GROW(__n);
1672 _Base::_M_append_range(__rg);
1673 _GLIBCXX_ASAN_ANNOTATE_GREW(__n);
1677 auto __first = ranges::begin(__rg);
1678 const auto __last = ranges::end(__rg);
1679 for (; __first != __last; ++__first)
1680 emplace_back(*__first);
1700 _GLIBCXX20_CONSTEXPR
1702#if __cplusplus >= 201103L
1704 {
return _M_erase(
begin() + (__position -
cbegin())); }
1707 {
return _M_erase(__position); }
1728 _GLIBCXX20_CONSTEXPR
1730#if __cplusplus >= 201103L
1731 erase(const_iterator __first, const_iterator __last)
1733 const auto __beg =
begin();
1734 const auto __cbeg =
cbegin();
1735 return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
1739 {
return _M_erase(__first, __last); }
1753 _GLIBCXX20_CONSTEXPR
1757#if __cplusplus >= 201103L
1758 __glibcxx_assert(_Alloc_traits::propagate_on_container_swap::value
1759 || _M_get_Tp_allocator() == __x._M_get_Tp_allocator());
1761 this->_M_impl._M_swap_data(__x._M_impl);
1762 _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
1763 __x._M_get_Tp_allocator());
1772 _GLIBCXX20_CONSTEXPR
1775 { _M_erase_at_end(this->_M_impl._M_start); }
1785 _GLIBCXX20_CONSTEXPR
1786 _Guard_alloc(pointer __s, size_type __l, _Base& __vect)
1787 : _M_storage(__s), _M_len(__l), _M_vect(__vect)
1790 _GLIBCXX20_CONSTEXPR
1794 _M_vect._M_deallocate(_M_storage, _M_len);
1797 _GLIBCXX20_CONSTEXPR
1801 pointer __res = _M_storage;
1802 _M_storage = pointer();
1807 _Guard_alloc(
const _Guard_alloc&);
1815 template<
typename _ForwardIterator>
1816 _GLIBCXX20_CONSTEXPR
1819 _ForwardIterator __first, _ForwardIterator __last)
1821 _Guard_alloc __guard(this->_M_allocate(__n), __n, *
this);
1822 std::__uninitialized_copy_a
1823 (__first, __last, __guard._M_storage, _M_get_Tp_allocator());
1824 return __guard._M_release();
1832#if __cplusplus < 201103L
1835 template<
typename _Integer>
1837 _M_initialize_dispatch(_Integer __int_n, _Integer __value, __true_type)
1839 const size_type __n =
static_cast<size_type
>(__int_n);
1841 _M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator()));
1842 this->_M_impl._M_start = __start;
1843 this->_M_impl._M_end_of_storage = __start + __n;
1844 _M_fill_initialize(__n, __value);
1848 template<
typename _InputIterator>
1850 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1853 _M_range_initialize(__first, __last,
1859 template<
typename _InputIterator>
1860 _GLIBCXX20_CONSTEXPR
1862 _M_range_initialize(_InputIterator __first, _InputIterator __last,
1866 for (; __first != __last; ++__first)
1867#
if __cplusplus >= 201103L
1868 emplace_back(*__first);
1874 __throw_exception_again;
1879 template<
typename _ForwardIterator>
1880 _GLIBCXX20_CONSTEXPR
1882 _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
1887 this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator()));
1888 _Guard_alloc __guard(__start, __n, *
this);
1889 this->_M_impl._M_finish = std::__uninitialized_copy_a
1890 (__first, __last, __start, _M_get_Tp_allocator());
1891 this->_M_impl._M_start = __start;
1892 (void) __guard._M_release();
1893 this->_M_impl._M_end_of_storage = __start + __n;
1898 _GLIBCXX20_CONSTEXPR
1900 _M_fill_initialize(size_type __n,
const value_type& __value)
1902 this->_M_impl._M_finish =
1903 std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
1904 _M_get_Tp_allocator());
1907#if __cplusplus >= 201103L
1909 _GLIBCXX20_CONSTEXPR
1911 _M_default_initialize(size_type __n)
1913 this->_M_impl._M_finish =
1914 std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
1915 _M_get_Tp_allocator());
1926 template<
typename _Integer>
1927 _GLIBCXX20_CONSTEXPR
1929 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
1930 { _M_fill_assign(__n, __val); }
1933 template<
typename _InputIterator>
1934 _GLIBCXX20_CONSTEXPR
1936 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
1941 template<
typename _InputIterator>
1942 _GLIBCXX20_CONSTEXPR
1944 _M_assign_aux(_InputIterator __first, _InputIterator __last,
1948 template<
typename _ForwardIterator>
1949 _GLIBCXX20_CONSTEXPR
1951 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1956 _GLIBCXX20_CONSTEXPR
1958 _M_fill_assign(size_type __n,
const value_type& __val);
1966 template<
typename _Integer>
1967 _GLIBCXX20_CONSTEXPR
1969 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
1971 { _M_fill_insert(__pos, __n, __val); }
1974 template<
typename _InputIterator>
1975 _GLIBCXX20_CONSTEXPR
1977 _M_insert_dispatch(iterator __pos, _InputIterator __first,
1978 _InputIterator __last, __false_type)
1980 _M_range_insert(__pos, __first, __last,
1985 template<
typename _InputIterator>
1986 _GLIBCXX20_CONSTEXPR
1988 _M_range_insert(iterator __pos, _InputIterator __first,
1992 template<
typename _ForwardIterator>
1993 _GLIBCXX20_CONSTEXPR
1995 _M_range_insert(iterator __pos, _ForwardIterator __first,
2000 _GLIBCXX20_CONSTEXPR
2002 _M_fill_insert(iterator __pos, size_type __n,
const value_type& __x);
2004#if __cplusplus >= 201103L
2006 _GLIBCXX20_CONSTEXPR
2008 _M_default_append(size_type __n);
2010 _GLIBCXX20_CONSTEXPR
2015#if __cplusplus < 201103L
2018 _M_insert_aux(iterator __position,
const value_type& __x);
2021 _M_realloc_insert(iterator __position,
const value_type& __x);
2024 _M_realloc_append(
const value_type& __x);
2028 struct _Temporary_value
2030 template<
typename... _Args>
2031 _GLIBCXX20_CONSTEXPR
explicit
2032 _Temporary_value(
vector* __vec, _Args&&... __args) : _M_this(__vec)
2034 _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(),
2035 std::forward<_Args>(__args)...);
2038 _GLIBCXX20_CONSTEXPR
2040 { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); }
2042 _GLIBCXX20_CONSTEXPR value_type&
2043 _M_val() noexcept {
return _M_storage._M_val; }
2046 _GLIBCXX20_CONSTEXPR _Tp*
2051 constexpr _Storage() : _M_byte() { }
2052 _GLIBCXX20_CONSTEXPR ~_Storage() { }
2053 _Storage& operator=(
const _Storage&) =
delete;
2054 unsigned char _M_byte;
2059 _Storage _M_storage;
2064 template<
typename _Arg>
2065 _GLIBCXX20_CONSTEXPR
2067 _M_insert_aux(iterator __position, _Arg&& __arg);
2069 template<
typename... _Args>
2070 _GLIBCXX20_CONSTEXPR
2072 _M_realloc_insert(iterator __position, _Args&&... __args);
2074 template<
typename... _Args>
2075 _GLIBCXX20_CONSTEXPR
2077 _M_realloc_append(_Args&&... __args);
2080 _GLIBCXX20_CONSTEXPR
2082 _M_insert_rval(const_iterator __position, value_type&& __v);
2085 template<
typename... _Args>
2086 _GLIBCXX20_CONSTEXPR
2088 _M_emplace_aux(const_iterator __position, _Args&&... __args);
2091 _GLIBCXX20_CONSTEXPR
2093 _M_emplace_aux(const_iterator __position, value_type&& __v)
2094 {
return _M_insert_rval(__position,
std::move(__v)); }
2098 _GLIBCXX20_CONSTEXPR
2100 _M_check_len(size_type __n,
const char* __s)
const
2103 __throw_length_error(__N(__s));
2110 static _GLIBCXX20_CONSTEXPR size_type
2111 _S_check_init_len(size_type __n,
const allocator_type& __a)
2113 if (__n > _S_max_size(_Tp_alloc_type(__a)))
2114 __throw_length_error(
2115 __N(
"cannot create std::vector larger than max_size()"));
2119 static _GLIBCXX20_CONSTEXPR size_type
2120 _S_max_size(
const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
2125 const size_t __diffmax
2126 = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max /
sizeof(_Tp);
2128 return (
std::min)(__diffmax, __allocmax);
2135 _GLIBCXX20_CONSTEXPR
2137 _M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
2139 if (size_type __n = this->_M_impl._M_finish - __pos)
2142 _M_get_Tp_allocator());
2143 this->_M_impl._M_finish = __pos;
2144 _GLIBCXX_ASAN_ANNOTATE_SHRINK(__n);
2148 _GLIBCXX20_CONSTEXPR
2150 _M_erase(iterator __position);
2152 _GLIBCXX20_CONSTEXPR
2154 _M_erase(iterator __first, iterator __last);
2156#if __cplusplus >= 201103L
2161 _GLIBCXX20_CONSTEXPR
2166 this->_M_impl._M_swap_data(__x._M_impl);
2167 __tmp._M_impl._M_swap_data(__x._M_impl);
2168 std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
2173 _GLIBCXX20_CONSTEXPR
2177 if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
2183 this->_M_assign_aux(std::make_move_iterator(__x.begin()),
2184 std::make_move_iterator(__x.end()),
2191 template<
typename _Up>
2192 _GLIBCXX20_CONSTEXPR
2194 _M_data_ptr(_Up* __ptr)
const _GLIBCXX_NOEXCEPT
2197#if __cplusplus >= 201103L
2198 template<
typename _Ptr>
2199 _GLIBCXX20_CONSTEXPR
2200 typename std::pointer_traits<_Ptr>::element_type*
2201 _M_data_ptr(_Ptr __ptr)
const
2202 {
return empty() ? nullptr : std::__to_address(__ptr); }
2204 template<
typename _Ptr>
2206 _M_data_ptr(_Ptr __ptr)
const
2207 {
return empty() ? (value_type*)0 : __ptr.operator->(); }
2211#if __cpp_deduction_guides >= 201606
2212 template<
typename _InputIterator,
typename _ValT
2213 =
typename iterator_traits<_InputIterator>::value_type,
2214 typename _Allocator = allocator<_ValT>,
2215 typename = _RequireInputIter<_InputIterator>,
2216 typename = _RequireAllocator<_Allocator>>
2217 vector(_InputIterator, _InputIterator, _Allocator = _Allocator())
2218 -> vector<_ValT, _Allocator>;
2220#if __glibcxx_ranges_to_container
2221 template<ranges::input_range _Rg,
2222 typename _Alloc = allocator<ranges::range_value_t<_Rg>>>
2223 vector(from_range_t, _Rg&&, _Alloc = _Alloc())
2224 -> vector<ranges::range_value_t<_Rg>, _Alloc>;
2238 template<
typename _Tp,
typename _Alloc>
2239 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
2242 {
return (__x.
size() == __y.size()
2243 && std::equal(__x.
begin(), __x.
end(), __y.begin())); }
2245#if __cpp_lib_three_way_comparison
2257 template<
typename _Tp,
typename _Alloc>
2259 constexpr __detail::__synth3way_t<_Tp>
2263 __y.begin(), __y.end(),
2264 __detail::__synth3way);
2278 template<
typename _Tp,
typename _Alloc>
2279 _GLIBCXX_NODISCARD
inline bool
2280 operator<(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2281 {
return std::lexicographical_compare(__x.begin(), __x.end(),
2282 __y.begin(), __y.end()); }
2285 template<
typename _Tp,
typename _Alloc>
2286 _GLIBCXX_NODISCARD
inline bool
2287 operator!=(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2288 {
return !(__x == __y); }
2291 template<
typename _Tp,
typename _Alloc>
2292 _GLIBCXX_NODISCARD
inline bool
2293 operator>(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2294 {
return __y < __x; }
2297 template<
typename _Tp,
typename _Alloc>
2298 _GLIBCXX_NODISCARD
inline bool
2299 operator<=(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2300 {
return !(__y < __x); }
2303 template<
typename _Tp,
typename _Alloc>
2304 _GLIBCXX_NODISCARD
inline bool
2305 operator>=(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2306 {
return !(__x < __y); }
2310 template<
typename _Tp,
typename _Alloc>
2311 _GLIBCXX20_CONSTEXPR
2314 _GLIBCXX_NOEXCEPT_IF(
noexcept(__x.swap(__y)))
2317_GLIBCXX_END_NAMESPACE_CONTAINER
2319#if __cplusplus >= 201703L
2320 namespace __detail::__variant
2322 template<
typename>
struct _Never_valueless_alt;
2326 template<
typename _Tp,
typename _Alloc>
2327 struct _Never_valueless_alt<_GLIBCXX_STD_C::vector<_Tp, _Alloc>>
2333_GLIBCXX_END_NAMESPACE_VERSION