vector的实现

有了前面的基础后，我们知道对于特定的容器，我们一般要有对应的iterator与之对应，因为不同的容器，对应不同的数据结构，不同的数据结构对应不同的存取方式，所以也对应了不同的iterator类型。

我们知道vector容器对应的iterator肯定是 std::random_access_iterator_tag 类型的，它代表这种迭代器可以随机访问。

所以跟前面一样我们的迭代器首先应该实现 相应类型接口：

public:
 typedef typename T                     value_type;
 typedef typename ptrdiff_t      difference_type;
 typedef typename T&                    reference;
 typedef typename T*                    pointer;
 typedef typename std::random_access_iterator_tag  iterator_category;

然后就是重载一些操作符了，尽量让它的操作与指针的操作相符合，所以我们必须首先一下操作符的重载：

++（前），++（后）

--（前），--(后）

+（int n） -（int n）

-（iterator iter）

*       ->

所以有了这些要求后我们的迭代器就可以按如下实现了：

template<typename T> class my_vector_iterator { public: typedef typename T value_type; typedef typename ptrdiff_t difference_type; typedef typename T& reference; typedef typename T* pointer; typedef typename std::random_access_iterator_tag iterator_category; private: T* item; public: my_vector_iterator():item(0){} my_vector_iterator(T* input_item):item(input_item){} my_vector_iterator(my_vector_iterator<T>& iter):item(iter.item){} my_vector_iterator<T>& operator=(my_vector_iterator<T> iter) { item=iter.item; return *this; } ~my_vector_iterator(){} operator pointer() { return item; } my_vector_iterator<T>& operator++() { ++item; return *this; } my_vector_iterator<T> operator++(int) { my_vector_iterator<T> temp=*this; ++(*this); return temp; } my_vector_iterator<T> operator--() { --item; return *this; } my_vector_iterator<T> operator--(int) { my_vector_iterator<T> temp=*this; --(*this); return temp; } my_vector_iterator<T> operator-(int n) { my_vector_iterator<T> temp=*this; temp.item-=n; return temp; } my_vector_iterator<T> operator+(int n) { my_vector_iterator<T> temp=*this; temp.item+=n; return temp; } difference_type operator-(my_vector_iterator<T> other_iter) { return this->item-other_iter.item; } reference operator*() { return *item; } pointer operator->() { return item; } };

然后就是vector的实现了：

首先我们要确认它提供哪些接口，一般来说，对于线性存储的，对应有：

push_back,pop_back,front,back,at,operator[],empty,size。这些基本的操作，插入，删除，随机访问，清空，得到元素的数量。

但是我们还有一点要记住，因为vector跟array不一样，vector可以实现智能增长，所以我们一般需要下面3个成员来记录vector的状态：

iterator  start；//指向第一个元素

iterator  finish；//指向最后一个元素的后一个元素

iterator end_of_storage;//指向容器的末尾。

当finish==end_of_storage时候就代表空间满了，需要重新分配一个更大的空间.

所以这个时候必须还要提供一个 私有的函数用于分配空间。

在这里仿照书上写的，我用insert_aux（）这个函数全权完成了。在这个函数里面实现内存的分配和释放：

new_start=(T*)__my_default_alloc_template<0,0>::allocate(sizeof(T)*capacity);//分配内存

__my_default_alloc_template<0,0>::deallocate(start,(end_of_storage-start)*sizeof(T));//释放内存

完整代码如下：

template<typename T> class my_vector { public: typedef typename my_vector_iterator<T> iterator; private: iterator start; iterator finish; iterator end_of_storage; protected: iterator insert_aux(T item); public: my_vector():start(0),finish(0),end_of_storage(0){} ptrdiff_t size() { return finish-start; } void empty() { finish=start; } void push_back(T item) { if(finish!=end_of_storage) { *finish=item; ++finish; } else { insert_aux(item); } } void pop_back() { if(finish!=start) { --finish; } else return ; } iterator begin() { return start; } iterator end() { return finish; } T front() { return *start; } T back() { return *(finish-1); } T& at(int i) { if(i>=size()||i<0) return NULL; return *(start+i); } T& operator[](int i) { return *(start+i); } }; template<typename T> typename my_vector<T>::iterator my_vector<T>::insert_aux(T item) { if(this->finish!=this->end_of_storage) { push_back(item); return finish; } else { int i=0; iterator new_start,old_start; ptrdiff_t capacity=2*(end_of_storage-start)+1; new_start=(T*)__my_default_alloc_template<0,0>::allocate(sizeof(T)*capacity); for(old_start=start;old_start!=finish;++old_start,++i) { *(new_start+i)=*old_start; } *(new_start+i)=item; finish=new_start+(end_of_storage-start)+1; __my_default_alloc_template<0,0>::deallocate(start,(end_of_storage-start)*sizeof(T)); start=new_start; end_of_storage=new_start+capacity; return finish; } }