vector源码

vector 源码

// Filename:    stl_vector.h  
    
/* 
 * 
 * Copyright (c) 1994 
 * Hewlett-Packard Company 
 * 
 * Permission to use, copy, modify, distribute and sell this software 
 * and its documentation for any purpose is hereby granted without fee, 
 * provided that the above copyright notice appear in all copies and 
 * that both that copyright notice and this permission notice appear 
 * in supporting documentation.  Hewlett-Packard Company makes no 
 * representations about the suitability of this software for any 
 * purpose.  It is provided "as is" without express or implied warranty. 
 * 
 * 
 * Copyright (c) 1996 
 * Silicon Graphics Computer Systems, Inc. 
 * 
 * Permission to use, copy, modify, distribute and sell this software 
 * and its documentation for any purpose is hereby granted without fee, 
 * provided that the above copyright notice appear in all copies and 
 * that both that copyright notice and this permission notice appear 
 * in supporting documentation.  Silicon Graphics makes no 
 * representations about the suitability of this software for any 
 * purpose.  It is provided "as is" without express or implied warranty. 
 */  
  
/* NOTE: This is an internal header file, included by other STL headers. 
 *   You should not attempt to use it directly. 
 */  
  
#ifndef __SGI_STL_INTERNAL_VECTOR_H  
#define __SGI_STL_INTERNAL_VECTOR_H  
  
__STL_BEGIN_NAMESPACE  
  
#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)  
#pragma set woff 1174  
#endif  
  
  
  
//  
  
  
  
// 默认allocator为alloc, 其具体使用版本请参照<stl_alloc.h>  
template <class T, class Alloc = alloc>  
class vector  
{  
public:  
  // 标记为'STL标准强制要求'的typedefs用于提供iterator_traits<I>支持  
  typedef T value_type;                         // STL标准强制要求  
  typedef value_type* pointer;                  // STL标准强制要求  
  typedef const value_type* const_pointer;  
  // 由于vector的特性, 一般我们实作的时候都分配给其连续的内存空间,  
  // 所以其迭代器只需要定义成原生指针即可满足需要  
  typedef value_type* iterator;                 // STL标准强制要求  
  typedef const value_type* const_iterator;  
  typedef value_type& reference;                // STL标准强制要求  
  typedef const value_type& const_reference;  
  typedef size_t size_type;  
  typedef ptrdiff_t difference_type;            // STL标准强制要求  
  
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION  
  typedef reverse_iterator<const_iterator> const_reverse_iterator;  
  typedef reverse_iterator<iterator> reverse_iterator;  
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */  
  typedef reverse_iterator<const_iterator, value_type, const_reference,  
                           difference_type>  const_reverse_iterator;  
  typedef reverse_iterator<iterator, value_type, reference, difference_type>  
          reverse_iterator;  
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */  
  
protected:  
  // 这个提供STL标准的allocator接口  
  typedef simple_alloc<value_type, Alloc> data_allocator;  
  
  iterator start;               // 内存空间起始点  
  iterator finish;              // 当前使用的内存空间结束点  
  iterator end_of_storage;      // 实际分配内存空间的结束点  
  
  void insert_aux(iterator position, const T& x);  
  
  // 释放分配的内存空间  
  void deallocate()  
  {  
    // 由于使用的是data_allocator进行内存空间的分配,  
    // 所以需要同样嗲用data_allocator::deallocate()进行释放  
    // 如果直接释放, 对于data_allocator内部使用内存池的版本  
    // 就会发生错误  
    if (start) data_allocator::deallocate(start, end_of_storage - start);  
  }  
  
  void fill_initialize(size_type n, const T& value)  
  {  
    start = allocate_and_fill(n, value);  
    finish = start + n;                         // 设置当前使用内存空间的结束点  
    // 构造阶段, 此实作不多分配内存,  
    // 所以要设置内存空间结束点和, 已经使用的内存空间结束点相同  
    end_of_storage = finish;  
  }  
  
public:  
  // 获取几种迭代器  
  iterator begin() { return start; }  
  const_iterator begin() const { return start; }  
  iterator end() { return finish; }  
  const_iterator end() const { return finish; }  
  reverse_iterator rbegin() { return reverse_iterator(end()); }  
  const_reverse_iterator rbegin() const {  
    return const_reverse_iterator(end());  
  }  
  reverse_iterator rend() { return reverse_iterator(begin()); }  
  const_reverse_iterator rend() const {  
    return const_reverse_iterator(begin());  
  }  
  
  // 返回当前对象个数  
  size_type size() const { return size_type(end() - begin()); }  
  size_type max_size() const { return size_type(-1) / sizeof(T); }  
  // 返回重新分配内存前最多能存储的对象个数  
  size_type capacity() const { return size_type(end_of_storage - begin()); }  
  bool empty() const { return begin() == end(); }  
  reference operator[](size_type n) { return *(begin() + n); }  
  const_reference operator[](size_type n) const { return *(begin() + n); }  
  
  // 本实作中默认构造出的vector不分配内存空间  
  vector() : start(0), finish(0), end_of_storage(0) {}  
  
  
// 本实作中给定个数和对象, 则只分配所需内存, 不会多分配  
  
//                    vector(size_type n, const T& value)  
//                                   ↓  
//                         fill_initialize(n, value)  
//                                   ↓  
//                        allocate_and_fill(n, value)  
//                                   ↓  
//          data_allocator::allocate(n)          <stl_alloc.h>  
//          uninitialized_fill_n(result, n, x)  <stl_uninitialized.h>  
  
  
  vector(size_type n, const T& value) { fill_initialize(n, value); }  
  vector(int n, const T& value) { fill_initialize(n, value); }