1// Vector implementation -*- C++ -*-
2
3// Copyright (C) 2001-2019 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/*
26 *
27 * Copyright (c) 1994
28 * Hewlett-Packard Company
29 *
30 * Permission to use, copy, modify, distribute and sell this software
31 * and its documentation for any purpose is hereby granted without fee,
32 * provided that the above copyright notice appear in all copies and
33 * that both that copyright notice and this permission notice appear
34 * in supporting documentation. Hewlett-Packard Company makes no
35 * representations about the suitability of this software for any
36 * purpose. It is provided "as is" without express or implied warranty.
37 *
38 *
39 * Copyright (c) 1996
40 * Silicon Graphics Computer Systems, Inc.
41 *
42 * Permission to use, copy, modify, distribute and sell this software
43 * and its documentation for any purpose is hereby granted without fee,
44 * provided that the above copyright notice appear in all copies and
45 * that both that copyright notice and this permission notice appear
46 * in supporting documentation. Silicon Graphics makes no
47 * representations about the suitability of this software for any
48 * purpose. It is provided "as is" without express or implied warranty.
49 */
50
51/** @file bits/stl_vector.h
52 * This is an internal header file, included by other library headers.
53 * Do not attempt to use it directly. @headername{vector}
54 */
55
56#ifndef _STL_VECTOR_H
57#define _STL_VECTOR_H 1
58
59#include <bits/stl_iterator_base_funcs.h>
60#include <bits/functexcept.h>
61#include <bits/concept_check.h>
62#if __cplusplus >= 201103L
63#include <initializer_list>
64#endif
65
66#include <debug/assertions.h>
67
68#if _GLIBCXX_SANITIZE_STD_ALLOCATOR && _GLIBCXX_SANITIZE_VECTOR
69extern "C" void
70__sanitizer_annotate_contiguous_container(const void*, const void*,
71 const void*, const void*);
72#endif
73
74namespace std _GLIBCXX_VISIBILITY(default)
75{
76_GLIBCXX_BEGIN_NAMESPACE_VERSION
77_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
78
79 /// See bits/stl_deque.h's _Deque_base for an explanation.
80 template<typename _Tp, typename _Alloc>
81 struct _Vector_base
82 {
83 typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
84 rebind<_Tp>::other _Tp_alloc_type;
85 typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
86 pointer;
87
88 struct _Vector_impl_data
89 {
90 pointer _M_start;
91 pointer _M_finish;
92 pointer _M_end_of_storage;
93
94 _Vector_impl_data() _GLIBCXX_NOEXCEPT
95 : _M_start(), _M_finish(), _M_end_of_storage()
96 { }
97
98#if __cplusplus >= 201103L
99 _Vector_impl_data(_Vector_impl_data&& __x) noexcept
100 : _M_start(__x._M_start), _M_finish(__x._M_finish),
101 _M_end_of_storage(__x._M_end_of_storage)
102 { __x._M_start = __x._M_finish = __x._M_end_of_storage = pointer(); }
103#endif
104
105 void
106 _M_copy_data(_Vector_impl_data const& __x) _GLIBCXX_NOEXCEPT
107 {
108 _M_start = __x._M_start;
109 _M_finish = __x._M_finish;
110 _M_end_of_storage = __x._M_end_of_storage;
111 }
112
113 void
114 _M_swap_data(_Vector_impl_data& __x) _GLIBCXX_NOEXCEPT
115 {
116 // Do not use std::swap(_M_start, __x._M_start), etc as it loses
117 // information used by TBAA.
118 _Vector_impl_data __tmp;
119 __tmp._M_copy_data(*this);
120 _M_copy_data(__x);
121 __x._M_copy_data(__tmp);
122 }
123 };
124
125 struct _Vector_impl
126 : public _Tp_alloc_type, public _Vector_impl_data
127 {
128 _Vector_impl() _GLIBCXX_NOEXCEPT_IF(
129 is_nothrow_default_constructible<_Tp_alloc_type>::value)
130 : _Tp_alloc_type()
131 { }
132
133 _Vector_impl(_Tp_alloc_type const& __a) _GLIBCXX_NOEXCEPT
134 : _Tp_alloc_type(__a)
135 { }
136
137#if __cplusplus >= 201103L
138 // Not defaulted, to enforce noexcept(true) even when
139 // !is_nothrow_move_constructible<_Tp_alloc_type>.
140 _Vector_impl(_Vector_impl&& __x) noexcept
141 : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x))
142 { }
143
144 _Vector_impl(_Tp_alloc_type&& __a) noexcept
145 : _Tp_alloc_type(std::move(__a))
146 { }
147
148 _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept
149 : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv))
150 { }
151#endif
152
153#if _GLIBCXX_SANITIZE_STD_ALLOCATOR && _GLIBCXX_SANITIZE_VECTOR
154 template<typename = _Tp_alloc_type>
155 struct _Asan
156 {
157 typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>
158 ::size_type size_type;
159
160 static void _S_shrink(_Vector_impl&, size_type) { }
161 static void _S_on_dealloc(_Vector_impl&) { }
162
163 typedef _Vector_impl& _Reinit;
164
165 struct _Grow
166 {
167 _Grow(_Vector_impl&, size_type) { }
168 void _M_grew(size_type) { }
169 };
170 };
171
172 // Enable ASan annotations for memory obtained from std::allocator.
173 template<typename _Up>
174 struct _Asan<allocator<_Up> >
175 {
176 typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>
177 ::size_type size_type;
178
179 // Adjust ASan annotation for [_M_start, _M_end_of_storage) to
180 // mark end of valid region as __curr instead of __prev.
181 static void
182 _S_adjust(_Vector_impl& __impl, pointer __prev, pointer __curr)
183 {
184 __sanitizer_annotate_contiguous_container(__impl._M_start,
185 __impl._M_end_of_storage, __prev, __curr);
186 }
187
188 static void
189 _S_grow(_Vector_impl& __impl, size_type __n)
190 { _S_adjust(__impl, __impl._M_finish, __impl._M_finish + __n); }
191
192 static void
193 _S_shrink(_Vector_impl& __impl, size_type __n)
194 { _S_adjust(__impl, __impl._M_finish + __n, __impl._M_finish); }
195
196 static void
197 _S_on_dealloc(_Vector_impl& __impl)
198 {
199 if (__impl._M_start)
200 _S_adjust(__impl, __impl._M_finish, __impl._M_end_of_storage);
201 }
202
203 // Used on reallocation to tell ASan unused capacity is invalid.
204 struct _Reinit
205 {
206 explicit _Reinit(_Vector_impl& __impl) : _M_impl(__impl)
207 {
208 // Mark unused capacity as valid again before deallocating it.
209 _S_on_dealloc(_M_impl);
210 }
211
212 ~_Reinit()
213 {
214 // Mark unused capacity as invalid after reallocation.
215 if (_M_impl._M_start)
216 _S_adjust(_M_impl, _M_impl._M_end_of_storage,
217 _M_impl._M_finish);
218 }
219
220 _Vector_impl& _M_impl;
221
222#if __cplusplus >= 201103L
223 _Reinit(const _Reinit&) = delete;
224 _Reinit& operator=(const _Reinit&) = delete;
225#endif
226 };
227
228 // Tell ASan when unused capacity is initialized to be valid.
229 struct _Grow
230 {
231 _Grow(_Vector_impl& __impl, size_type __n)
232 : _M_impl(__impl), _M_n(__n)
233 { _S_grow(_M_impl, __n); }
234
235 ~_Grow() { if (_M_n) _S_shrink(_M_impl, _M_n); }
236
237 void _M_grew(size_type __n) { _M_n -= __n; }
238
239#if __cplusplus >= 201103L
240 _Grow(const _Grow&) = delete;
241 _Grow& operator=(const _Grow&) = delete;
242#endif
243 private:
244 _Vector_impl& _M_impl;
245 size_type _M_n;
246 };
247 };
248
249#define _GLIBCXX_ASAN_ANNOTATE_REINIT \
250 typename _Base::_Vector_impl::template _Asan<>::_Reinit const \
251 __attribute__((__unused__)) __reinit_guard(this->_M_impl)
252#define _GLIBCXX_ASAN_ANNOTATE_GROW(n) \
253 typename _Base::_Vector_impl::template _Asan<>::_Grow \
254 __attribute__((__unused__)) __grow_guard(this->_M_impl, (n))
255#define _GLIBCXX_ASAN_ANNOTATE_GREW(n) __grow_guard._M_grew(n)
256#define _GLIBCXX_ASAN_ANNOTATE_SHRINK(n) \
257 _Base::_Vector_impl::template _Asan<>::_S_shrink(this->_M_impl, n)
258#define _GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC \
259 _Base::_Vector_impl::template _Asan<>::_S_on_dealloc(this->_M_impl)
260#else // ! (_GLIBCXX_SANITIZE_STD_ALLOCATOR && _GLIBCXX_SANITIZE_VECTOR)
261#define _GLIBCXX_ASAN_ANNOTATE_REINIT
262#define _GLIBCXX_ASAN_ANNOTATE_GROW(n)
263#define _GLIBCXX_ASAN_ANNOTATE_GREW(n)
264#define _GLIBCXX_ASAN_ANNOTATE_SHRINK(n)
265#define _GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC
266#endif // _GLIBCXX_SANITIZE_STD_ALLOCATOR && _GLIBCXX_SANITIZE_VECTOR
267 };
268
269 public:
270 typedef _Alloc allocator_type;
271
272 _Tp_alloc_type&
273 _M_get_Tp_allocator() _GLIBCXX_NOEXCEPT
274 { return this->_M_impl; }
275
276 const _Tp_alloc_type&
277 _M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
278 { return this->_M_impl; }
279
280 allocator_type
281 get_allocator() const _GLIBCXX_NOEXCEPT
282 { return allocator_type(_M_get_Tp_allocator()); }
283
284#if __cplusplus >= 201103L
285 _Vector_base() = default;
286#else
287 _Vector_base() { }
288#endif
289
290 _Vector_base(const allocator_type& __a) _GLIBCXX_NOEXCEPT
291 : _M_impl(__a) { }
292
293 // Kept for ABI compatibility.
294#if !_GLIBCXX_INLINE_VERSION
295 _Vector_base(size_t __n)
296 : _M_impl()
297 { _M_create_storage(__n); }
298#endif
299
300 _Vector_base(size_t __n, const allocator_type& __a)
301 : _M_impl(__a)
302 { _M_create_storage(__n); }
303
304#if __cplusplus >= 201103L
305 _Vector_base(_Vector_base&&) = default;
306
307 // Kept for ABI compatibility.
308# if !_GLIBCXX_INLINE_VERSION
309 _Vector_base(_Tp_alloc_type&& __a) noexcept
310 : _M_impl(std::move(__a)) { }
311
312 _Vector_base(_Vector_base&& __x, const allocator_type& __a)
313 : _M_impl(__a)
314 {
315 if (__x.get_allocator() == __a)
316 this->_M_impl._M_swap_data(__x._M_impl);
317 else
318 {
319 size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
320 _M_create_storage(__n);
321 }
322 }
323# endif
324
325 _Vector_base(const allocator_type& __a, _Vector_base&& __x)
326 : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl))
327 { }
328#endif
329
330 ~_Vector_base() _GLIBCXX_NOEXCEPT
331 {
332 _M_deallocate(_M_impl._M_start,
333 _M_impl._M_end_of_storage - _M_impl._M_start);
334 }
335
336 public:
337 _Vector_impl _M_impl;
338
339 pointer
340 _M_allocate(size_t __n)
341 {
342 typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
343 return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
344 }
345
346 void
347 _M_deallocate(pointer __p, size_t __n)
348 {
349 typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
350 if (__p)
351 _Tr::deallocate(_M_impl, __p, __n);
352 }
353
354 protected:
355 void
356 _M_create_storage(size_t __n)
357 {
358 this->_M_impl._M_start = this->_M_allocate(__n);
359 this->_M_impl._M_finish = this->_M_impl._M_start;
360 this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
361 }
362 };
363
364 /**
365 * @brief A standard container which offers fixed time access to
366 * individual elements in any order.
367 *
368 * @ingroup sequences
369 *
370 * @tparam _Tp Type of element.
371 * @tparam _Alloc Allocator type, defaults to allocator<_Tp>.
372 *
373 * Meets the requirements of a <a href="tables.html#65">container</a>, a
374 * <a href="tables.html#66">reversible container</a>, and a
375 * <a href="tables.html#67">sequence</a>, including the
376 * <a href="tables.html#68">optional sequence requirements</a> with the
377 * %exception of @c push_front and @c pop_front.
378 *
379 * In some terminology a %vector can be described as a dynamic
380 * C-style array, it offers fast and efficient access to individual
381 * elements in any order and saves the user from worrying about
382 * memory and size allocation. Subscripting ( @c [] ) access is
383 * also provided as with C-style arrays.
384 */
385 template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
386 class vector : protected _Vector_base<_Tp, _Alloc>
387 {
388#ifdef _GLIBCXX_CONCEPT_CHECKS
389 // Concept requirements.
390 typedef typename _Alloc::value_type _Alloc_value_type;
391# if __cplusplus < 201103L
392 __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
393# endif
394 __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)
395#endif
396
397#if __cplusplus >= 201103L
398 static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
399 "std::vector must have a non-const, non-volatile value_type");
400# ifdef __STRICT_ANSI__
401 static_assert(is_same<typename _Alloc::value_type, _Tp>::value,
402 "std::vector must have the same value_type as its allocator");
403# endif
404#endif
405
406 typedef _Vector_base<_Tp, _Alloc> _Base;
407 typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
408 typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
409
410 public:
411 typedef _Tp value_type;
412 typedef typename _Base::pointer pointer;
413 typedef typename _Alloc_traits::const_pointer const_pointer;
414 typedef typename _Alloc_traits::reference reference;
415 typedef typename _Alloc_traits::const_reference const_reference;
416 typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
417 typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
418 const_iterator;
419 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
420 typedef std::reverse_iterator<iterator> reverse_iterator;
421 typedef size_t size_type;
422 typedef ptrdiff_t difference_type;
423 typedef _Alloc allocator_type;
424
425 private:
426#if __cplusplus >= 201103L
427 static constexpr bool
428 _S_nothrow_relocate(true_type)
429 {
430 return noexcept(std::__relocate_a(std::declval<pointer>(),
431 std::declval<pointer>(),
432 std::declval<pointer>(),
433 std::declval<_Tp_alloc_type&>()));
434 }
435
436 static constexpr bool
437 _S_nothrow_relocate(false_type)
438 { return false; }
439
440 static constexpr bool
441 _S_use_relocate()
442 {
443 // Instantiating std::__relocate_a might cause an error outside the
444 // immediate context (in __relocate_object_a's noexcept-specifier),
445 // so only do it if we know the type can be move-inserted into *this.
446 return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{});
447 }
448
449 static pointer
450 _S_do_relocate(pointer __first, pointer __last, pointer __result,
451 _Tp_alloc_type& __alloc, true_type) noexcept
452 {
453 return std::__relocate_a(__first, __last, __result, __alloc);
454 }
455
456 static pointer
457 _S_do_relocate(pointer, pointer, pointer __result,
458 _Tp_alloc_type&, false_type) noexcept
459 { return __result; }
460
461 static pointer
462 _S_relocate(pointer __first, pointer __last, pointer __result,
463 _Tp_alloc_type& __alloc) noexcept
464 {
465 using __do_it = __bool_constant<_S_use_relocate()>;
466 return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
467 }
468#endif // C++11
469
470 protected:
471 using _Base::_M_allocate;
472 using _Base::_M_deallocate;
473 using _Base::_M_impl;
474 using _Base::_M_get_Tp_allocator;
475
476 public:
477 // [23.2.4.1] construct/copy/destroy
478 // (assign() and get_allocator() are also listed in this section)
479
480 /**
481 * @brief Creates a %vector with no elements.
482 */
483#if __cplusplus >= 201103L
484 vector() = default;
485#else
486 vector() { }
487#endif
488
489 /**
490 * @brief Creates a %vector with no elements.
491 * @param __a An allocator object.
492 */
493 explicit
494 vector(const allocator_type& __a) _GLIBCXX_NOEXCEPT
495 : _Base(__a) { }
496
497#if __cplusplus >= 201103L
498 /**
499 * @brief Creates a %vector with default constructed elements.
500 * @param __n The number of elements to initially create.
501 * @param __a An allocator.
502 *
503 * This constructor fills the %vector with @a __n default
504 * constructed elements.
505 */
506 explicit
507 vector(size_type __n, const allocator_type& __a = allocator_type())
508 : _Base(_S_check_init_len(__n, __a), __a)
509 { _M_default_initialize(__n); }
510
511 /**
512 * @brief Creates a %vector with copies of an exemplar element.
513 * @param __n The number of elements to initially create.
514 * @param __value An element to copy.
515 * @param __a An allocator.
516 *
517 * This constructor fills the %vector with @a __n copies of @a __value.
518 */
519 vector(size_type __n, const value_type& __value,
520 const allocator_type& __a = allocator_type())
521 : _Base(_S_check_init_len(__n, __a), __a)
522 { _M_fill_initialize(__n, __value); }
523#else
524 /**
525 * @brief Creates a %vector with copies of an exemplar element.
526 * @param __n The number of elements to initially create.
527 * @param __value An element to copy.
528 * @param __a An allocator.
529 *
530 * This constructor fills the %vector with @a __n copies of @a __value.
531 */
532 explicit
533 vector(size_type __n, const value_type& __value = value_type(),
534 const allocator_type& __a = allocator_type())
535 : _Base(_S_check_init_len(__n, __a), __a)
536 { _M_fill_initialize(__n, __value); }
537#endif
538
539 /**
540 * @brief %Vector copy constructor.
541 * @param __x A %vector of identical element and allocator types.
542 *
543 * All the elements of @a __x are copied, but any unused capacity in
544 * @a __x will not be copied
545 * (i.e. capacity() == size() in the new %vector).
546 *
547 * The newly-created %vector uses a copy of the allocator object used
548 * by @a __x (unless the allocator traits dictate a different object).
549 */
550 vector(const vector& __x)
551 : _Base(__x.size(),
552 _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
553 {
554 this->_M_impl._M_finish =
555 std::__uninitialized_copy_a(__x.begin(), __x.end(),
556 this->_M_impl._M_start,
557 _M_get_Tp_allocator());
558 }
559
560#if __cplusplus >= 201103L
561 /**
562 * @brief %Vector move constructor.
563 *
564 * The newly-created %vector contains the exact contents of the
565 * moved instance.
566 * The contents of the moved instance are a valid, but unspecified
567 * %vector.
568 */
569 vector(vector&&) noexcept = default;
570
571 /// Copy constructor with alternative allocator
572 vector(const vector& __x, const allocator_type& __a)
573 : _Base(__x.size(), __a)
574 {
575 this->_M_impl._M_finish =
576 std::__uninitialized_copy_a(__x.begin(), __x.end(),
577 this->_M_impl._M_start,
578 _M_get_Tp_allocator());
579 }
580
581 private:
582 vector(vector&& __rv, const allocator_type& __m, true_type) noexcept
583 : _Base(__m, std::move(__rv))
584 { }
585
586 vector(vector&& __rv, const allocator_type& __m, false_type)
587 : _Base(__m)
588 {
589 if (__rv.get_allocator() == __m)
590 this->_M_impl._M_swap_data(__rv._M_impl);
591 else if (!__rv.empty())
592 {
593 this->_M_create_storage(__rv.size());
594 this->_M_impl._M_finish =
595 std::__uninitialized_move_a(__rv.begin(), __rv.end(),
596 this->_M_impl._M_start,
597 _M_get_Tp_allocator());
598 __rv.clear();
599 }
600 }
601
602 public:
603 /// Move constructor with alternative allocator
604 vector(vector&& __rv, const allocator_type& __m)
605 noexcept( noexcept(
606 vector(std::declval<vector&&>(), std::declval<const allocator_type&>(),
607 std::declval<typename _Alloc_traits::is_always_equal>())) )
608 : vector(std::move(__rv), __m, typename _Alloc_traits::is_always_equal{})
609 { }
610
611 /**
612 * @brief Builds a %vector from an initializer list.
613 * @param __l An initializer_list.
614 * @param __a An allocator.
615 *
616 * Create a %vector consisting of copies of the elements in the
617 * initializer_list @a __l.
618 *
619 * This will call the element type's copy constructor N times
620 * (where N is @a __l.size()) and do no memory reallocation.
621 */
622 vector(initializer_list<value_type> __l,
623 const allocator_type& __a = allocator_type())
624 : _Base(__a)
625 {
626 _M_range_initialize(__l.begin(), __l.end(),
627 random_access_iterator_tag());
628 }
629#endif
630
631 /**
632 * @brief Builds a %vector from a range.
633 * @param __first An input iterator.
634 * @param __last An input iterator.
635 * @param __a An allocator.
636 *
637 * Create a %vector consisting of copies of the elements from
638 * [first,last).
639 *
640 * If the iterators are forward, bidirectional, or
641 * random-access, then this will call the elements' copy
642 * constructor N times (where N is distance(first,last)) and do
643 * no memory reallocation. But if only input iterators are
644 * used, then this will do at most 2N calls to the copy
645 * constructor, and logN memory reallocations.
646 */
647#if __cplusplus >= 201103L
648 template<typename _InputIterator,
649 typename = std::_RequireInputIter<_InputIterator>>
650 vector(_InputIterator __first, _InputIterator __last,
651 const allocator_type& __a = allocator_type())
652 : _Base(__a)
653 {
654 _M_range_initialize(__first, __last,
655 std::__iterator_category(__first));
656 }
657#else
658 template<typename _InputIterator>
659 vector(_InputIterator __first, _InputIterator __last,
660 const allocator_type& __a = allocator_type())
661 : _Base(__a)
662 {
663 // Check whether it's an integral type. If so, it's not an iterator.
664 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
665 _M_initialize_dispatch(__first, __last, _Integral());
666 }
667#endif
668
669 /**
670 * The dtor only erases the elements, and note that if the
671 * elements themselves are pointers, the pointed-to memory is
672 * not touched in any way. Managing the pointer is the user's
673 * responsibility.
674 */
675 ~vector() _GLIBCXX_NOEXCEPT
676 {
677 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
678 _M_get_Tp_allocator());
679 _GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC;
680 }
681
682 /**
683 * @brief %Vector assignment operator.
684 * @param __x A %vector of identical element and allocator types.
685 *
686 * All the elements of @a __x are copied, but any unused capacity in
687 * @a __x will not be copied.
688 *
689 * Whether the allocator is copied depends on the allocator traits.
690 */
691 vector&
692 operator=(const vector& __x);
693
694#if __cplusplus >= 201103L
695 /**
696 * @brief %Vector move assignment operator.
697 * @param __x A %vector of identical element and allocator types.
698 *
699 * The contents of @a __x are moved into this %vector (without copying,
700 * if the allocators permit it).
701 * Afterwards @a __x is a valid, but unspecified %vector.
702 *
703 * Whether the allocator is moved depends on the allocator traits.
704 */
705 vector&
706 operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
707 {
708 constexpr bool __move_storage =
709 _Alloc_traits::_S_propagate_on_move_assign()
710 || _Alloc_traits::_S_always_equal();
711 _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
712 return *this;
713 }
714
715 /**
716 * @brief %Vector list assignment operator.
717 * @param __l An initializer_list.
718 *
719 * This function fills a %vector with copies of the elements in the
720 * initializer list @a __l.
721 *
722 * Note that the assignment completely changes the %vector and
723 * that the resulting %vector's size is the same as the number
724 * of elements assigned.
725 */
726 vector&
727 operator=(initializer_list<value_type> __l)
728 {
729 this->_M_assign_aux(__l.begin(), __l.end(),
730 random_access_iterator_tag());
731 return *this;
732 }
733#endif
734
735 /**
736 * @brief Assigns a given value to a %vector.
737 * @param __n Number of elements to be assigned.
738 * @param __val Value to be assigned.
739 *
740 * This function fills a %vector with @a __n copies of the given
741 * value. Note that the assignment completely changes the
742 * %vector and that the resulting %vector's size is the same as
743 * the number of elements assigned.
744 */
745 void
746 assign(size_type __n, const value_type& __val)
747 { _M_fill_assign(__n, __val); }
748
749 /**
750 * @brief Assigns a range to a %vector.
751 * @param __first An input iterator.
752 * @param __last An input iterator.
753 *
754 * This function fills a %vector with copies of the elements in the
755 * range [__first,__last).
756 *
757 * Note that the assignment completely changes the %vector and
758 * that the resulting %vector's size is the same as the number
759 * of elements assigned.
760 */
761#if __cplusplus >= 201103L
762 template<typename _InputIterator,
763 typename = std::_RequireInputIter<_InputIterator>>
764 void
765 assign(_InputIterator __first, _InputIterator __last)
766 { _M_assign_dispatch(__first, __last, __false_type()); }
767#else
768 template<typename _InputIterator>
769 void
770 assign(_InputIterator __first, _InputIterator __last)
771 {
772 // Check whether it's an integral type. If so, it's not an iterator.
773 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
774 _M_assign_dispatch(__first, __last, _Integral());
775 }
776#endif
777
778#if __cplusplus >= 201103L
779 /**
780 * @brief Assigns an initializer list to a %vector.
781 * @param __l An initializer_list.
782 *
783 * This function fills a %vector with copies of the elements in the
784 * initializer list @a __l.
785 *
786 * Note that the assignment completely changes the %vector and
787 * that the resulting %vector's size is the same as the number
788 * of elements assigned.
789 */
790 void
791 assign(initializer_list<value_type> __l)
792 {
793 this->_M_assign_aux(__l.begin(), __l.end(),
794 random_access_iterator_tag());
795 }
796#endif
797
798 /// Get a copy of the memory allocation object.
799 using _Base::get_allocator;
800
801 // iterators
802 /**
803 * Returns a read/write iterator that points to the first
804 * element in the %vector. Iteration is done in ordinary
805 * element order.
806 */
807 iterator
808 begin() _GLIBCXX_NOEXCEPT
809 { return iterator(this->_M_impl._M_start); }
810
811 /**
812 * Returns a read-only (constant) iterator that points to the
813 * first element in the %vector. Iteration is done in ordinary
814 * element order.
815 */
816 const_iterator
817 begin() const _GLIBCXX_NOEXCEPT
818 { return const_iterator(this->_M_impl._M_start); }
819
820 /**
821 * Returns a read/write iterator that points one past the last
822 * element in the %vector. Iteration is done in ordinary
823 * element order.
824 */
825 iterator
826 end() _GLIBCXX_NOEXCEPT
827 { return iterator(this->_M_impl._M_finish); }
828
829 /**
830 * Returns a read-only (constant) iterator that points one past
831 * the last element in the %vector. Iteration is done in
832 * ordinary element order.
833 */
834 const_iterator
835 end() const _GLIBCXX_NOEXCEPT
836 { return const_iterator(this->_M_impl._M_finish); }
837
838 /**
839 * Returns a read/write reverse iterator that points to the
840 * last element in the %vector. Iteration is done in reverse
841 * element order.
842 */
843 reverse_iterator
844 rbegin() _GLIBCXX_NOEXCEPT
845 { return reverse_iterator(end()); }
846
847 /**
848 * Returns a read-only (constant) reverse iterator that points
849 * to the last element in the %vector. Iteration is done in
850 * reverse element order.
851 */
852 const_reverse_iterator
853 rbegin() const _GLIBCXX_NOEXCEPT
854 { return const_reverse_iterator(end()); }
855
856 /**
857 * Returns a read/write reverse iterator that points to one
858 * before the first element in the %vector. Iteration is done
859 * in reverse element order.
860 */
861 reverse_iterator
862 rend() _GLIBCXX_NOEXCEPT
863 { return reverse_iterator(begin()); }
864
865 /**
866 * Returns a read-only (constant) reverse iterator that points
867 * to one before the first element in the %vector. Iteration
868 * is done in reverse element order.
869 */
870 const_reverse_iterator
871 rend() const _GLIBCXX_NOEXCEPT
872 { return const_reverse_iterator(begin()); }
873
874#if __cplusplus >= 201103L
875 /**
876 * Returns a read-only (constant) iterator that points to the
877 * first element in the %vector. Iteration is done in ordinary
878 * element order.
879 */
880 const_iterator
881 cbegin() const noexcept
882 { return const_iterator(this->_M_impl._M_start); }
883
884 /**
885 * Returns a read-only (constant) iterator that points one past
886 * the last element in the %vector. Iteration is done in
887 * ordinary element order.
888 */
889 const_iterator
890 cend() const noexcept
891 { return const_iterator(this->_M_impl._M_finish); }
892
893 /**
894 * Returns a read-only (constant) reverse iterator that points
895 * to the last element in the %vector. Iteration is done in
896 * reverse element order.
897 */
898 const_reverse_iterator
899 crbegin() const noexcept
900 { return const_reverse_iterator(end()); }
901
902 /**
903 * Returns a read-only (constant) reverse iterator that points
904 * to one before the first element in the %vector. Iteration
905 * is done in reverse element order.
906 */
907 const_reverse_iterator
908 crend() const noexcept
909 { return const_reverse_iterator(begin()); }
910#endif
911
912 // [23.2.4.2] capacity
913 /** Returns the number of elements in the %vector. */
914 size_type
915 size() const _GLIBCXX_NOEXCEPT
916 { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
917
918 /** Returns the size() of the largest possible %vector. */
919 size_type
920 max_size() const _GLIBCXX_NOEXCEPT
921 { return _S_max_size(_M_get_Tp_allocator()); }
922
923#if __cplusplus >= 201103L
924 /**
925 * @brief Resizes the %vector to the specified number of elements.
926 * @param __new_size Number of elements the %vector should contain.
927 *
928 * This function will %resize the %vector to the specified
929 * number of elements. If the number is smaller than the
930 * %vector's current size the %vector is truncated, otherwise
931 * default constructed elements are appended.
932 */
933 void
934 resize(size_type __new_size)
935 {
936 if (__new_size > size())
937 _M_default_append(__new_size - size());
938 else if (__new_size < size())
939 _M_erase_at_end(this->_M_impl._M_start + __new_size);
940 }
941
942 /**
943 * @brief Resizes the %vector to the specified number of elements.
944 * @param __new_size Number of elements the %vector should contain.
945 * @param __x Data with which new elements should be populated.
946 *
947 * This function will %resize the %vector to the specified
948 * number of elements. If the number is smaller than the
949 * %vector's current size the %vector is truncated, otherwise
950 * the %vector is extended and new elements are populated with
951 * given data.
952 */
953 void
954 resize(size_type __new_size, const value_type& __x)
955 {
956 if (__new_size > size())
957 _M_fill_insert(end(), __new_size - size(), __x);
958 else if (__new_size < size())
959 _M_erase_at_end(this->_M_impl._M_start + __new_size);
960 }
961#else
962 /**
963 * @brief Resizes the %vector to the specified number of elements.
964 * @param __new_size Number of elements the %vector should contain.
965 * @param __x Data with which new elements should be populated.
966 *
967 * This function will %resize the %vector to the specified
968 * number of elements. If the number is smaller than the
969 * %vector's current size the %vector is truncated, otherwise
970 * the %vector is extended and new elements are populated with
971 * given data.
972 */
973 void
974 resize(size_type __new_size, value_type __x = value_type())
975 {
976 if (__new_size > size())
977 _M_fill_insert(end(), __new_size - size(), __x);
978 else if (__new_size < size())
979 _M_erase_at_end(this->_M_impl._M_start + __new_size);
980 }
981#endif
982
983#if __cplusplus >= 201103L
984 /** A non-binding request to reduce capacity() to size(). */
985 void
986 shrink_to_fit()
987 { _M_shrink_to_fit(); }
988#endif
989
990 /**
991 * Returns the total number of elements that the %vector can
992 * hold before needing to allocate more memory.
993 */
994 size_type
995 capacity() const _GLIBCXX_NOEXCEPT
996 { return size_type(this->_M_impl._M_end_of_storage
997 - this->_M_impl._M_start); }
998
999 /**
1000 * Returns true if the %vector is empty. (Thus begin() would
1001 * equal end().)
1002 */
1003 _GLIBCXX_NODISCARD bool
1004 empty() const _GLIBCXX_NOEXCEPT
1005 { return begin() == end(); }
1006
1007 /**
1008 * @brief Attempt to preallocate enough memory for specified number of
1009 * elements.
1010 * @param __n Number of elements required.
1011 * @throw std::length_error If @a n exceeds @c max_size().
1012 *
1013 * This function attempts to reserve enough memory for the
1014 * %vector to hold the specified number of elements. If the
1015 * number requested is more than max_size(), length_error is
1016 * thrown.
1017 *
1018 * The advantage of this function is that if optimal code is a
1019 * necessity and the user can determine the number of elements
1020 * that will be required, the user can reserve the memory in
1021 * %advance, and thus prevent a possible reallocation of memory
1022 * and copying of %vector data.
1023 */
1024 void
1025 reserve(size_type __n);
1026
1027 // element access
1028 /**
1029 * @brief Subscript access to the data contained in the %vector.
1030 * @param __n The index of the element for which data should be
1031 * accessed.
1032 * @return Read/write reference to data.
1033 *
1034 * This operator allows for easy, array-style, data access.
1035 * Note that data access with this operator is unchecked and
1036 * out_of_range lookups are not defined. (For checked lookups
1037 * see at().)
1038 */
1039 reference
1040 operator[](size_type __n) _GLIBCXX_NOEXCEPT
1041 {
1042 __glibcxx_requires_subscript(__n);
1043 return *(this->_M_impl._M_start + __n);
1044 }
1045
1046 /**
1047 * @brief Subscript access to the data contained in the %vector.
1048 * @param __n The index of the element for which data should be
1049 * accessed.
1050 * @return Read-only (constant) reference to data.
1051 *
1052 * This operator allows for easy, array-style, data access.
1053 * Note that data access with this operator is unchecked and
1054 * out_of_range lookups are not defined. (For checked lookups
1055 * see at().)
1056 */
1057 const_reference
1058 operator[](size_type __n) const _GLIBCXX_NOEXCEPT
1059 {
1060 __glibcxx_requires_subscript(__n);
1061 return *(this->_M_impl._M_start + __n);
1062 }
1063
1064 protected:
1065 /// Safety check used only from at().
1066 void
1067 _M_range_check(size_type __n) const
1068 {
1069 if (__n >= this->size())
1070 __throw_out_of_range_fmt(__N("vector::_M_range_check: __n "
1071 "(which is %zu) >= this->size() "
1072 "(which is %zu)"),
1073 __n, this->size());
1074 }
1075
1076 public:
1077 /**
1078 * @brief Provides access to the data contained in the %vector.
1079 * @param __n The index of the element for which data should be
1080 * accessed.
1081 * @return Read/write reference to data.
1082 * @throw std::out_of_range If @a __n is an invalid index.
1083 *
1084 * This function provides for safer data access. The parameter
1085 * is first checked that it is in the range of the vector. The
1086 * function throws out_of_range if the check fails.
1087 */
1088 reference
1089 at(size_type __n)
1090 {
1091 _M_range_check(__n);
1092 return (*this)[__n];
1093 }
1094
1095 /**
1096 * @brief Provides access to the data contained in the %vector.
1097 * @param __n The index of the element for which data should be
1098 * accessed.
1099 * @return Read-only (constant) reference to data.
1100 * @throw std::out_of_range If @a __n is an invalid index.
1101 *
1102 * This function provides for safer data access. The parameter
1103 * is first checked that it is in the range of the vector. The
1104 * function throws out_of_range if the check fails.
1105 */
1106 const_reference
1107 at(size_type __n) const
1108 {
1109 _M_range_check(__n);
1110 return (*this)[__n];
1111 }
1112
1113 /**
1114 * Returns a read/write reference to the data at the first
1115 * element of the %vector.
1116 */
1117 reference
1118 front() _GLIBCXX_NOEXCEPT
1119 {
1120 __glibcxx_requires_nonempty();
1121 return *begin();
1122 }
1123
1124 /**
1125 * Returns a read-only (constant) reference to the data at the first
1126 * element of the %vector.
1127 */
1128 const_reference
1129 front() const _GLIBCXX_NOEXCEPT
1130 {
1131 __glibcxx_requires_nonempty();
1132 return *begin();
1133 }
1134
1135 /**
1136 * Returns a read/write reference to the data at the last
1137 * element of the %vector.
1138 */
1139 reference
1140 back() _GLIBCXX_NOEXCEPT
1141 {
1142 __glibcxx_requires_nonempty();
1143 return *(end() - 1);
1144 }
1145
1146 /**
1147 * Returns a read-only (constant) reference to the data at the
1148 * last element of the %vector.
1149 */
1150 const_reference
1151 back() const _GLIBCXX_NOEXCEPT
1152 {
1153 __glibcxx_requires_nonempty();
1154 return *(end() - 1);
1155 }
1156
1157 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1158 // DR 464. Suggestion for new member functions in standard containers.
1159 // data access
1160 /**
1161 * Returns a pointer such that [data(), data() + size()) is a valid
1162 * range. For a non-empty %vector, data() == &front().
1163 */
1164 _Tp*
1165 data() _GLIBCXX_NOEXCEPT
1166 { return _M_data_ptr(this->_M_impl._M_start); }
1167
1168 const _Tp*
1169 data() const _GLIBCXX_NOEXCEPT
1170 { return _M_data_ptr(this->_M_impl._M_start); }
1171
1172 // [23.2.4.3] modifiers
1173 /**
1174 * @brief Add data to the end of the %vector.
1175 * @param __x Data to be added.
1176 *
1177 * This is a typical stack operation. The function creates an
1178 * element at the end of the %vector and assigns the given data
1179 * to it. Due to the nature of a %vector this operation can be
1180 * done in constant time if the %vector has preallocated space
1181 * available.
1182 */
1183 void
1184 push_back(const value_type& __x)
1185 {
1186 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
1187 {
1188 _GLIBCXX_ASAN_ANNOTATE_GROW(1);
1189 _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
1190 __x);
1191 ++this->_M_impl._M_finish;
1192 _GLIBCXX_ASAN_ANNOTATE_GREW(1);
1193 }
1194 else
1195 _M_realloc_insert(end(), __x);
1196 }
1197
1198#if __cplusplus >= 201103L
1199 void
1200 push_back(value_type&& __x)
1201 { emplace_back(std::move(__x)); }
1202
1203 template<typename... _Args>
1204#if __cplusplus > 201402L
1205 reference
1206#else
1207 void
1208#endif
1209 emplace_back(_Args&&... __args);
1210#endif
1211
1212 /**
1213 * @brief Removes last element.
1214 *
1215 * This is a typical stack operation. It shrinks the %vector by one.
1216 *
1217 * Note that no data is returned, and if the last element's
1218 * data is needed, it should be retrieved before pop_back() is
1219 * called.
1220 */
1221 void
1222 pop_back() _GLIBCXX_NOEXCEPT
1223 {
1224 __glibcxx_requires_nonempty();
1225 --this->_M_impl._M_finish;
1226 _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
1227 _GLIBCXX_ASAN_ANNOTATE_SHRINK(1);
1228 }
1229
1230#if __cplusplus >= 201103L
1231 /**
1232 * @brief Inserts an object in %vector before specified iterator.
1233 * @param __position A const_iterator into the %vector.
1234 * @param __args Arguments.
1235 * @return An iterator that points to the inserted data.
1236 *
1237 * This function will insert an object of type T constructed
1238 * with T(std::forward<Args>(args)...) before the specified location.
1239 * Note that this kind of operation could be expensive for a %vector
1240 * and if it is frequently used the user should consider using
1241 * std::list.
1242 */
1243 template<typename... _Args>
1244 iterator
1245 emplace(const_iterator __position, _Args&&... __args)
1246 { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); }
1247
1248 /**
1249 * @brief Inserts given value into %vector before specified iterator.
1250 * @param __position A const_iterator into the %vector.
1251 * @param __x Data to be inserted.
1252 * @return An iterator that points to the inserted data.
1253 *
1254 * This function will insert a copy of the given value before
1255 * the specified location. Note that this kind of operation
1256 * could be expensive for a %vector and if it is frequently
1257 * used the user should consider using std::list.
1258 */
1259 iterator
1260 insert(const_iterator __position, const value_type& __x);
1261#else
1262 /**
1263 * @brief Inserts given value into %vector before specified iterator.
1264 * @param __position An iterator into the %vector.
1265 * @param __x Data to be inserted.
1266 * @return An iterator that points to the inserted data.
1267 *
1268 * This function will insert a copy of the given value before
1269 * the specified location. Note that this kind of operation
1270 * could be expensive for a %vector and if it is frequently
1271 * used the user should consider using std::list.
1272 */
1273 iterator
1274 insert(iterator __position, const value_type& __x);
1275#endif
1276
1277#if __cplusplus >= 201103L
1278 /**
1279 * @brief Inserts given rvalue into %vector before specified iterator.
1280 * @param __position A const_iterator into the %vector.
1281 * @param __x Data to be inserted.
1282 * @return An iterator that points to the inserted data.
1283 *
1284 * This function will insert a copy of the given rvalue before
1285 * the specified location. Note that this kind of operation
1286 * could be expensive for a %vector and if it is frequently
1287 * used the user should consider using std::list.
1288 */
1289 iterator
1290 insert(const_iterator __position, value_type&& __x)
1291 { return _M_insert_rval(__position, std::move(__x)); }
1292
1293 /**
1294 * @brief Inserts an initializer_list into the %vector.
1295 * @param __position An iterator into the %vector.
1296 * @param __l An initializer_list.
1297 *
1298 * This function will insert copies of the data in the
1299 * initializer_list @a l into the %vector before the location
1300 * specified by @a position.
1301 *
1302 * Note that this kind of operation could be expensive for a
1303 * %vector and if it is frequently used the user should
1304 * consider using std::list.
1305 */
1306 iterator
1307 insert(const_iterator __position, initializer_list<value_type> __l)
1308 {
1309 auto __offset = __position - cbegin();
1310 _M_range_insert(begin() + __offset, __l.begin(), __l.end(),
1311 std::random_access_iterator_tag());
1312 return begin() + __offset;
1313 }
1314#endif
1315
1316#if __cplusplus >= 201103L
1317 /**
1318 * @brief Inserts a number of copies of given data into the %vector.
1319 * @param __position A const_iterator into the %vector.
1320 * @param __n Number of elements to be inserted.
1321 * @param __x Data to be inserted.
1322 * @return An iterator that points to the inserted data.
1323 *
1324 * This function will insert a specified number of copies of
1325 * the given data before the location specified by @a position.
1326 *
1327 * Note that this kind of operation could be expensive for a
1328 * %vector and if it is frequently used the user should
1329 * consider using std::list.
1330 */
1331 iterator
1332 insert(const_iterator __position, size_type __n, const value_type& __x)
1333 {
1334 difference_type __offset = __position - cbegin();
1335 _M_fill_insert(begin() + __offset, __n, __x);
1336 return begin() + __offset;
1337 }
1338#else
1339 /**
1340 * @brief Inserts a number of copies of given data into the %vector.
1341 * @param __position An iterator into the %vector.
1342 * @param __n Number of elements to be inserted.
1343 * @param __x Data to be inserted.
1344 *
1345 * This function will insert a specified number of copies of
1346 * the given data before the location specified by @a position.
1347 *
1348 * Note that this kind of operation could be expensive for a
1349 * %vector and if it is frequently used the user should
1350 * consider using std::list.
1351 */
1352 void
1353 insert(iterator __position, size_type __n, const value_type& __x)
1354 { _M_fill_insert(__position, __n, __x); }
1355#endif
1356
1357#if __cplusplus >= 201103L
1358 /**
1359 * @brief Inserts a range into the %vector.
1360 * @param __position A const_iterator into the %vector.
1361 * @param __first An input iterator.
1362 * @param __last An input iterator.
1363 * @return An iterator that points to the inserted data.
1364 *
1365 * This function will insert copies of the data in the range
1366 * [__first,__last) into the %vector before the location specified
1367 * by @a pos.
1368 *
1369 * Note that this kind of operation could be expensive for a
1370 * %vector and if it is frequently used the user should
1371 * consider using std::list.
1372 */
1373 template<typename _InputIterator,
1374 typename = std::_RequireInputIter<_InputIterator>>
1375 iterator
1376 insert(const_iterator __position, _InputIterator __first,
1377 _InputIterator __last)
1378 {
1379 difference_type __offset = __position - cbegin();
1380 _M_insert_dispatch(begin() + __offset,
1381 __first, __last, __false_type());
1382 return begin() + __offset;
1383 }
1384#else
1385 /**
1386 * @brief Inserts a range into the %vector.
1387 * @param __position An iterator into the %vector.
1388 * @param __first An input iterator.
1389 * @param __last An input iterator.
1390 *
1391 * This function will insert copies of the data in the range
1392 * [__first,__last) into the %vector before the location specified
1393 * by @a pos.
1394 *
1395 * Note that this kind of operation could be expensive for a
1396 * %vector and if it is frequently used the user should
1397 * consider using std::list.
1398 */
1399 template<typename _InputIterator>
1400 void
1401 insert(iterator __position, _InputIterator __first,
1402 _InputIterator __last)
1403 {
1404 // Check whether it's an integral type. If so, it's not an iterator.
1405 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
1406 _M_insert_dispatch(__position, __first, __last, _Integral());
1407 }
1408#endif
1409
1410 /**
1411 * @brief Remove element at given position.
1412 * @param __position Iterator pointing to element to be erased.
1413 * @return An iterator pointing to the next element (or end()).
1414 *
1415 * This function will erase the element at the given position and thus
1416 * shorten the %vector by one.
1417 *
1418 * Note This operation could be expensive and if it is
1419 * frequently used the user should consider using std::list.
1420 * The user is also cautioned that this function only erases
1421 * the element, and that if the element is itself a pointer,
1422 * the pointed-to memory is not touched in any way. Managing
1423 * the pointer is the user's responsibility.
1424 */
1425 iterator
1426#if __cplusplus >= 201103L
1427 erase(const_iterator __position)
1428 { return _M_erase(begin() + (__position - cbegin())); }
1429#else
1430 erase(iterator __position)
1431 { return _M_erase(__position); }
1432#endif
1433
1434 /**
1435 * @brief Remove a range of elements.
1436 * @param __first Iterator pointing to the first element to be erased.
1437 * @param __last Iterator pointing to one past the last element to be
1438 * erased.
1439 * @return An iterator pointing to the element pointed to by @a __last
1440 * prior to erasing (or end()).
1441 *
1442 * This function will erase the elements in the range
1443 * [__first,__last) and shorten the %vector accordingly.
1444 *
1445 * Note This operation could be expensive and if it is
1446 * frequently used the user should consider using std::list.
1447 * The user is also cautioned that this function only erases
1448 * the elements, and that if the elements themselves are
1449 * pointers, the pointed-to memory is not touched in any way.
1450 * Managing the pointer is the user's responsibility.
1451 */
1452 iterator
1453#if __cplusplus >= 201103L
1454 erase(const_iterator __first, const_iterator __last)
1455 {
1456 const auto __beg = begin();
1457 const auto __cbeg = cbegin();
1458 return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
1459 }
1460#else
1461 erase(iterator __first, iterator __last)
1462 { return _M_erase(__first, __last); }
1463#endif
1464
1465 /**
1466 * @brief Swaps data with another %vector.
1467 * @param __x A %vector of the same element and allocator types.
1468 *
1469 * This exchanges the elements between two vectors in constant time.
1470 * (Three pointers, so it should be quite fast.)
1471 * Note that the global std::swap() function is specialized such that
1472 * std::swap(v1,v2) will feed to this function.
1473 *
1474 * Whether the allocators are swapped depends on the allocator traits.
1475 */
1476 void
1477 swap(vector& __x) _GLIBCXX_NOEXCEPT
1478 {
1479#if __cplusplus >= 201103L
1480 __glibcxx_assert(_Alloc_traits::propagate_on_container_swap::value
1481 || _M_get_Tp_allocator() == __x._M_get_Tp_allocator());
1482#endif
1483 this->_M_impl._M_swap_data(__x._M_impl);
1484 _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
1485 __x._M_get_Tp_allocator());
1486 }
1487
1488 /**
1489 * Erases all the elements. Note that this function only erases the
1490 * elements, and that if the elements themselves are pointers, the
1491 * pointed-to memory is not touched in any way. Managing the pointer is
1492 * the user's responsibility.
1493 */
1494 void
1495 clear() _GLIBCXX_NOEXCEPT
1496 { _M_erase_at_end(this->_M_impl._M_start); }
1497
1498 protected:
1499 /**
1500 * Memory expansion handler. Uses the member allocation function to
1501 * obtain @a n bytes of memory, and then copies [first,last) into it.
1502 */
1503 template<typename _ForwardIterator>
1504 pointer
1505 _M_allocate_and_copy(size_type __n,
1506 _ForwardIterator __first, _ForwardIterator __last)
1507 {
1508 pointer __result = this->_M_allocate(__n);
1509 __try
1510 {
1511 std::__uninitialized_copy_a(__first, __last, __result,
1512 _M_get_Tp_allocator());
1513 return __result;
1514 }
1515 __catch(...)
1516 {
1517 _M_deallocate(__result, __n);
1518 __throw_exception_again;
1519 }
1520 }
1521
1522
1523 // Internal constructor functions follow.
1524
1525 // Called by the range constructor to implement [23.1.1]/9
1526
1527#if __cplusplus < 201103L
1528 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1529 // 438. Ambiguity in the "do the right thing" clause
1530 template<typename _Integer>
1531 void
1532 _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
1533 {
1534 this->_M_impl._M_start = _M_allocate(_S_check_init_len(
1535 static_cast<size_type>(__n), _M_get_Tp_allocator()));
1536 this->_M_impl._M_end_of_storage =
1537 this->_M_impl._M_start + static_cast<size_type>(__n);
1538 _M_fill_initialize(static_cast<size_type>(__n), __value);
1539 }
1540
1541 // Called by the range constructor to implement [23.1.1]/9
1542 template<typename _InputIterator>
1543 void
1544 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1545 __false_type)
1546 {
1547 _M_range_initialize(__first, __last,
1548 std::__iterator_category(__first));
1549 }
1550#endif
1551
1552 // Called by the second initialize_dispatch above
1553 template<typename _InputIterator>
1554 void
1555 _M_range_initialize(_InputIterator __first, _InputIterator __last,
1556 std::input_iterator_tag)
1557 {
1558 __try {
1559 for (; __first != __last; ++__first)
1560#if __cplusplus >= 201103L
1561 emplace_back(*__first);
1562#else
1563 push_back(*__first);
1564#endif
1565 } __catch(...) {
1566 clear();
1567 __throw_exception_again;
1568 }
1569 }
1570
1571 // Called by the second initialize_dispatch above
1572 template<typename _ForwardIterator>
1573 void
1574 _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
1575 std::forward_iterator_tag)
1576 {
1577 const size_type __n = std::distance(__first, __last);
1578 this->_M_impl._M_start
1579 = this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator()));
1580 this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
1581 this->_M_impl._M_finish =
1582 std::__uninitialized_copy_a(__first, __last,
1583 this->_M_impl._M_start,
1584 _M_get_Tp_allocator());
1585 }
1586
1587 // Called by the first initialize_dispatch above and by the
1588 // vector(n,value,a) constructor.
1589 void
1590 _M_fill_initialize(size_type __n, const value_type& __value)
1591 {
1592 this->_M_impl._M_finish =
1593 std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
1594 _M_get_Tp_allocator());
1595 }
1596
1597#if __cplusplus >= 201103L
1598 // Called by the vector(n) constructor.
1599 void
1600 _M_default_initialize(size_type __n)
1601 {
1602 this->_M_impl._M_finish =
1603 std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
1604 _M_get_Tp_allocator());
1605 }
1606#endif
1607
1608 // Internal assign functions follow. The *_aux functions do the actual
1609 // assignment work for the range versions.
1610
1611 // Called by the range assign to implement [23.1.1]/9
1612
1613 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1614 // 438. Ambiguity in the "do the right thing" clause
1615 template<typename _Integer>
1616 void
1617 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
1618 { _M_fill_assign(__n, __val); }
1619
1620 // Called by the range assign to implement [23.1.1]/9
1621 template<typename _InputIterator>
1622 void
1623 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
1624 __false_type)
1625 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
1626
1627 // Called by the second assign_dispatch above
1628 template<typename _InputIterator>
1629 void
1630 _M_assign_aux(_InputIterator __first, _InputIterator __last,
1631 std::input_iterator_tag);
1632
1633 // Called by the second assign_dispatch above
1634 template<typename _ForwardIterator>
1635 void
1636 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1637 std::forward_iterator_tag);
1638
1639 // Called by assign(n,t), and the range assign when it turns out
1640 // to be the same thing.
1641 void
1642 _M_fill_assign(size_type __n, const value_type& __val);
1643
1644 // Internal insert functions follow.
1645
1646 // Called by the range insert to implement [23.1.1]/9
1647
1648 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1649 // 438. Ambiguity in the "do the right thing" clause
1650 template<typename _Integer>
1651 void
1652 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
1653 __true_type)
1654 { _M_fill_insert(__pos, __n, __val); }
1655
1656 // Called by the range insert to implement [23.1.1]/9
1657 template<typename _InputIterator>
1658 void
1659 _M_insert_dispatch(iterator __pos, _InputIterator __first,
1660 _InputIterator __last, __false_type)
1661 {
1662 _M_range_insert(__pos, __first, __last,
1663 std::__iterator_category(__first));
1664 }
1665
1666 // Called by the second insert_dispatch above
1667 template<typename _InputIterator>
1668 void
1669 _M_range_insert(iterator __pos, _InputIterator __first,
1670 _InputIterator __last, std::input_iterator_tag);
1671
1672 // Called by the second insert_dispatch above
1673 template<typename _ForwardIterator>
1674 void
1675 _M_range_insert(iterator __pos, _ForwardIterator __first,
1676 _ForwardIterator __last, std::forward_iterator_tag);
1677
1678 // Called by insert(p,n,x), and the range insert when it turns out to be
1679 // the same thing.
1680 void
1681 _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
1682
1683#if __cplusplus >= 201103L
1684 // Called by resize(n).
1685 void
1686 _M_default_append(size_type __n);
1687
1688 bool
1689 _M_shrink_to_fit();
1690#endif
1691
1692#if __cplusplus < 201103L
1693 // Called by insert(p,x)
1694 void
1695 _M_insert_aux(iterator __position, const value_type& __x);
1696
1697 void
1698 _M_realloc_insert(iterator __position, const value_type& __x);
1699#else
1700 // A value_type object constructed with _Alloc_traits::construct()
1701 // and destroyed with _Alloc_traits::destroy().
1702 struct _Temporary_value
1703 {
1704 template<typename... _Args>
1705 explicit
1706 _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec)
1707 {
1708 _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(),
1709 std::forward<_Args>(__args)...);
1710 }
1711
1712 ~_Temporary_value()
1713 { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); }
1714
1715 value_type&
1716 _M_val() { return *_M_ptr(); }
1717
1718 private:
1719 _Tp*
1720 _M_ptr() { return reinterpret_cast<_Tp*>(&__buf); }
1721
1722 vector* _M_this;
1723 typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __buf;
1724 };
1725
1726 // Called by insert(p,x) and other functions when insertion needs to
1727 // reallocate or move existing elements. _Arg is either _Tp& or _Tp.
1728 template<typename _Arg>
1729 void
1730 _M_insert_aux(iterator __position, _Arg&& __arg);
1731
1732 template<typename... _Args>
1733 void
1734 _M_realloc_insert(iterator __position, _Args&&... __args);
1735
1736 // Either move-construct at the end, or forward to _M_insert_aux.
1737 iterator
1738 _M_insert_rval(const_iterator __position, value_type&& __v);
1739
1740 // Try to emplace at the end, otherwise forward to _M_insert_aux.
1741 template<typename... _Args>
1742 iterator
1743 _M_emplace_aux(const_iterator __position, _Args&&... __args);
1744
1745 // Emplacing an rvalue of the correct type can use _M_insert_rval.
1746 iterator
1747 _M_emplace_aux(const_iterator __position, value_type&& __v)
1748 { return _M_insert_rval(__position, std::move(__v)); }
1749#endif
1750
1751 // Called by _M_fill_insert, _M_insert_aux etc.
1752 size_type
1753 _M_check_len(size_type __n, const char* __s) const
1754 {
1755 if (max_size() - size() < __n)
1756 __throw_length_error(__N(__s));
1757
1758 const size_type __len = size() + (std::max)(size(), __n);
1759 return (__len < size() || __len > max_size()) ? max_size() : __len;
1760 }
1761
1762 // Called by constructors to check initial size.
1763 static size_type
1764 _S_check_init_len(size_type __n, const allocator_type& __a)
1765 {
1766 if (__n > _S_max_size(_Tp_alloc_type(__a)))
1767 __throw_length_error(
1768 __N("cannot create std::vector larger than max_size()"));
1769 return __n;
1770 }
1771
1772 static size_type
1773 _S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
1774 {
1775 // std::distance(begin(), end()) cannot be greater than PTRDIFF_MAX,
1776 // and realistically we can't store more than PTRDIFF_MAX/sizeof(T)
1777 // (even if std::allocator_traits::max_size says we can).
1778 const size_t __diffmax
1779 = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
1780 const size_t __allocmax = _Alloc_traits::max_size(__a);
1781 return (std::min)(__diffmax, __allocmax);
1782 }
1783
1784 // Internal erase functions follow.
1785
1786 // Called by erase(q1,q2), clear(), resize(), _M_fill_assign,
1787 // _M_assign_aux.
1788 void
1789 _M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
1790 {
1791 if (size_type __n = this->_M_impl._M_finish - __pos)
1792 {
1793 std::_Destroy(__pos, this->_M_impl._M_finish,
1794 _M_get_Tp_allocator());
1795 this->_M_impl._M_finish = __pos;
1796 _GLIBCXX_ASAN_ANNOTATE_SHRINK(__n);
1797 }
1798 }
1799
1800 iterator
1801 _M_erase(iterator __position);
1802
1803 iterator
1804 _M_erase(iterator __first, iterator __last);
1805
1806#if __cplusplus >= 201103L
1807 private:
1808 // Constant-time move assignment when source object's memory can be
1809 // moved, either because the source's allocator will move too
1810 // or because the allocators are equal.
1811 void
1812 _M_move_assign(vector&& __x, true_type) noexcept
1813 {
1814 vector __tmp(get_allocator());
1815 this->_M_impl._M_swap_data(__x._M_impl);
1816 __tmp._M_impl._M_swap_data(__x._M_impl);
1817 std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
1818 }
1819
1820 // Do move assignment when it might not be possible to move source
1821 // object's memory, resulting in a linear-time operation.
1822 void
1823 _M_move_assign(vector&& __x, false_type)
1824 {
1825 if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
1826 _M_move_assign(std::move(__x), true_type());
1827 else
1828 {
1829 // The rvalue's allocator cannot be moved and is not equal,
1830 // so we need to individually move each element.
1831 this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
1832 std::__make_move_if_noexcept_iterator(__x.end()));
1833 __x.clear();
1834 }
1835 }
1836#endif
1837
1838 template<typename _Up>
1839 _Up*
1840 _M_data_ptr(_Up* __ptr) const _GLIBCXX_NOEXCEPT
1841 { return __ptr; }
1842
1843#if __cplusplus >= 201103L
1844 template<typename _Ptr>
1845 typename std::pointer_traits<_Ptr>::element_type*
1846 _M_data_ptr(_Ptr __ptr) const
1847 { return empty() ? nullptr : std::__to_address(__ptr); }
1848#else
1849 template<typename _Up>
1850 _Up*
1851 _M_data_ptr(_Up* __ptr) _GLIBCXX_NOEXCEPT
1852 { return __ptr; }
1853
1854 template<typename _Ptr>
1855 value_type*
1856 _M_data_ptr(_Ptr __ptr)
1857 { return empty() ? (value_type*)0 : __ptr.operator->(); }
1858
1859 template<typename _Ptr>
1860 const value_type*
1861 _M_data_ptr(_Ptr __ptr) const
1862 { return empty() ? (const value_type*)0 : __ptr.operator->(); }
1863#endif
1864 };
1865
1866#if __cpp_deduction_guides >= 201606
1867 template<typename _InputIterator, typename _ValT
1868 = typename iterator_traits<_InputIterator>::value_type,
1869 typename _Allocator = allocator<_ValT>,
1870 typename = _RequireInputIter<_InputIterator>,
1871 typename = _RequireAllocator<_Allocator>>
1872 vector(_InputIterator, _InputIterator, _Allocator = _Allocator())
1873 -> vector<_ValT, _Allocator>;
1874#endif
1875
1876 /**
1877 * @brief Vector equality comparison.
1878 * @param __x A %vector.
1879 * @param __y A %vector of the same type as @a __x.
1880 * @return True iff the size and elements of the vectors are equal.
1881 *
1882 * This is an equivalence relation. It is linear in the size of the
1883 * vectors. Vectors are considered equivalent if their sizes are equal,
1884 * and if corresponding elements compare equal.
1885 */
1886 template<typename _Tp, typename _Alloc>
1887 inline bool
1888 operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1889 { return (__x.size() == __y.size()
1890 && std::equal(__x.begin(), __x.end(), __y.begin())); }
1891
1892 /**
1893 * @brief Vector ordering relation.
1894 * @param __x A %vector.
1895 * @param __y A %vector of the same type as @a __x.
1896 * @return True iff @a __x is lexicographically less than @a __y.
1897 *
1898 * This is a total ordering relation. It is linear in the size of the
1899 * vectors. The elements must be comparable with @c <.
1900 *
1901 * See std::lexicographical_compare() for how the determination is made.
1902 */
1903 template<typename _Tp, typename _Alloc>
1904 inline bool
1905 operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1906 { return std::lexicographical_compare(__x.begin(), __x.end(),
1907 __y.begin(), __y.end()); }
1908
1909 /// Based on operator==
1910 template<typename _Tp, typename _Alloc>
1911 inline bool
1912 operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1913 { return !(__x == __y); }
1914
1915 /// Based on operator<
1916 template<typename _Tp, typename _Alloc>
1917 inline bool
1918 operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1919 { return __y < __x; }
1920
1921 /// Based on operator<
1922 template<typename _Tp, typename _Alloc>
1923 inline bool
1924 operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1925 { return !(__y < __x); }
1926
1927 /// Based on operator<
1928 template<typename _Tp, typename _Alloc>
1929 inline bool
1930 operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1931 { return !(__x < __y); }
1932
1933 /// See std::vector::swap().
1934 template<typename _Tp, typename _Alloc>
1935 inline void
1936 swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
1937 _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
1938 { __x.swap(__y); }
1939
1940_GLIBCXX_END_NAMESPACE_CONTAINER
1941
1942#if __cplusplus >= 201703L
1943 namespace __detail::__variant
1944 {
1945 template<typename> struct _Never_valueless_alt; // see <variant>
1946
1947 // Provide the strong exception-safety guarantee when emplacing a
1948 // vector into a variant, but only if move assignment cannot throw.
1949 template<typename _Tp, typename _Alloc>
1950 struct _Never_valueless_alt<_GLIBCXX_STD_C::vector<_Tp, _Alloc>>
1951 : std::is_nothrow_move_assignable<_GLIBCXX_STD_C::vector<_Tp, _Alloc>>
1952 { };
1953 } // namespace __detail::__variant
1954#endif // C++17
1955
1956_GLIBCXX_END_NAMESPACE_VERSION
1957} // namespace std
1958
1959#endif /* _STL_VECTOR_H */
1960

source code of include/c++/9/bits/stl_vector.h