headers/cpp/stl_vector.h

69   _Tp* _M_allocate(size_t __n)
70     { return _M_data_allocator.allocate(__n); }
71   void _M_deallocate(_Tp* __p, size_t __n)
72     { if (__p) _M_data_allocator.deallocate(__p, __n); }
94   _Tp* _M_allocate(size_t __n)
95     { return _Alloc_type::allocate(__n); }
96   void _M_deallocate(_Tp* __p, size_t __n)
97     { _Alloc_type::deallocate(__p, __n);}
111   _Vector_base(size_t __n, const allocator_type& __a) : _Base(__a) {
112     _M_start = _M_allocate(__n);
114     _M_end_of_storage = _M_start + __n;
130   _Vector_base(size_t __n, const _Alloc&)
133     _M_start = _M_allocate(__n);
135     _M_end_of_storage = _M_start + __n;
146   _Tp* _M_allocate(size_t __n)
147     { return _M_data_allocator::allocate(__n); }
148   void _M_deallocate(_Tp* __p, size_t __n)
149     { _M_data_allocator::deallocate(__p, __n); }
220   reference operator[](size_type __n) { return *(begin() + __n); }
221   const_reference operator[](size_type __n) const { return *(begin() + __n); }
223   reference at(size_type __n) {
224 	  if (__n >= size())
226 	  return *(begin() + __n);
229   const_reference at(size_type __n) const {
230 	  if (__n >= size())
232 	  return *(begin() + __n);
238   vector(size_type __n, const _Tp& __value,
240     : _Base(__n, __a)
241     { _M_finish = uninitialized_fill_n(_M_start, __n, __value); }
243   explicit vector(size_type __n)
244     : _Base(__n, allocator_type())
245     { _M_finish = uninitialized_fill_n(_M_start, __n, _Tp()); }
261   void _M_initialize_aux(_Integer __n, _Integer __value, __true_type) {
262     _M_start = _M_allocate(__n);
263     _M_end_of_storage = _M_start + __n;
264     _M_finish = uninitialized_fill_n(_M_start, __n, __value);
283   void reserve(size_type __n) {
284     if (capacity() < __n) {
286       iterator __tmp = _M_allocate_and_copy(__n, _M_start, _M_finish);
291       _M_end_of_storage = _M_start + __n;
300   void assign(size_type __n, const _Tp& __val);
311   void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
312     { assign((size_type) __n, (_Tp) __val); }
356     size_type __n = __position - begin();
363     return begin() + __n;
366     size_type __n = __position - begin();
373     return begin() + __n;
384   void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
386     insert(__pos, (size_type) __n, (_Tp) __val);
400   void insert (iterator __pos, size_type __n, const _Tp& __x);
433   iterator _M_allocate_and_copy(size_type __n, _ForwardIterator __first,
436     iterator __result = _M_allocate(__n);
441     __STL_UNWIND(_M_deallocate(__result, __n));
444   iterator _M_allocate_and_copy(size_type __n, const_iterator __first,
447     iterator __result = _M_allocate(__n);
452     __STL_UNWIND(_M_deallocate(__result, __n));
471     size_type __n = 0;
472     distance(__first, __last, __n);
473     _M_start = _M_allocate(__n);
474     _M_end_of_storage = _M_start + __n;
544 void vector<_Tp, _Alloc>::assign(size_t __n, const value_type& __val) {
545   if (__n > capacity()) {
546     vector<_Tp, _Alloc> __tmp(__n, __val, get_allocator());
549   else if (__n > size()) {
551     _M_finish = uninitialized_fill_n(_M_finish, __n - size(), __val);
554     erase(fill_n(begin(), __n, __val), end());
664 void vector<_Tp, _Alloc>::insert(iterator __position, size_type __n,
667   if (__n != 0) {
668     if (size_type(_M_end_of_storage - _M_finish) >= __n) {
672       if (__elems_after > __n) {
673         uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
674         _M_finish += __n;
675         copy_backward(__position, __old_finish - __n, __old_finish);
676         fill(__position, __position + __n, __x_copy);
679         uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);
680         _M_finish += __n - __elems_after;
688       const size_type __len = __old_size + max(__old_size, __n);
693         __new_finish = uninitialized_fill_n(__new_finish, __n, __x);
731     size_type __n = 0;
732     distance(__first, __last, __n);
733     if (size_type(_M_end_of_storage - _M_finish) >= __n) {
736       if (__elems_after > __n) {
737         uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
738         _M_finish += __n;
739         copy_backward(__position, __old_finish - __n, __old_finish);
746         _M_finish += __n - __elems_after;
754       const size_type __len = __old_size + max(__old_size, __n);
783     size_type __n = 0;
784     distance(__first, __last, __n);
785     if (size_type(_M_end_of_storage - _M_finish) >= __n) {
788       if (__elems_after > __n) {
789         uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
790         _M_finish += __n;
791         copy_backward(__position, __old_finish - __n, __old_finish);
796         _M_finish += __n - __elems_after;
804       const size_type __len = __old_size + max(__old_size, __n);