vector针对大对象的优化

vector在可用空间不足，进行某些插入操作的时候就会重新分配空间，然后再进行一系列的拷贝工作，如果对象比较大，那么拷贝起来是非常缓慢的。有没有办法提高拷贝时的速度呢。办法是有的。那就是以空间换取时间。vector只存取大对象的指针。指针的大小是固定的，比较小的。这样就能提高拷贝的速度。当然如果是小对象也那么干，速度不但不会提升，反到会下降。白白多了一些内存分配动作。下面是一个实现：

#ifndef FASHLISH_H
#define FASHLISH_H

#include<vector>
namespace lytool
{ 
 using namespace std;

 struct __fastlist_iterator_base
   {
   typedef size_t size_type;
   typedef ptrdiff_t difference_type;
   typedef random_access_iterator_tag iterator_category;
   };

 template<typename T, typename Ref, typename Ptr>
 struct __fastlist_iterator: public __fastlist_iterator_base
 {
  typedef __fastlist_iterator<T, T&, T*>   iterator;
  typedef __fastlist_iterator<T, const T&, const T*> const_iterator;
  typedef __fastlist_iterator<T, Ref, Ptr>  self;

        typedef T value_type;
  typedef Ptr pointer;
  typedef Ref reference;
       
  typename vector<T*>::iterator node;

  __fastlist_iterator(){}

  __fastlist_iterator(typename vector<T*>::iterator iter)
  { node = iter; }

  __fastlist_iterator(const self& other)
  { node = other.node; }

  reference operator* () const { return **node; }
  pointer operator-> () const { return &(operator*()); }

  self& operator= (const self& other)
  {
   if( this == &other)
    return *this;

   node = other.node;
   return *this;
  }
       
  self& operator++ ()
  {
   ++node;
   return *this;
  }

  self operator++ (int)
  {
   self temp = *this;
   ++node;
   return temp;
  }

  self& operator-- ()
  {
   --node;
   return *this;
  }

  self operator-- (int)
  {
   self temp = *this;
   --node;
   return temp;
  }

  self operator+= (int n)
  {
   node + = n;
   return *this
  }

  self operator-= (int n)
  {
   return operator+= (-n);
  }

  self operator+ (int n)
  {
   return operator+= (n);
  }

  self operator- (int n)
  {
   return operator-= (n);
  }

  bool operator== (const self& other)
  {
   return (node == other.node);
  }

  bool operator!= (const self& other)
  {
   return !(operator== (other));
  }

 };

 template<typename T>
 class fastlist
 {
 public:
  typedef T value_type;
  typedef value_type* pointer;
        typedef const value_type* const_pointer; 
  typedef value_type& reference;
  typedef const value_type&  const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef __fastlist_iterator<T, T&, T*> iterator;
  typedef __fastlist_iterator<T, const T&, const T*> const_iterator;

 private:
  vector<T*> data;

 private:
  pointer construct()
  {
   return new T;
  }

  pointer construct(const T& other)
  {
   return new T(other);
  }

  void destruct(T* p)
  {
   delete p;
  }
 public:
        iterator begin()
  {
   return iterator(data.begin());
  }

  iterator end()
  {
   return iterator(data.end());
  }

  size_type size()
  {
   return data.size();
  }

  bool empty()
  {
   return data.empty();
  }

  reference front()
  {
   return *begin();
  }

  reference back()
  {
   return *( end() - 1 );
  }

  void insert(const T& other,iterator iter)
  {
           pointer p = construct(other);
     data.insert(iter.node, p);
  }

  void push_back(const T& other)
  {
   pointer p = construct(other);
   data.push_back(p);
  }

  void push_front(const T& other)
  {
   insert(other, begin());
  }

  void pop_back(const iterator& iter)
  {
   data.pop_back(*(iter.node));
  }

  void pop_front(const iterator& iter)
  {
   data.pop_front(*(iter.node));
  }

  void erase(iterator iter)
  {
           destruct(*(iter.node));
  }

        void clear()
  {
   iterator iter = begin();
   iterator iterend = end();
   for(;iter != iterend; ++iter)
   {
    destruct(*(iter.node));
   }
   data.clear();
  }

        fastlist()
  {
  }

  fastlist(const fastlist& other)
  {
   data = other.data;
  }

  ~fastlist()
  {
   clear();
  }
 };
}
#endif 

 上面的Fastlist容器的优点是针对大对象而言，插入和遍历速度都快于
vector,遍历速度当然更是远快于list(名字的由来)
此外，提供了符合c++标准的迭代器，可以使用的一些C++中的一些算法。但由于这个迭代器还没有完工，有的方法还没有实现，所以有些算法还不能使用。