988 using _Base::get_allocator;
999 {
return iterator(this->_M_impl._M_start); }
1009 {
return const_iterator(this->_M_impl._M_start); }
1019 {
return iterator(this->_M_impl._M_finish); }
1029 {
return const_iterator(this->_M_impl._M_finish); }
1047 const_reverse_iterator
1067 const_reverse_iterator
1071#if __cplusplus >= 201103L
1080 {
return const_iterator(this->_M_impl._M_start); }
1090 {
return const_iterator(this->_M_impl._M_finish); }
1098 const_reverse_iterator
1108 const_reverse_iterator
1119 ptrdiff_t __dif = this->_M_impl._M_finish - this->_M_impl._M_start;
1122 return size_type(
__dif);
1129 {
return _S_max_size(_M_get_Tp_allocator()); }
1131#if __cplusplus >= 201103L
1148 _M_erase_at_end(this->_M_impl._M_start +
__new_size);
1169 _M_erase_at_end(this->_M_impl._M_start +
__new_size);
1190 _M_erase_at_end(this->_M_impl._M_start +
__new_size);
1194#if __cplusplus >= 201103L
1196 _GLIBCXX20_CONSTEXPR
1199 { _M_shrink_to_fit(); }
1211 - this->_M_impl._M_start;
1214 return size_type(
__dif);
1263 __glibcxx_requires_subscript(__n);
1264 return *(this->_M_impl._M_start + __n);
1282 __glibcxx_requires_subscript(__n);
1283 return *(this->_M_impl._M_start + __n);
1292 if (__n >= this->
size())
1293 __throw_out_of_range_fmt(__N(
"vector::_M_range_check: __n "
1294 "(which is %zu) >= this->size() "
1316 return (*
this)[__n];
1335 return (*
this)[__n];
1346 __glibcxx_requires_nonempty();
1358 __glibcxx_requires_nonempty();
1370 __glibcxx_requires_nonempty();
1371 return *(
end() - 1);
1382 __glibcxx_requires_nonempty();
1383 return *(
end() - 1);
1396 {
return _M_data_ptr(this->_M_impl._M_start); }
1401 {
return _M_data_ptr(this->_M_impl._M_start); }
1414 _GLIBCXX20_CONSTEXPR
1418 if (this->_M_impl._M_finish !=
this->_M_impl._M_end_of_storage)
1420 _GLIBCXX_ASAN_ANNOTATE_GROW(1);
1421 _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
1423 ++this->_M_impl._M_finish;
1424 _GLIBCXX_ASAN_ANNOTATE_GREW(1);
1427 _M_realloc_append(__x);
1430#if __cplusplus >= 201103L
1436 template<
typename... _Args>
1437#if __cplusplus > 201402L
1438 _GLIBCXX20_CONSTEXPR
1443 emplace_back(_Args&&... __args);
1455 _GLIBCXX20_CONSTEXPR
1459 __glibcxx_requires_nonempty();
1460 --this->_M_impl._M_finish;
1461 _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
1462 _GLIBCXX_ASAN_ANNOTATE_SHRINK(1);
1465#if __cplusplus >= 201103L
1478 template<
typename...
_Args>
1514#if __cplusplus >= 201103L
1549 _M_range_insert(
begin() + __offset,
__l.begin(),
__l.end(),
1551 return begin() + __offset;
1555#if __cplusplus >= 201103L
1575 _M_fill_insert(
begin() + __offset, __n, __x);
1576 return begin() + __offset;
1597#if __cplusplus >= 201103L
1613 template<
typename _InputIterator,
1615 _GLIBCXX20_CONSTEXPR
1621 _M_range_insert(
begin() + __offset, __first, __last,
1623 return begin() + __offset;
1640 template<
typename _InputIterator>
1646 typedef typename std::__is_integer<_InputIterator>::__type
_Integral;
1651#if __glibcxx_containers_ranges
1660 template<__detail::__container_compatible_range<_Tp> _Rg>
1662 insert_range(const_iterator __pos, _Rg&& __rg);
1669 template<__detail::__container_compatible_range<_Tp> _Rg>
1671 append_range(_Rg&& __rg)
1676 if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
1678 const auto __n = size_type(ranges::distance(__rg));
1685 const auto __sz =
size();
1686 const auto __capacity =
capacity();
1687 if ((__capacity - __sz) >= __n)
1689 _GLIBCXX_ASAN_ANNOTATE_GROW(__n);
1690 _Base::_M_append_range(__rg);
1691 _GLIBCXX_ASAN_ANNOTATE_GREW(__n);
1695 const size_type __len = _M_check_len(__n,
"vector::append_range");
1697 pointer __old_start = this->_M_impl._M_start;
1698 pointer __old_finish = this->_M_impl._M_finish;
1700 allocator_type& __a = _M_get_Tp_allocator();
1701 const pointer __start = this->_M_allocate(__len);
1702 const pointer __mid = __start + __sz;
1703 const pointer __back = __mid + __n;
1704 _Guard_alloc __guard(__start, __len, *
this);
1709 if constexpr (_S_use_relocate())
1710 _S_relocate(__old_start, __old_finish, __start, __a);
1716 pointer _M_first, _M_last;
1717 _Tp_alloc_type& _M_alloc;
1720 _Guard_elts(pointer __f, pointer __l, _Tp_alloc_type& __a)
1721 : _M_first(__f), _M_last(__l), _M_alloc(__a)
1728 _Guard_elts(_Guard_elts&&) =
delete;
1730 _Guard_elts __guard_elts{__mid, __back, __a};
1736 __guard_elts._M_first = __old_start;
1737 __guard_elts._M_last = __old_finish;
1741 __guard._M_storage = __old_start;
1742 __guard._M_len = __capacity;
1744 this->_M_impl._M_start = __start;
1745 this->_M_impl._M_finish = __back;
1746 this->_M_impl._M_end_of_storage = __start + __len;
1750 auto __first = ranges::begin(__rg);
1751 const auto __last = ranges::end(__rg);
1755 __first != __last && __free > 0;
1756 ++__first, (void) --__free)
1757 emplace_back(*__first);
1759 if (__first == __last)
1763 vector __tmp(_M_get_Tp_allocator());
1764 for (; __first != __last; ++__first)
1765 __tmp.emplace_back(*__first);
1766 reserve(_M_check_len(__tmp.size(),
"vector::append_range"));
1767 ranges::subrange __r(std::make_move_iterator(__tmp.begin()),
1768 std::make_move_iterator(__tmp.end()));
1789 _GLIBCXX20_CONSTEXPR
1791#if __cplusplus >= 201103L
1817 _GLIBCXX20_CONSTEXPR
1819#if __cplusplus >= 201103L
1820 erase(const_iterator __first, const_iterator __last)
1828 {
return _M_erase(__first, __last); }
1842 _GLIBCXX20_CONSTEXPR
1846#if __cplusplus >= 201103L
1847 __glibcxx_assert(_Alloc_traits::propagate_on_container_swap::value
1848 || _M_get_Tp_allocator() == __x._M_get_Tp_allocator());
1850 this->_M_impl._M_swap_data(__x._M_impl);
1851 _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
1852 __x._M_get_Tp_allocator());
1864 { _M_erase_at_end(this->_M_impl._M_start); }
1875 _Guard_alloc(pointer
__s, size_type
__l, _Base&
__vect)
1879 _GLIBCXX20_CONSTEXPR
1883 _M_vect._M_deallocate(_M_storage, _M_len);
1886 _GLIBCXX20_CONSTEXPR
1890 pointer __res = _M_storage;
1891 _M_storage = pointer();
1896 _Guard_alloc(
const _Guard_alloc&);
1904 template<
typename _ForwardIterator>
1905 _GLIBCXX20_CONSTEXPR
1910 _Guard_alloc __guard(this->_M_allocate(__n), __n, *
this);
1912 (__first, __last, __guard._M_storage, _M_get_Tp_allocator());
1913 return __guard._M_release();
1921#if __cplusplus < 201103L
1924 template<
typename _Integer>
1928 const size_type __n =
static_cast<size_type
>(
__int_n);
1930 _M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator()));
1931 this->_M_impl._M_start =
__start;
1932 this->_M_impl._M_end_of_storage =
__start + __n;
1933 _M_fill_initialize(__n, __value);
1937 template<
typename _InputIterator>
1939 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1942 _M_range_initialize(__first, __last,
1948 template<
typename _InputIterator>
1949 _GLIBCXX20_CONSTEXPR
1951 _M_range_initialize(_InputIterator __first, _InputIterator __last,
1955 for (; __first != __last; ++__first)
1956#
if __cplusplus >= 201103L
1957 emplace_back(*__first);
1963 __throw_exception_again;
1968 template<
typename _ForwardIterator>
1969 _GLIBCXX20_CONSTEXPR
1971 _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
1974 _M_range_initialize_n(__first, __last,
1978 template<
typename _Iterator,
typename _Sentinel>
1979 _GLIBCXX20_CONSTEXPR
1981 _M_range_initialize_n(_Iterator __first, _Sentinel __last,
1985 this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator()));
1986 this->_M_impl._M_start = this->_M_impl._M_finish = __start;
1987 this->_M_impl._M_end_of_storage = __start + __n;
1988 this->_M_impl._M_finish
1990 __start, _M_get_Tp_allocator());
1995 _GLIBCXX20_CONSTEXPR
1997 _M_fill_initialize(size_type __n,
const value_type& __value)
1999 this->_M_impl._M_finish =
2001 _M_get_Tp_allocator());
2004#if __cplusplus >= 201103L
2006 _GLIBCXX20_CONSTEXPR
2008 _M_default_initialize(size_type __n)
2010 this->_M_impl._M_finish =
2012 _M_get_Tp_allocator());
2023 template<
typename _Integer>
2024 _GLIBCXX20_CONSTEXPR
2026 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
2027 { _M_fill_assign(__n, __val); }
2030 template<
typename _InputIterator>
2031 _GLIBCXX20_CONSTEXPR
2033 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
2038 template<
typename _InputIterator>
2039 _GLIBCXX20_CONSTEXPR
2041 _M_assign_aux(_InputIterator __first, _InputIterator __last,
2045 template<
typename _ForwardIterator>
2046 _GLIBCXX20_CONSTEXPR
2048 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
2053 _GLIBCXX20_CONSTEXPR
2055 _M_fill_assign(size_type __n,
const value_type& __val);
2063 template<
typename _Integer>
2064 _GLIBCXX20_CONSTEXPR
2066 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
2068 { _M_fill_insert(__pos, __n, __val); }
2071 template<
typename _InputIterator>
2072 _GLIBCXX20_CONSTEXPR
2074 _M_insert_dispatch(iterator __pos, _InputIterator __first,
2075 _InputIterator __last, __false_type)
2077 _M_range_insert(__pos, __first, __last,
2082 template<
typename _InputIterator>
2083 _GLIBCXX20_CONSTEXPR
2085 _M_range_insert(iterator __pos, _InputIterator __first,
2089 template<
typename _ForwardIterator>
2090 _GLIBCXX20_CONSTEXPR
2092 _M_range_insert(iterator __pos, _ForwardIterator __first,
2097 _GLIBCXX20_CONSTEXPR
2099 _M_fill_insert(iterator __pos, size_type __n,
const value_type& __x);
2101#if __cplusplus >= 201103L
2103 _GLIBCXX20_CONSTEXPR
2105 _M_default_append(size_type __n);
2107 _GLIBCXX20_CONSTEXPR
2112#if __cplusplus < 201103L
2115 _M_insert_aux(iterator __position,
const value_type& __x);
2118 _M_realloc_insert(iterator __position,
const value_type& __x);
2121 _M_realloc_append(
const value_type& __x);
2125 struct _Temporary_value
2127 template<
typename... _Args>
2128 _GLIBCXX20_CONSTEXPR
explicit
2129 _Temporary_value(
vector* __vec, _Args&&... __args) : _M_this(__vec)
2131 _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(),
2135 _GLIBCXX20_CONSTEXPR
2137 { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); }
2139 _GLIBCXX20_CONSTEXPR value_type&
2140 _M_val() noexcept {
return _M_storage._M_val; }
2143 _GLIBCXX20_CONSTEXPR _Tp*
2148 constexpr _Storage() : _M_byte() { }
2149 _GLIBCXX20_CONSTEXPR ~_Storage() { }
2150 _Storage& operator=(
const _Storage&) =
delete;
2151 unsigned char _M_byte;
2156 _Storage _M_storage;
2161 template<
typename _Arg>
2162 _GLIBCXX20_CONSTEXPR
2164 _M_insert_aux(iterator __position, _Arg&& __arg);
2166 template<
typename... _Args>
2167 _GLIBCXX20_CONSTEXPR
2169 _M_realloc_insert(iterator __position, _Args&&... __args);
2171 template<
typename... _Args>
2172 _GLIBCXX20_CONSTEXPR
2174 _M_realloc_append(_Args&&... __args);
2177 _GLIBCXX20_CONSTEXPR
2179 _M_insert_rval(const_iterator __position, value_type&& __v);
2182 template<
typename... _Args>
2183 _GLIBCXX20_CONSTEXPR
2185 _M_emplace_aux(const_iterator __position, _Args&&... __args);
2188 _GLIBCXX20_CONSTEXPR
2190 _M_emplace_aux(const_iterator __position, value_type&& __v)
2191 {
return _M_insert_rval(__position,
std::move(__v)); }
2195 _GLIBCXX20_CONSTEXPR
2197 _M_check_len(size_type __n,
const char* __s)
const
2200 __throw_length_error(__N(__s));
2207 static _GLIBCXX20_CONSTEXPR size_type
2208 _S_check_init_len(size_type __n,
const allocator_type& __a)
2210 if (__n > _S_max_size(_Tp_alloc_type(__a)))
2211 __throw_length_error(
2212 __N(
"cannot create std::vector larger than max_size()"));
2216 static _GLIBCXX20_CONSTEXPR size_type
2217 _S_max_size(
const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
2222 const size_t __diffmax
2223 = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max /
sizeof(_Tp);
2225 return (
std::min)(__diffmax, __allocmax);
2232 _GLIBCXX20_CONSTEXPR
2234 _M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
2236 if (size_type __n = this->_M_impl._M_finish - __pos)
2239 _M_get_Tp_allocator());
2240 this->_M_impl._M_finish = __pos;
2241 _GLIBCXX_ASAN_ANNOTATE_SHRINK(__n);
2245 _GLIBCXX20_CONSTEXPR
2247 _M_erase(iterator __position);
2249 _GLIBCXX20_CONSTEXPR
2251 _M_erase(iterator __first, iterator __last);
2253#if __cplusplus >= 201103L
2258 _GLIBCXX20_CONSTEXPR
2263 this->_M_impl._M_swap_data(__x._M_impl);
2264 __tmp._M_impl._M_swap_data(__x._M_impl);
2270 _GLIBCXX20_CONSTEXPR
2274 if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
2280 this->_M_assign_aux(std::make_move_iterator(__x.begin()),
2281 std::make_move_iterator(__x.end()),
2288 template<
typename _Up>
2289 _GLIBCXX20_CONSTEXPR
2291 _M_data_ptr(_Up* __ptr)
const _GLIBCXX_NOEXCEPT
2294#if __cplusplus >= 201103L
2295 template<
typename _Ptr>
2296 _GLIBCXX20_CONSTEXPR
2298 _M_data_ptr(_Ptr __ptr)
const
2301 template<
typename _Ptr>
2303 _M_data_ptr(_Ptr __ptr)
const
2304 {
return empty() ? (value_type*)0 : __ptr.operator->(); }
2308#if __cpp_deduction_guides >= 201606
2309 template<
typename _InputIterator,
typename _ValT
2310 =
typename iterator_traits<_InputIterator>::value_type,
2311 typename _Allocator = allocator<_ValT>,
2312 typename = _RequireInputIter<_InputIterator>,
2313 typename = _RequireAllocator<_Allocator>>
2314 vector(_InputIterator, _InputIterator, _Allocator = _Allocator())
2315 -> vector<_ValT, _Allocator>;
2317#if __glibcxx_containers_ranges
2318 template<ranges::input_range _Rg,
2319 typename _Alloc = allocator<ranges::range_value_t<_Rg>>>
2320 vector(from_range_t, _Rg&&, _Alloc = _Alloc())
2321 -> vector<ranges::range_value_t<_Rg>, _Alloc>;
2335 template<
typename _Tp,
typename _Alloc>
2336 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
2339 {
return (__x.size() == __y.size()
2340 && std::equal(__x.begin(), __x.end(), __y.begin())); }
2342#if __cpp_lib_three_way_comparison
2354 template<
typename _Tp,
typename _Alloc>
2356 constexpr __detail::__synth3way_t<_Tp>
2360 __y.begin(), __y.end(),
2361 __detail::__synth3way);
2375 template<
typename _Tp,
typename _Alloc>
2376 _GLIBCXX_NODISCARD
inline bool
2377 operator<(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2378 {
return std::lexicographical_compare(__x.begin(), __x.end(),
2379 __y.begin(), __y.end()); }
2382 template<
typename _Tp,
typename _Alloc>
2383 _GLIBCXX_NODISCARD
inline bool
2384 operator!=(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2385 {
return !(__x == __y); }
2388 template<
typename _Tp,
typename _Alloc>
2389 _GLIBCXX_NODISCARD
inline bool
2390 operator>(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2391 {
return __y < __x; }
2394 template<
typename _Tp,
typename _Alloc>
2395 _GLIBCXX_NODISCARD
inline bool
2396 operator<=(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2397 {
return !(__y < __x); }
2400 template<
typename _Tp,
typename _Alloc>
2401 _GLIBCXX_NODISCARD
inline bool
2402 operator>=(
const vector<_Tp, _Alloc>& __x,
const vector<_Tp, _Alloc>& __y)
2403 {
return !(__x < __y); }
2407 template<
typename _Tp,
typename _Alloc>
2408 _GLIBCXX20_CONSTEXPR
2414_GLIBCXX_END_NAMESPACE_CONTAINER
2416#if __cplusplus >= 201703L
2417 namespace __detail::__variant
2419 template<
typename>
struct _Never_valueless_alt;
2423 template<
typename _Tp,
typename _Alloc>
2424 struct _Never_valueless_alt<_GLIBCXX_STD_C::vector<_Tp, _Alloc>>
2430_GLIBCXX_END_NAMESPACE_VERSION