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
1117 {
return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
1120 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1123 {
return _S_max_size(_M_get_Tp_allocator()); }
1125#if __cplusplus >= 201103L
1135 _GLIBCXX20_CONSTEXPR
1139 if (__new_size >
size())
1140 _M_default_append(__new_size -
size());
1141 else if (__new_size <
size())
1142 _M_erase_at_end(this->_M_impl._M_start + __new_size);
1156 _GLIBCXX20_CONSTEXPR
1158 resize(size_type __new_size,
const value_type& __x)
1160 if (__new_size >
size())
1161 _M_fill_insert(
end(), __new_size -
size(), __x);
1162 else if (__new_size <
size())
1163 _M_erase_at_end(this->_M_impl._M_start + __new_size);
1177 _GLIBCXX20_CONSTEXPR
1179 resize(size_type __new_size, value_type __x = value_type())
1181 if (__new_size >
size())
1182 _M_fill_insert(
end(), __new_size -
size(), __x);
1183 else if (__new_size <
size())
1184 _M_erase_at_end(this->_M_impl._M_start + __new_size);
1188#if __cplusplus >= 201103L
1190 _GLIBCXX20_CONSTEXPR
1193 { _M_shrink_to_fit(); }
1200 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1204 return size_type(this->_M_impl._M_end_of_storage
1205 - this->_M_impl._M_start);
1212 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1234 _GLIBCXX20_CONSTEXPR
1250 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1254 __glibcxx_requires_subscript(__n);
1255 return *(this->_M_impl._M_start + __n);
1269 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1273 __glibcxx_requires_subscript(__n);
1274 return *(this->_M_impl._M_start + __n);
1279 _GLIBCXX20_CONSTEXPR
1283 if (__n >= this->
size())
1284 __throw_out_of_range_fmt(__N(
"vector::_M_range_check: __n "
1285 "(which is %zu) >= this->size() "
1302 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1307 return (*
this)[__n];
1321 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1326 return (*
this)[__n];
1333 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1337 __glibcxx_requires_nonempty();
1345 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1349 __glibcxx_requires_nonempty();
1357 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1361 __glibcxx_requires_nonempty();
1362 return *(
end() - 1);
1369 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1373 __glibcxx_requires_nonempty();
1374 return *(
end() - 1);
1384 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1387 {
return _M_data_ptr(this->_M_impl._M_start); }
1389 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1391 data() const _GLIBCXX_NOEXCEPT
1392 {
return _M_data_ptr(this->_M_impl._M_start); }
1405 _GLIBCXX20_CONSTEXPR
1409 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
1411 _GLIBCXX_ASAN_ANNOTATE_GROW(1);
1412 _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
1414 ++this->_M_impl._M_finish;
1415 _GLIBCXX_ASAN_ANNOTATE_GREW(1);
1418 _M_realloc_append(__x);
1421#if __cplusplus >= 201103L
1422 _GLIBCXX20_CONSTEXPR
1427 template<
typename... _Args>
1428#if __cplusplus > 201402L
1429 _GLIBCXX20_CONSTEXPR
1434 emplace_back(_Args&&... __args);
1446 _GLIBCXX20_CONSTEXPR
1450 __glibcxx_requires_nonempty();
1451 --this->_M_impl._M_finish;
1452 _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
1453 _GLIBCXX_ASAN_ANNOTATE_SHRINK(1);
1456#if __cplusplus >= 201103L
1469 template<
typename... _Args>
1470 _GLIBCXX20_CONSTEXPR
1472 emplace(const_iterator __position, _Args&&... __args)
1473 {
return _M_emplace_aux(__position, std::forward<_Args>(__args)...); }
1486 _GLIBCXX20_CONSTEXPR
1488 insert(const_iterator __position,
const value_type& __x);
1505#if __cplusplus >= 201103L
1517 _GLIBCXX20_CONSTEXPR
1519 insert(const_iterator __position, value_type&& __x)
1520 {
return _M_insert_rval(__position,
std::move(__x)); }
1535 _GLIBCXX20_CONSTEXPR
1539 auto __offset = __position -
cbegin();
1540 _M_range_insert(
begin() + __offset, __l.begin(), __l.end(),
1542 return begin() + __offset;
1546#if __cplusplus >= 201103L
1561 _GLIBCXX20_CONSTEXPR
1563 insert(const_iterator __position, size_type __n,
const value_type& __x)
1565 difference_type __offset = __position -
cbegin();
1566 _M_fill_insert(
begin() + __offset, __n, __x);
1567 return begin() + __offset;
1584 insert(
iterator __position, size_type __n,
const value_type& __x)
1585 { _M_fill_insert(__position, __n, __x); }
1588#if __cplusplus >= 201103L
1604 template<
typename _InputIterator,
1605 typename = std::_RequireInputIter<_InputIterator>>
1606 _GLIBCXX20_CONSTEXPR
1608 insert(const_iterator __position, _InputIterator __first,
1609 _InputIterator __last)
1611 difference_type __offset = __position -
cbegin();
1612 _M_range_insert(
begin() + __offset, __first, __last,
1614 return begin() + __offset;
1631 template<
typename _InputIterator>
1634 _InputIterator __last)
1637 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
1638 _M_insert_dispatch(__position, __first, __last, _Integral());
1642#if __glibcxx_ranges_to_container
1647 template<__detail::__container_compatible_range<_Tp> _Rg>
1649 insert_range(const_iterator __pos, _Rg&& __rg);
1655 template<__detail::__container_compatible_range<_Tp> _Rg>
1657 append_range(_Rg&& __rg)
1659 if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
1661 const auto __n = size_type(ranges::distance(__rg));
1663 _GLIBCXX_ASAN_ANNOTATE_GROW(__n);
1664 _Base::_M_append_range(__rg);
1665 _GLIBCXX_ASAN_ANNOTATE_GREW(__n);
1669 auto __first = ranges::begin(__rg);
1670 const auto __last = ranges::end(__rg);
1671 for (; __first != __last; ++__first)
1672 emplace_back(*__first);
1692 _GLIBCXX20_CONSTEXPR
1694#if __cplusplus >= 201103L
1696 {
return _M_erase(
begin() + (__position -
cbegin())); }
1699 {
return _M_erase(__position); }
1720 _GLIBCXX20_CONSTEXPR
1722#if __cplusplus >= 201103L
1723 erase(const_iterator __first, const_iterator __last)
1725 const auto __beg =
begin();
1726 const auto __cbeg =
cbegin();
1727 return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
1731 {
return _M_erase(__first, __last); }
1745 _GLIBCXX20_CONSTEXPR
1749#if __cplusplus >= 201103L
1750 __glibcxx_assert(_Alloc_traits::propagate_on_container_swap::value
1751 || _M_get_Tp_allocator() == __x._M_get_Tp_allocator());
1753 this->_M_impl._M_swap_data(__x._M_impl);
1754 _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
1755 __x._M_get_Tp_allocator());
1764 _GLIBCXX20_CONSTEXPR
1767 { _M_erase_at_end(this->_M_impl._M_start); }
1777 _GLIBCXX20_CONSTEXPR
1778 _Guard_alloc(pointer __s, size_type __l, _Base& __vect)
1779 : _M_storage(__s), _M_len(__l), _M_vect(__vect)
1782 _GLIBCXX20_CONSTEXPR
1786 _M_vect._M_deallocate(_M_storage, _M_len);
1789 _GLIBCXX20_CONSTEXPR
1793 pointer __res = _M_storage;
1794 _M_storage = pointer();
1799 _Guard_alloc(
const _Guard_alloc&);
1807 template<
typename _ForwardIterator>
1808 _GLIBCXX20_CONSTEXPR
1811 _ForwardIterator __first, _ForwardIterator __last)
1813 _Guard_alloc __guard(this->_M_allocate(__n), __n, *
this);
1814 std::__uninitialized_copy_a
1815 (__first, __last, __guard._M_storage, _M_get_Tp_allocator());
1816 return __guard._M_release();
1824#if __cplusplus < 201103L
1827 template<
typename _Integer>
1829 _M_initialize_dispatch(_Integer __int_n, _Integer __value, __true_type)
1831 const size_type __n =
static_cast<size_type
>(__int_n);
1833 _M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator()));
1834 this->_M_impl._M_start = __start;
1835 this->_M_impl._M_end_of_storage = __start + __n;
1836 _M_fill_initialize(__n, __value);
1840 template<
typename _InputIterator>
1842 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1845 _M_range_initialize(__first, __last,
1851 template<
typename _InputIterator>
1852 _GLIBCXX20_CONSTEXPR
1854 _M_range_initialize(_InputIterator __first, _InputIterator __last,
1858 for (; __first != __last; ++__first)
1859#
if __cplusplus >= 201103L
1860 emplace_back(*__first);
1866 __throw_exception_again;
1871 template<
typename _ForwardIterator>
1872 _GLIBCXX20_CONSTEXPR
1874 _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
1879 this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator()));
1880 _Guard_alloc __guard(__start, __n, *
this);
1881 this->_M_impl._M_finish = std::__uninitialized_copy_a
1882 (__first, __last, __start, _M_get_Tp_allocator());
1883 this->_M_impl._M_start = __start;
1884 (void) __guard._M_release();
1885 this->_M_impl._M_end_of_storage = __start + __n;
1890 _GLIBCXX20_CONSTEXPR
1892 _M_fill_initialize(size_type __n,
const value_type& __value)
1894 this->_M_impl._M_finish =
1895 std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
1896 _M_get_Tp_allocator());
1899#if __cplusplus >= 201103L
1901 _GLIBCXX20_CONSTEXPR
1903 _M_default_initialize(size_type __n)
1905 this->_M_impl._M_finish =
1906 std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
1907 _M_get_Tp_allocator());
1918 template<
typename _Integer>
1919 _GLIBCXX20_CONSTEXPR
1921 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
1922 { _M_fill_assign(__n, __val); }
1925 template<
typename _InputIterator>
1926 _GLIBCXX20_CONSTEXPR
1928 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
1933 template<
typename _InputIterator>
1934 _GLIBCXX20_CONSTEXPR
1936 _M_assign_aux(_InputIterator __first, _InputIterator __last,
1940 template<
typename _ForwardIterator>
1941 _GLIBCXX20_CONSTEXPR
1943 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1948 _GLIBCXX20_CONSTEXPR
1950 _M_fill_assign(size_type __n,
const value_type& __val);
1958 template<
typename _Integer>
1959 _GLIBCXX20_CONSTEXPR
1961 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
1963 { _M_fill_insert(__pos, __n, __val); }
1966 template<
typename _InputIterator>
1967 _GLIBCXX20_CONSTEXPR
1969 _M_insert_dispatch(iterator __pos, _InputIterator __first,
1970 _InputIterator __last, __false_type)
1972 _M_range_insert(__pos, __first, __last,
1977 template<
typename _InputIterator>
1978 _GLIBCXX20_CONSTEXPR
1980 _M_range_insert(iterator __pos, _InputIterator __first,
1984 template<
typename _ForwardIterator>
1985 _GLIBCXX20_CONSTEXPR
1987 _M_range_insert(iterator __pos, _ForwardIterator __first,
1992 _GLIBCXX20_CONSTEXPR
1994 _M_fill_insert(iterator __pos, size_type __n,
const value_type& __x);
1996#if __cplusplus >= 201103L
1998 _GLIBCXX20_CONSTEXPR
2000 _M_default_append(size_type __n);
2002 _GLIBCXX20_CONSTEXPR
2007#if __cplusplus < 201103L
2010 _M_insert_aux(iterator __position,
const value_type& __x);
2013 _M_realloc_insert(iterator __position,
const value_type& __x);
2016 _M_realloc_append(
const value_type& __x);
2020 struct _Temporary_value
2022 template<
typename... _Args>
2023 _GLIBCXX20_CONSTEXPR
explicit
2024 _Temporary_value(
vector* __vec, _Args&&... __args) : _M_this(__vec)
2026 _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(),
2027 std::forward<_Args>(__args)...);
2030 _GLIBCXX20_CONSTEXPR
2032 { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); }
2034 _GLIBCXX20_CONSTEXPR value_type&
2035 _M_val() noexcept {
return _M_storage._M_val; }
2038 _GLIBCXX20_CONSTEXPR _Tp*
2043 constexpr _Storage() : _M_byte() { }
2044 _GLIBCXX20_CONSTEXPR ~_Storage() { }
2045 _Storage& operator=(
const _Storage&) =
delete;
2046 unsigned char _M_byte;
2051 _Storage _M_storage;
2056 template<
typename _Arg>
2057 _GLIBCXX20_CONSTEXPR
2059 _M_insert_aux(iterator __position, _Arg&& __arg);
2061 template<
typename... _Args>
2062 _GLIBCXX20_CONSTEXPR
2064 _M_realloc_insert(iterator __position, _Args&&... __args);
2066 template<
typename... _Args>
2067 _GLIBCXX20_CONSTEXPR
2069 _M_realloc_append(_Args&&... __args);
2072 _GLIBCXX20_CONSTEXPR
2074 _M_insert_rval(const_iterator __position, value_type&& __v);
2077 template<
typename... _Args>
2078 _GLIBCXX20_CONSTEXPR
2080 _M_emplace_aux(const_iterator __position, _Args&&... __args);
2083 _GLIBCXX20_CONSTEXPR
2085 _M_emplace_aux(const_iterator __position, value_type&& __v)
2086 {
return _M_insert_rval(__position,
std::move(__v)); }
2090 _GLIBCXX20_CONSTEXPR
2092 _M_check_len(size_type __n,
const char* __s)
const
2095 __throw_length_error(__N(__s));
2102 static _GLIBCXX20_CONSTEXPR size_type
2103 _S_check_init_len(size_type __n,
const allocator_type& __a)
2105 if (__n > _S_max_size(_Tp_alloc_type(__a)))
2106 __throw_length_error(
2107 __N(
"cannot create std::vector larger than max_size()"));
2111 static _GLIBCXX20_CONSTEXPR size_type
2112 _S_max_size(
const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
2117 const size_t __diffmax
2118 = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max /
sizeof(_Tp);
2120 return (
std::min)(__diffmax, __allocmax);
2127 _GLIBCXX20_CONSTEXPR
2129 _M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
2131 if (size_type __n = this->_M_impl._M_finish - __pos)
2134 _M_get_Tp_allocator());
2135 this->_M_impl._M_finish = __pos;
2136 _GLIBCXX_ASAN_ANNOTATE_SHRINK(__n);
2140 _GLIBCXX20_CONSTEXPR
2142 _M_erase(iterator __position);
2144 _GLIBCXX20_CONSTEXPR
2146 _M_erase(iterator __first, iterator __last);
2148#if __cplusplus >= 201103L
2153 _GLIBCXX20_CONSTEXPR
2158 this->_M_impl._M_swap_data(__x._M_impl);
2159 __tmp._M_impl._M_swap_data(__x._M_impl);
2160 std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
2165 _GLIBCXX20_CONSTEXPR
2169 if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
2175 this->_M_assign_aux(std::make_move_iterator(__x.begin()),
2176 std::make_move_iterator(__x.end()),
2183 template<
typename _Up>
2184 _GLIBCXX20_CONSTEXPR
2186 _M_data_ptr(_Up* __ptr)
const _GLIBCXX_NOEXCEPT
2189#if __cplusplus >= 201103L
2190 template<
typename _Ptr>
2191 _GLIBCXX20_CONSTEXPR
2192 typename std::pointer_traits<_Ptr>::element_type*
2193 _M_data_ptr(_Ptr __ptr)
const
2194 {
return empty() ? nullptr : std::__to_address(__ptr); }
2196 template<
typename _Ptr>
2198 _M_data_ptr(_Ptr __ptr)
const
2199 {
return empty() ? (value_type*)0 : __ptr.operator->(); }
2203#if __cpp_deduction_guides >= 201606
2204 template<
typename _InputIterator,
typename _ValT
2205 =
typename iterator_traits<_InputIterator>::value_type,
2206 typename _Allocator = allocator<_ValT>,
2207 typename = _RequireInputIter<_InputIterator>,
2208 typename = _RequireAllocator<_Allocator>>
2209 vector(_InputIterator, _InputIterator, _Allocator = _Allocator())
2210 -> vector<_ValT, _Allocator>;
2212#if __glibcxx_ranges_to_container
2213 template<ranges::input_range _Rg,
2214 typename _Alloc = allocator<ranges::range_value_t<_Rg>>>
2215 vector(from_range_t, _Rg&&, _Alloc = _Alloc())
2216 -> vector<ranges::range_value_t<_Rg>, _Alloc>;
2230 template<
typename _Tp,
typename _Alloc>
2231 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
2234 {
return (__x.
size() == __y.size()
2235 && std::equal(__x.
begin(), __x.
end(), __y.begin())); }
2237#if __cpp_lib_three_way_comparison
2249 template<
typename _Tp,
typename _Alloc>
2251 constexpr __detail::__synth3way_t<_Tp>
2255 __y.begin(), __y.end(),
2256 __detail::__synth3way);
2270 template<
typename _Tp,
typename _Alloc>
2271 _GLIBCXX_NODISCARD
inline bool
2272 operator<(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2273 {
return std::lexicographical_compare(__x.begin(), __x.end(),
2274 __y.begin(), __y.end()); }
2277 template<
typename _Tp,
typename _Alloc>
2278 _GLIBCXX_NODISCARD
inline bool
2279 operator!=(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2280 {
return !(__x == __y); }
2283 template<
typename _Tp,
typename _Alloc>
2284 _GLIBCXX_NODISCARD
inline bool
2285 operator>(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2286 {
return __y < __x; }
2289 template<
typename _Tp,
typename _Alloc>
2290 _GLIBCXX_NODISCARD
inline bool
2291 operator<=(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2292 {
return !(__y < __x); }
2295 template<
typename _Tp,
typename _Alloc>
2296 _GLIBCXX_NODISCARD
inline bool
2297 operator>=(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2298 {
return !(__x < __y); }
2302 template<
typename _Tp,
typename _Alloc>
2303 _GLIBCXX20_CONSTEXPR
2306 _GLIBCXX_NOEXCEPT_IF(
noexcept(__x.swap(__y)))
2309_GLIBCXX_END_NAMESPACE_CONTAINER
2311#if __cplusplus >= 201703L
2312 namespace __detail::__variant
2314 template<
typename>
struct _Never_valueless_alt;
2318 template<
typename _Tp,
typename _Alloc>
2319 struct _Never_valueless_alt<_GLIBCXX_STD_C::vector<_Tp, _Alloc>>
2325_GLIBCXX_END_NAMESPACE_VERSION