1 : // Vector implementation -*- C++ -*-
2 :
3 : // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 : // Free Software Foundation, Inc.
5 : //
6 : // This file is part of the GNU ISO C++ Library. This library is free
7 : // software; you can redistribute it and/or modify it under the
8 : // terms of the GNU General Public License as published by the
9 : // Free Software Foundation; either version 2, or (at your option)
10 : // any later version.
11 :
12 : // This library is distributed in the hope that it will be useful,
13 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : // GNU General Public License for more details.
16 :
17 : // You should have received a copy of the GNU General Public License along
18 : // with this library; see the file COPYING. If not, write to the Free
19 : // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20 : // USA.
21 :
22 : // As a special exception, you may use this file as part of a free software
23 : // library without restriction. Specifically, if other files instantiate
24 : // templates or use macros or inline functions from this file, or you compile
25 : // this file and link it with other files to produce an executable, this
26 : // file does not by itself cause the resulting executable to be covered by
27 : // the GNU General Public License. This exception does not however
28 : // invalidate any other reasons why the executable file might be covered by
29 : // the GNU General Public License.
30 :
31 : /*
32 : *
33 : * Copyright (c) 1994
34 : * Hewlett-Packard Company
35 : *
36 : * Permission to use, copy, modify, distribute and sell this software
37 : * and its documentation for any purpose is hereby granted without fee,
38 : * provided that the above copyright notice appear in all copies and
39 : * that both that copyright notice and this permission notice appear
40 : * in supporting documentation. Hewlett-Packard Company makes no
41 : * representations about the suitability of this software for any
42 : * purpose. It is provided "as is" without express or implied warranty.
43 : *
44 : *
45 : * Copyright (c) 1996
46 : * Silicon Graphics Computer Systems, Inc.
47 : *
48 : * Permission to use, copy, modify, distribute and sell this software
49 : * and its documentation for any purpose is hereby granted without fee,
50 : * provided that the above copyright notice appear in all copies and
51 : * that both that copyright notice and this permission notice appear
52 : * in supporting documentation. Silicon Graphics makes no
53 : * representations about the suitability of this software for any
54 : * purpose. It is provided "as is" without express or implied warranty.
55 : */
56 :
57 : /** @file stl_vector.h
58 : * This is an internal header file, included by other library headers.
59 : * You should not attempt to use it directly.
60 : */
61 :
62 : #ifndef _STL_VECTOR_H
63 : #define _STL_VECTOR_H 1
64 :
65 : #include <bits/stl_iterator_base_funcs.h>
66 : #include <bits/functexcept.h>
67 : #include <bits/concept_check.h>
68 :
69 : _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
70 :
71 : /// See bits/stl_deque.h's _Deque_base for an explanation.
72 : template<typename _Tp, typename _Alloc>
73 : struct _Vector_base
74 : {
75 : typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
76 :
77 : struct _Vector_impl
78 : : public _Tp_alloc_type
79 4841 : {
80 : _Tp* _M_start;
81 : _Tp* _M_finish;
82 : _Tp* _M_end_of_storage;
83 :
84 4840 : _Vector_impl()
85 4840 : : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
86 4840 : { }
87 :
88 9 : _Vector_impl(_Tp_alloc_type const& __a)
89 9 : : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
90 9 : { }
91 : };
92 :
93 : public:
94 : typedef _Alloc allocator_type;
95 :
96 : _Tp_alloc_type&
97 119679 : _M_get_Tp_allocator()
98 119679 : { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
99 :
100 : const _Tp_alloc_type&
101 41426 : _M_get_Tp_allocator() const
102 41426 : { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
103 :
104 : allocator_type
105 : get_allocator() const
106 : { return allocator_type(_M_get_Tp_allocator()); }
107 :
108 4840 : _Vector_base()
109 4840 : : _M_impl() { }
110 :
111 : _Vector_base(const allocator_type& __a)
112 : : _M_impl(__a) { }
113 :
114 9 : _Vector_base(size_t __n, const allocator_type& __a)
115 9 : : _M_impl(__a)
116 : {
117 9 : this->_M_impl._M_start = this->_M_allocate(__n);
118 9 : this->_M_impl._M_finish = this->_M_impl._M_start;
119 9 : this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
120 9 : }
121 :
122 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
123 : _Vector_base(_Vector_base&& __x)
124 : : _M_impl(__x._M_get_Tp_allocator())
125 : {
126 : this->_M_impl._M_start = __x._M_impl._M_start;
127 : this->_M_impl._M_finish = __x._M_impl._M_finish;
128 : this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
129 : __x._M_impl._M_start = 0;
130 : __x._M_impl._M_finish = 0;
131 : __x._M_impl._M_end_of_storage = 0;
132 : }
133 : #endif
134 :
135 4841 : ~_Vector_base()
136 4841 : { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
137 4841 : - this->_M_impl._M_start); }
138 :
139 : public:
140 : _Vector_impl _M_impl;
141 :
142 : _Tp*
143 20727 : _M_allocate(size_t __n)
144 20727 : { return __n != 0 ? _M_impl.allocate(__n) : 0; }
145 :
146 : void
147 25559 : _M_deallocate(_Tp* __p, size_t __n)
148 : {
149 25559 : if (__p)
150 20616 : _M_impl.deallocate(__p, __n);
151 25559 : }
152 : };
153 :
154 :
155 : /**
156 : * @brief A standard container which offers fixed time access to
157 : * individual elements in any order.
158 : *
159 : * @ingroup Containers
160 : * @ingroup Sequences
161 : *
162 : * Meets the requirements of a <a href="tables.html#65">container</a>, a
163 : * <a href="tables.html#66">reversible container</a>, and a
164 : * <a href="tables.html#67">sequence</a>, including the
165 : * <a href="tables.html#68">optional sequence requirements</a> with the
166 : * %exception of @c push_front and @c pop_front.
167 : *
168 : * In some terminology a %vector can be described as a dynamic
169 : * C-style array, it offers fast and efficient access to individual
170 : * elements in any order and saves the user from worrying about
171 : * memory and size allocation. Subscripting ( @c [] ) access is
172 : * also provided as with C-style arrays.
173 : */
174 : template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
175 : class vector : protected _Vector_base<_Tp, _Alloc>
176 : {
177 : // Concept requirements.
178 : typedef typename _Alloc::value_type _Alloc_value_type;
179 : __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
180 : __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)
181 :
182 : typedef _Vector_base<_Tp, _Alloc> _Base;
183 : typedef vector<_Tp, _Alloc> vector_type;
184 : typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
185 :
186 : public:
187 : typedef _Tp value_type;
188 : typedef typename _Tp_alloc_type::pointer pointer;
189 : typedef typename _Tp_alloc_type::const_pointer const_pointer;
190 : typedef typename _Tp_alloc_type::reference reference;
191 : typedef typename _Tp_alloc_type::const_reference const_reference;
192 : typedef __gnu_cxx::__normal_iterator<pointer, vector_type> iterator;
193 : typedef __gnu_cxx::__normal_iterator<const_pointer, vector_type>
194 : const_iterator;
195 : typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
196 : typedef std::reverse_iterator<iterator> reverse_iterator;
197 : typedef size_t size_type;
198 : typedef ptrdiff_t difference_type;
199 : typedef _Alloc allocator_type;
200 :
201 : protected:
202 : using _Base::_M_allocate;
203 : using _Base::_M_deallocate;
204 : using _Base::_M_impl;
205 : using _Base::_M_get_Tp_allocator;
206 :
207 : public:
208 : // [23.2.4.1] construct/copy/destroy
209 : // (assign() and get_allocator() are also listed in this section)
210 : /**
211 : * @brief Default constructor creates no elements.
212 : */
213 4840 : vector()
214 4840 : : _Base() { }
215 :
216 : /**
217 : * @brief Creates a %vector with no elements.
218 : * @param a An allocator object.
219 : */
220 : explicit
221 : vector(const allocator_type& __a)
222 : : _Base(__a) { }
223 :
224 : /**
225 : * @brief Creates a %vector with copies of an exemplar element.
226 : * @param n The number of elements to initially create.
227 : * @param value An element to copy.
228 : * @param a An allocator.
229 : *
230 : * This constructor fills the %vector with @a n copies of @a value.
231 : */
232 : explicit
233 : vector(size_type __n, const value_type& __value = value_type(),
234 9 : const allocator_type& __a = allocator_type())
235 9 : : _Base(__n, __a)
236 9 : { _M_fill_initialize(__n, __value); }
237 :
238 : /**
239 : * @brief %Vector copy constructor.
240 : * @param x A %vector of identical element and allocator types.
241 : *
242 : * The newly-created %vector uses a copy of the allocation
243 : * object used by @a x. All the elements of @a x are copied,
244 : * but any extra memory in
245 : * @a x (for fast expansion) will not be copied.
246 : */
247 0 : vector(const vector& __x)
248 0 : : _Base(__x.size(), __x._M_get_Tp_allocator())
249 0 : { this->_M_impl._M_finish =
250 : std::__uninitialized_copy_a(__x.begin(), __x.end(),
251 : this->_M_impl._M_start,
252 : _M_get_Tp_allocator());
253 0 : }
254 :
255 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
256 : /**
257 : * @brief %Vector move constructor.
258 : * @param x A %vector of identical element and allocator types.
259 : *
260 : * The newly-created %vector contains the exact contents of @a x.
261 : * The contents of @a x are a valid, but unspecified %vector.
262 : */
263 : vector(vector&& __x)
264 : : _Base(std::forward<_Base>(__x)) { }
265 : #endif
266 :
267 : /**
268 : * @brief Builds a %vector from a range.
269 : * @param first An input iterator.
270 : * @param last An input iterator.
271 : * @param a An allocator.
272 : *
273 : * Create a %vector consisting of copies of the elements from
274 : * [first,last).
275 : *
276 : * If the iterators are forward, bidirectional, or
277 : * random-access, then this will call the elements' copy
278 : * constructor N times (where N is distance(first,last)) and do
279 : * no memory reallocation. But if only input iterators are
280 : * used, then this will do at most 2N calls to the copy
281 : * constructor, and logN memory reallocations.
282 : */
283 : template<typename _InputIterator>
284 : vector(_InputIterator __first, _InputIterator __last,
285 : const allocator_type& __a = allocator_type())
286 : : _Base(__a)
287 : {
288 : // Check whether it's an integral type. If so, it's not an iterator.
289 : typedef typename std::__is_integer<_InputIterator>::__type _Integral;
290 : _M_initialize_dispatch(__first, __last, _Integral());
291 : }
292 :
293 : /**
294 : * The dtor only erases the elements, and note that if the
295 : * elements themselves are pointers, the pointed-to memory is
296 : * not touched in any way. Managing the pointer is the user's
297 : * responsibility.
298 : */
299 4841 : ~vector()
300 4841 : { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
301 4841 : _M_get_Tp_allocator()); }
302 :
303 : /**
304 : * @brief %Vector assignment operator.
305 : * @param x A %vector of identical element and allocator types.
306 : *
307 : * All the elements of @a x are copied, but any extra memory in
308 : * @a x (for fast expansion) will not be copied. Unlike the
309 : * copy constructor, the allocator object is not copied.
310 : */
311 : vector&
312 : operator=(const vector& __x);
313 :
314 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
315 : /**
316 : * @brief %Vector move assignment operator.
317 : * @param x A %vector of identical element and allocator types.
318 : *
319 : * The contents of @a x are moved into this %vector (without copying).
320 : * @a x is a valid, but unspecified %vector.
321 : */
322 : vector&
323 : operator=(vector&& __x)
324 : {
325 : // NB: DR 675.
326 : this->clear();
327 : this->swap(__x);
328 : return *this;
329 : }
330 : #endif
331 :
332 : /**
333 : * @brief Assigns a given value to a %vector.
334 : * @param n Number of elements to be assigned.
335 : * @param val Value to be assigned.
336 : *
337 : * This function fills a %vector with @a n copies of the given
338 : * value. Note that the assignment completely changes the
339 : * %vector and that the resulting %vector's size is the same as
340 : * the number of elements assigned. Old data may be lost.
341 : */
342 : void
343 : assign(size_type __n, const value_type& __val)
344 : { _M_fill_assign(__n, __val); }
345 :
346 : /**
347 : * @brief Assigns a range to a %vector.
348 : * @param first An input iterator.
349 : * @param last An input iterator.
350 : *
351 : * This function fills a %vector with copies of the elements in the
352 : * range [first,last).
353 : *
354 : * Note that the assignment completely changes the %vector and
355 : * that the resulting %vector's size is the same as the number
356 : * of elements assigned. Old data may be lost.
357 : */
358 : template<typename _InputIterator>
359 : void
360 : assign(_InputIterator __first, _InputIterator __last)
361 : {
362 : // Check whether it's an integral type. If so, it's not an iterator.
363 : typedef typename std::__is_integer<_InputIterator>::__type _Integral;
364 : _M_assign_dispatch(__first, __last, _Integral());
365 : }
366 :
367 : /// Get a copy of the memory allocation object.
368 : using _Base::get_allocator;
369 :
370 : // iterators
371 : /**
372 : * Returns a read/write iterator that points to the first
373 : * element in the %vector. Iteration is done in ordinary
374 : * element order.
375 : */
376 : iterator
377 4034 : begin()
378 4034 : { return iterator(this->_M_impl._M_start); }
379 :
380 : /**
381 : * Returns a read-only (constant) iterator that points to the
382 : * first element in the %vector. Iteration is done in ordinary
383 : * element order.
384 : */
385 : const_iterator
386 91 : begin() const
387 91 : { return const_iterator(this->_M_impl._M_start); }
388 :
389 : /**
390 : * Returns a read/write iterator that points one past the last
391 : * element in the %vector. Iteration is done in ordinary
392 : * element order.
393 : */
394 : iterator
395 69161 : end()
396 69161 : { return iterator(this->_M_impl._M_finish); }
397 :
398 : /**
399 : * Returns a read-only (constant) iterator that points one past
400 : * the last element in the %vector. Iteration is done in
401 : * ordinary element order.
402 : */
403 : const_iterator
404 175 : end() const
405 175 : { return const_iterator(this->_M_impl._M_finish); }
406 :
407 : /**
408 : * Returns a read/write reverse iterator that points to the
409 : * last element in the %vector. Iteration is done in reverse
410 : * element order.
411 : */
412 : reverse_iterator
413 1 : rbegin()
414 1 : { return reverse_iterator(end()); }
415 :
416 : /**
417 : * Returns a read-only (constant) reverse iterator that points
418 : * to the last element in the %vector. Iteration is done in
419 : * reverse element order.
420 : */
421 : const_reverse_iterator
422 : rbegin() const
423 : { return const_reverse_iterator(end()); }
424 :
425 : /**
426 : * Returns a read/write reverse iterator that points to one
427 : * before the first element in the %vector. Iteration is done
428 : * in reverse element order.
429 : */
430 : reverse_iterator
431 : rend()
432 : { return reverse_iterator(begin()); }
433 :
434 : /**
435 : * Returns a read-only (constant) reverse iterator that points
436 : * to one before the first element in the %vector. Iteration
437 : * is done in reverse element order.
438 : */
439 : const_reverse_iterator
440 : rend() const
441 : { return const_reverse_iterator(begin()); }
442 :
443 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
444 : /**
445 : * Returns a read-only (constant) iterator that points to the
446 : * first element in the %vector. Iteration is done in ordinary
447 : * element order.
448 : */
449 : const_iterator
450 : cbegin() const
451 : { return const_iterator(this->_M_impl._M_start); }
452 :
453 : /**
454 : * Returns a read-only (constant) iterator that points one past
455 : * the last element in the %vector. Iteration is done in
456 : * ordinary element order.
457 : */
458 : const_iterator
459 : cend() const
460 : { return const_iterator(this->_M_impl._M_finish); }
461 :
462 : /**
463 : * Returns a read-only (constant) reverse iterator that points
464 : * to the last element in the %vector. Iteration is done in
465 : * reverse element order.
466 : */
467 : const_reverse_iterator
468 : crbegin() const
469 : { return const_reverse_iterator(end()); }
470 :
471 : /**
472 : * Returns a read-only (constant) reverse iterator that points
473 : * to one before the first element in the %vector. Iteration
474 : * is done in reverse element order.
475 : */
476 : const_reverse_iterator
477 : crend() const
478 : { return const_reverse_iterator(begin()); }
479 : #endif
480 :
481 : // [23.2.4.2] capacity
482 : /** Returns the number of elements in the %vector. */
483 : size_type
484 1028954 : size() const
485 1028954 : { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
486 :
487 : /** Returns the size() of the largest possible %vector. */
488 : size_type
489 41426 : max_size() const
490 41426 : { return _M_get_Tp_allocator().max_size(); }
491 :
492 : /**
493 : * @brief Resizes the %vector to the specified number of elements.
494 : * @param new_size Number of elements the %vector should contain.
495 : * @param x Data with which new elements should be populated.
496 : *
497 : * This function will %resize the %vector to the specified
498 : * number of elements. If the number is smaller than the
499 : * %vector's current size the %vector is truncated, otherwise
500 : * the %vector is extended and new elements are populated with
501 : * given data.
502 : */
503 : void
504 22443 : resize(size_type __new_size, value_type __x = value_type())
505 : {
506 22443 : if (__new_size < size())
507 0 : _M_erase_at_end(this->_M_impl._M_start + __new_size);
508 : else
509 22443 : insert(end(), __new_size - size(), __x);
510 22443 : }
511 :
512 : /**
513 : * Returns the total number of elements that the %vector can
514 : * hold before needing to allocate more memory.
515 : */
516 : size_type
517 10 : capacity() const
518 : { return size_type(this->_M_impl._M_end_of_storage
519 10 : - this->_M_impl._M_start); }
520 :
521 : /**
522 : * Returns true if the %vector is empty. (Thus begin() would
523 : * equal end().)
524 : */
525 : bool
526 25 : empty() const
527 25 : { return begin() == end(); }
528 :
529 : /**
530 : * @brief Attempt to preallocate enough memory for specified number of
531 : * elements.
532 : * @param n Number of elements required.
533 : * @throw std::length_error If @a n exceeds @c max_size().
534 : *
535 : * This function attempts to reserve enough memory for the
536 : * %vector to hold the specified number of elements. If the
537 : * number requested is more than max_size(), length_error is
538 : * thrown.
539 : *
540 : * The advantage of this function is that if optimal code is a
541 : * necessity and the user can determine the number of elements
542 : * that will be required, the user can reserve the memory in
543 : * %advance, and thus prevent a possible reallocation of memory
544 : * and copying of %vector data.
545 : */
546 : void
547 : reserve(size_type __n);
548 :
549 : // element access
550 : /**
551 : * @brief Subscript access to the data contained in the %vector.
552 : * @param n The index of the element for which data should be
553 : * accessed.
554 : * @return Read/write reference to data.
555 : *
556 : * This operator allows for easy, array-style, data access.
557 : * Note that data access with this operator is unchecked and
558 : * out_of_range lookups are not defined. (For checked lookups
559 : * see at().)
560 : */
561 : reference
562 256895 : operator[](size_type __n)
563 256895 : { return *(this->_M_impl._M_start + __n); }
564 :
565 : /**
566 : * @brief Subscript access to the data contained in the %vector.
567 : * @param n The index of the element for which data should be
568 : * accessed.
569 : * @return Read-only (constant) reference to data.
570 : *
571 : * This operator allows for easy, array-style, data access.
572 : * Note that data access with this operator is unchecked and
573 : * out_of_range lookups are not defined. (For checked lookups
574 : * see at().)
575 : */
576 : const_reference
577 1925198 : operator[](size_type __n) const
578 1925198 : { return *(this->_M_impl._M_start + __n); }
579 :
580 : protected:
581 : /// Safety check used only from at().
582 : void
583 : _M_range_check(size_type __n) const
584 : {
585 : if (__n >= this->size())
586 : __throw_out_of_range(__N("vector::_M_range_check"));
587 : }
588 :
589 : public:
590 : /**
591 : * @brief Provides access to the data contained in the %vector.
592 : * @param n The index of the element for which data should be
593 : * accessed.
594 : * @return Read/write reference to data.
595 : * @throw std::out_of_range If @a n is an invalid index.
596 : *
597 : * This function provides for safer data access. The parameter
598 : * is first checked that it is in the range of the vector. The
599 : * function throws out_of_range if the check fails.
600 : */
601 : reference
602 : at(size_type __n)
603 : {
604 : _M_range_check(__n);
605 : return (*this)[__n];
606 : }
607 :
608 : /**
609 : * @brief Provides access to the data contained in the %vector.
610 : * @param n The index of the element for which data should be
611 : * accessed.
612 : * @return Read-only (constant) reference to data.
613 : * @throw std::out_of_range If @a n is an invalid index.
614 : *
615 : * This function provides for safer data access. The parameter
616 : * is first checked that it is in the range of the vector. The
617 : * function throws out_of_range if the check fails.
618 : */
619 : const_reference
620 : at(size_type __n) const
621 : {
622 : _M_range_check(__n);
623 : return (*this)[__n];
624 : }
625 :
626 : /**
627 : * Returns a read/write reference to the data at the first
628 : * element of the %vector.
629 : */
630 : reference
631 : front()
632 : { return *begin(); }
633 :
634 : /**
635 : * Returns a read-only (constant) reference to the data at the first
636 : * element of the %vector.
637 : */
638 : const_reference
639 : front() const
640 : { return *begin(); }
641 :
642 : /**
643 : * Returns a read/write reference to the data at the last
644 : * element of the %vector.
645 : */
646 : reference
647 3 : back()
648 3 : { return *(end() - 1); }
649 :
650 : /**
651 : * Returns a read-only (constant) reference to the data at the
652 : * last element of the %vector.
653 : */
654 : const_reference
655 : back() const
656 : { return *(end() - 1); }
657 :
658 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
659 : // DR 464. Suggestion for new member functions in standard containers.
660 : // data access
661 : /**
662 : * Returns a pointer such that [data(), data() + size()) is a valid
663 : * range. For a non-empty %vector, data() == &front().
664 : */
665 : pointer
666 : data()
667 : { return pointer(this->_M_impl._M_start); }
668 :
669 : const_pointer
670 : data() const
671 : { return const_pointer(this->_M_impl._M_start); }
672 :
673 : // [23.2.4.3] modifiers
674 : /**
675 : * @brief Add data to the end of the %vector.
676 : * @param x Data to be added.
677 : *
678 : * This is a typical stack operation. The function creates an
679 : * element at the end of the %vector and assigns the given data
680 : * to it. Due to the nature of a %vector this operation can be
681 : * done in constant time if the %vector has preallocated space
682 : * available.
683 : */
684 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
685 : void
686 129213 : push_back(const value_type& __x)
687 : {
688 129213 : if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
689 : {
690 108914 : this->_M_impl.construct(this->_M_impl._M_finish, __x);
691 108914 : ++this->_M_impl._M_finish;
692 : }
693 : else
694 20299 : _M_insert_aux(end(), __x);
695 129213 : }
696 : #else
697 : template<typename... _Args>
698 : void
699 : push_back(_Args&&... __args)
700 : {
701 : if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
702 : {
703 : this->_M_impl.construct(this->_M_impl._M_finish,
704 : std::forward<_Args>(__args)...);
705 : ++this->_M_impl._M_finish;
706 : }
707 : else
708 : _M_insert_aux(end(), std::forward<_Args>(__args)...);
709 : }
710 : #endif
711 :
712 : /**
713 : * @brief Removes last element.
714 : *
715 : * This is a typical stack operation. It shrinks the %vector by one.
716 : *
717 : * Note that no data is returned, and if the last element's
718 : * data is needed, it should be retrieved before pop_back() is
719 : * called.
720 : */
721 : void
722 3 : pop_back()
723 : {
724 3 : --this->_M_impl._M_finish;
725 3 : this->_M_impl.destroy(this->_M_impl._M_finish);
726 3 : }
727 :
728 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
729 : /**
730 : * @brief Inserts an object in %vector before specified iterator.
731 : * @param position An iterator into the %vector.
732 : * @param args Arguments.
733 : * @return An iterator that points to the inserted data.
734 : *
735 : * This function will insert an object of type T constructed
736 : * with T(std::forward<Args>(args)...) before the specified location.
737 : * Note that this kind of operation could be expensive for a %vector
738 : * and if it is frequently used the user should consider using
739 : * std::list.
740 : */
741 : template<typename... _Args>
742 : iterator
743 : emplace(iterator __position, _Args&&... __args);
744 : #endif
745 :
746 : /**
747 : * @brief Inserts given value into %vector before specified iterator.
748 : * @param position An iterator into the %vector.
749 : * @param x Data to be inserted.
750 : * @return An iterator that points to the inserted data.
751 : *
752 : * This function will insert a copy of the given value before
753 : * the specified location. Note that this kind of operation
754 : * could be expensive for a %vector and if it is frequently
755 : * used the user should consider using std::list.
756 : */
757 : iterator
758 : insert(iterator __position, const value_type& __x);
759 :
760 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
761 : /**
762 : * @brief Inserts given rvalue into %vector before specified iterator.
763 : * @param position An iterator into the %vector.
764 : * @param x Data to be inserted.
765 : * @return An iterator that points to the inserted data.
766 : *
767 : * This function will insert a copy of the given rvalue before
768 : * the specified location. Note that this kind of operation
769 : * could be expensive for a %vector and if it is frequently
770 : * used the user should consider using std::list.
771 : */
772 : iterator
773 : insert(iterator __position, value_type&& __x)
774 : { return emplace(__position, std::move(__x)); }
775 : #endif
776 :
777 : /**
778 : * @brief Inserts a number of copies of given data into the %vector.
779 : * @param position An iterator into the %vector.
780 : * @param n Number of elements to be inserted.
781 : * @param x Data to be inserted.
782 : *
783 : * This function will insert a specified number of copies of
784 : * the given data before the location specified by @a position.
785 : *
786 : * Note that this kind of operation could be expensive for a
787 : * %vector and if it is frequently used the user should
788 : * consider using std::list.
789 : */
790 : void
791 22443 : insert(iterator __position, size_type __n, const value_type& __x)
792 22443 : { _M_fill_insert(__position, __n, __x); }
793 :
794 : /**
795 : * @brief Inserts a range into the %vector.
796 : * @param position An iterator into the %vector.
797 : * @param first An input iterator.
798 : * @param last An input iterator.
799 : *
800 : * This function will insert copies of the data in the range
801 : * [first,last) into the %vector before the location specified
802 : * by @a pos.
803 : *
804 : * Note that this kind of operation could be expensive for a
805 : * %vector and if it is frequently used the user should
806 : * consider using std::list.
807 : */
808 : template<typename _InputIterator>
809 : void
810 : insert(iterator __position, _InputIterator __first,
811 : _InputIterator __last)
812 : {
813 : // Check whether it's an integral type. If so, it's not an iterator.
814 : typedef typename std::__is_integer<_InputIterator>::__type _Integral;
815 : _M_insert_dispatch(__position, __first, __last, _Integral());
816 : }
817 :
818 : /**
819 : * @brief Remove element at given position.
820 : * @param position Iterator pointing to element to be erased.
821 : * @return An iterator pointing to the next element (or end()).
822 : *
823 : * This function will erase the element at the given position and thus
824 : * shorten the %vector by one.
825 : *
826 : * Note This operation could be expensive and if it is
827 : * frequently used the user should consider using std::list.
828 : * The user is also cautioned that this function only erases
829 : * the element, and that if the element is itself a pointer,
830 : * the pointed-to memory is not touched in any way. Managing
831 : * the pointer is the user's responsibility.
832 : */
833 : iterator
834 : erase(iterator __position);
835 :
836 : /**
837 : * @brief Remove a range of elements.
838 : * @param first Iterator pointing to the first element to be erased.
839 : * @param last Iterator pointing to one past the last element to be
840 : * erased.
841 : * @return An iterator pointing to the element pointed to by @a last
842 : * prior to erasing (or end()).
843 : *
844 : * This function will erase the elements in the range [first,last) and
845 : * shorten the %vector accordingly.
846 : *
847 : * Note This operation could be expensive and if it is
848 : * frequently used the user should consider using std::list.
849 : * The user is also cautioned that this function only erases
850 : * the elements, and that if the elements themselves are
851 : * pointers, the pointed-to memory is not touched in any way.
852 : * Managing the pointer is the user's responsibility.
853 : */
854 : iterator
855 : erase(iterator __first, iterator __last);
856 :
857 : /**
858 : * @brief Swaps data with another %vector.
859 : * @param x A %vector of the same element and allocator types.
860 : *
861 : * This exchanges the elements between two vectors in constant time.
862 : * (Three pointers, so it should be quite fast.)
863 : * Note that the global std::swap() function is specialized such that
864 : * std::swap(v1,v2) will feed to this function.
865 : */
866 : void
867 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
868 : swap(vector&& __x)
869 : #else
870 : swap(vector& __x)
871 : #endif
872 : {
873 : std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
874 : std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
875 : std::swap(this->_M_impl._M_end_of_storage,
876 : __x._M_impl._M_end_of_storage);
877 :
878 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
879 : // 431. Swapping containers with unequal allocators.
880 : std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
881 : __x._M_get_Tp_allocator());
882 : }
883 :
884 : /**
885 : * Erases all the elements. Note that this function only erases the
886 : * elements, and that if the elements themselves are pointers, the
887 : * pointed-to memory is not touched in any way. Managing the pointer is
888 : * the user's responsibility.
889 : */
890 : void
891 7856 : clear()
892 7856 : { _M_erase_at_end(this->_M_impl._M_start); }
893 :
894 : protected:
895 : /**
896 : * Memory expansion handler. Uses the member allocation function to
897 : * obtain @a n bytes of memory, and then copies [first,last) into it.
898 : */
899 : template<typename _ForwardIterator>
900 : pointer
901 : _M_allocate_and_copy(size_type __n,
902 10 : _ForwardIterator __first, _ForwardIterator __last)
903 : {
904 10 : pointer __result = this->_M_allocate(__n);
905 : try
906 : {
907 10 : std::__uninitialized_copy_a(__first, __last, __result,
908 : _M_get_Tp_allocator());
909 10 : return __result;
910 : }
911 0 : catch(...)
912 : {
913 0 : _M_deallocate(__result, __n);
914 0 : __throw_exception_again;
915 : }
916 : }
917 :
918 :
919 : // Internal constructor functions follow.
920 :
921 : // Called by the range constructor to implement [23.1.1]/9
922 :
923 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
924 : // 438. Ambiguity in the "do the right thing" clause
925 : template<typename _Integer>
926 : void
927 : _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
928 : {
929 : this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
930 : this->_M_impl._M_end_of_storage =
931 : this->_M_impl._M_start + static_cast<size_type>(__n);
932 : _M_fill_initialize(static_cast<size_type>(__n), __value);
933 : }
934 :
935 : // Called by the range constructor to implement [23.1.1]/9
936 : template<typename _InputIterator>
937 : void
938 : _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
939 : __false_type)
940 : {
941 : typedef typename std::iterator_traits<_InputIterator>::
942 : iterator_category _IterCategory;
943 : _M_range_initialize(__first, __last, _IterCategory());
944 : }
945 :
946 : // Called by the second initialize_dispatch above
947 : template<typename _InputIterator>
948 : void
949 : _M_range_initialize(_InputIterator __first,
950 : _InputIterator __last, std::input_iterator_tag)
951 : {
952 : for (; __first != __last; ++__first)
953 : push_back(*__first);
954 : }
955 :
956 : // Called by the second initialize_dispatch above
957 : template<typename _ForwardIterator>
958 : void
959 : _M_range_initialize(_ForwardIterator __first,
960 : _ForwardIterator __last, std::forward_iterator_tag)
961 : {
962 : const size_type __n = std::distance(__first, __last);
963 : this->_M_impl._M_start = this->_M_allocate(__n);
964 : this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
965 : this->_M_impl._M_finish =
966 : std::__uninitialized_copy_a(__first, __last,
967 : this->_M_impl._M_start,
968 : _M_get_Tp_allocator());
969 : }
970 :
971 : // Called by the first initialize_dispatch above and by the
972 : // vector(n,value,a) constructor.
973 : void
974 9 : _M_fill_initialize(size_type __n, const value_type& __value)
975 : {
976 9 : std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
977 : _M_get_Tp_allocator());
978 9 : this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
979 9 : }
980 :
981 :
982 : // Internal assign functions follow. The *_aux functions do the actual
983 : // assignment work for the range versions.
984 :
985 : // Called by the range assign to implement [23.1.1]/9
986 :
987 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
988 : // 438. Ambiguity in the "do the right thing" clause
989 : template<typename _Integer>
990 : void
991 : _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
992 : { _M_fill_assign(__n, __val); }
993 :
994 : // Called by the range assign to implement [23.1.1]/9
995 : template<typename _InputIterator>
996 : void
997 : _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
998 : __false_type)
999 : {
1000 : typedef typename std::iterator_traits<_InputIterator>::
1001 : iterator_category _IterCategory;
1002 : _M_assign_aux(__first, __last, _IterCategory());
1003 : }
1004 :
1005 : // Called by the second assign_dispatch above
1006 : template<typename _InputIterator>
1007 : void
1008 : _M_assign_aux(_InputIterator __first, _InputIterator __last,
1009 : std::input_iterator_tag);
1010 :
1011 : // Called by the second assign_dispatch above
1012 : template<typename _ForwardIterator>
1013 : void
1014 : _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1015 : std::forward_iterator_tag);
1016 :
1017 : // Called by assign(n,t), and the range assign when it turns out
1018 : // to be the same thing.
1019 : void
1020 : _M_fill_assign(size_type __n, const value_type& __val);
1021 :
1022 :
1023 : // Internal insert functions follow.
1024 :
1025 : // Called by the range insert to implement [23.1.1]/9
1026 :
1027 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1028 : // 438. Ambiguity in the "do the right thing" clause
1029 : template<typename _Integer>
1030 : void
1031 : _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
1032 : __true_type)
1033 : { _M_fill_insert(__pos, __n, __val); }
1034 :
1035 : // Called by the range insert to implement [23.1.1]/9
1036 : template<typename _InputIterator>
1037 : void
1038 : _M_insert_dispatch(iterator __pos, _InputIterator __first,
1039 : _InputIterator __last, __false_type)
1040 : {
1041 : typedef typename std::iterator_traits<_InputIterator>::
1042 : iterator_category _IterCategory;
1043 : _M_range_insert(__pos, __first, __last, _IterCategory());
1044 : }
1045 :
1046 : // Called by the second insert_dispatch above
1047 : template<typename _InputIterator>
1048 : void
1049 : _M_range_insert(iterator __pos, _InputIterator __first,
1050 : _InputIterator __last, std::input_iterator_tag);
1051 :
1052 : // Called by the second insert_dispatch above
1053 : template<typename _ForwardIterator>
1054 : void
1055 : _M_range_insert(iterator __pos, _ForwardIterator __first,
1056 : _ForwardIterator __last, std::forward_iterator_tag);
1057 :
1058 : // Called by insert(p,n,x), and the range insert when it turns out to be
1059 : // the same thing.
1060 : void
1061 : _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
1062 :
1063 : // Called by insert(p,x)
1064 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
1065 : void
1066 : _M_insert_aux(iterator __position, const value_type& __x);
1067 : #else
1068 : template<typename... _Args>
1069 : void
1070 : _M_insert_aux(iterator __position, _Args&&... __args);
1071 : #endif
1072 :
1073 : // Called by the latter.
1074 : size_type
1075 20708 : _M_check_len(size_type __n, const char* __s) const
1076 : {
1077 20708 : if (max_size() - size() < __n)
1078 0 : __throw_length_error(__N(__s));
1079 :
1080 20708 : const size_type __len = size() + std::max(size(), __n);
1081 20708 : return (__len < size() || __len > max_size()) ? max_size() : __len;
1082 : }
1083 :
1084 : // Internal erase functions follow.
1085 :
1086 : // Called by erase(q1,q2), clear(), resize(), _M_fill_assign,
1087 : // _M_assign_aux.
1088 : void
1089 7856 : _M_erase_at_end(pointer __pos)
1090 : {
1091 7856 : std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
1092 7856 : this->_M_impl._M_finish = __pos;
1093 7856 : }
1094 : };
1095 :
1096 :
1097 : /**
1098 : * @brief Vector equality comparison.
1099 : * @param x A %vector.
1100 : * @param y A %vector of the same type as @a x.
1101 : * @return True iff the size and elements of the vectors are equal.
1102 : *
1103 : * This is an equivalence relation. It is linear in the size of the
1104 : * vectors. Vectors are considered equivalent if their sizes are equal,
1105 : * and if corresponding elements compare equal.
1106 : */
1107 : template<typename _Tp, typename _Alloc>
1108 : inline bool
1109 : operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1110 : { return (__x.size() == __y.size()
1111 : && std::equal(__x.begin(), __x.end(), __y.begin())); }
1112 :
1113 : /**
1114 : * @brief Vector ordering relation.
1115 : * @param x A %vector.
1116 : * @param y A %vector of the same type as @a x.
1117 : * @return True iff @a x is lexicographically less than @a y.
1118 : *
1119 : * This is a total ordering relation. It is linear in the size of the
1120 : * vectors. The elements must be comparable with @c <.
1121 : *
1122 : * See std::lexicographical_compare() for how the determination is made.
1123 : */
1124 : template<typename _Tp, typename _Alloc>
1125 : inline bool
1126 : operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1127 : { return std::lexicographical_compare(__x.begin(), __x.end(),
1128 : __y.begin(), __y.end()); }
1129 :
1130 : /// Based on operator==
1131 : template<typename _Tp, typename _Alloc>
1132 : inline bool
1133 : operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1134 : { return !(__x == __y); }
1135 :
1136 : /// Based on operator<
1137 : template<typename _Tp, typename _Alloc>
1138 : inline bool
1139 : operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1140 : { return __y < __x; }
1141 :
1142 : /// Based on operator<
1143 : template<typename _Tp, typename _Alloc>
1144 : inline bool
1145 : operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1146 : { return !(__y < __x); }
1147 :
1148 : /// Based on operator<
1149 : template<typename _Tp, typename _Alloc>
1150 : inline bool
1151 : operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1152 : { return !(__x < __y); }
1153 :
1154 : /// See std::vector::swap().
1155 : template<typename _Tp, typename _Alloc>
1156 : inline void
1157 : swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
1158 : { __x.swap(__y); }
1159 :
1160 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
1161 : template<typename _Tp, typename _Alloc>
1162 : inline void
1163 : swap(vector<_Tp, _Alloc>&& __x, vector<_Tp, _Alloc>& __y)
1164 : { __x.swap(__y); }
1165 :
1166 : template<typename _Tp, typename _Alloc>
1167 : inline void
1168 : swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>&& __y)
1169 : { __x.swap(__y); }
1170 : #endif
1171 :
1172 : _GLIBCXX_END_NESTED_NAMESPACE
1173 :
1174 : #endif /* _STL_VECTOR_H */
|