从头到尾实现vector
在实现vector容器之前，我们要先了解STL中的各大组件之前的关系：
从图片中，我们可以看出vector容器是基于空间配置器和迭代器的基础上实现的。用过STL都知道，每一个容器都有自己的专属迭代器，然后这些容器都有相同之处，也有不同之处。因此我们只需要每个容器的迭代器都继承同一个迭代器的基类，去实现我们各自的迭代器。下面首先实现的就是迭代器，在STL源码剖析这个书中，vector迭代器迭代器就是一个指针，但是，本人理解不太符合STL的架构，STL架构中明显每个迭代器都要继承迭代器基类，因此本人设计的迭代器也是继承了基类的迭代器。
//iterator_vector.h
#ifndef VECTOR_ITERATOR_H_INCLUDED
#define VECTOR_ITERATOR_H_INCLUDED
#include"my_iterator_base.h"
namespace juine
{
template<typename _T>
class Iterator_vector:public Iterator_base<_T>
{
public:
typedef random_access_iterator_tag iterator_category;
//构造函数,copy构造函数，copy函数
Iterator_vector(_T* p=0):Iterator_base<_T>(p){}
Iterator_vector(const Iterator_vector& iter):Iterator_base<_T>(iter.point){}
Iterator_vector operator=(Iterator_vector iter)
{
this->point=iter.point;
return *this;
}
//注意 ，好好理解析构函数该怎么写
~Iterator_vector(){}
//随机迭代器能够支持迭代器+,-，--操作
Iterator_vector& operator++()
{
this->point++;
return *this;
}
Iterator_vector operator++(int)
{
Iterator_vector tmp=*this;
++*this;
return tmp;
}
Iterator_vector operator+(size_t n)
{
Iterator_vector iter;
iter.point=(this->point)+n;
return iter;
}
Iterator_vector operator--()
{
this->point--;
return *this;
}
Iterator_vector operator--(int)
{
Iterator_vector tmp=*this;
--*this;
return tmp;
}
Iterator_vector operator-(size_t n)
{
Iterator_vector iter;
iter.point=(this->point)-n;
return iter;
}
int operator-(Iterator_vector iter)
{
return (this->point)-iter.point;
}
bool operator<=(Iterator_vector iter)
{
return this->point<=iter.point;
}
//返回迭代器中的指针(这不是一个好办法，暴漏的内部实现细节)
typename Iterator_base<_T>::pointer& get_pointer()
{
return this->point;
}
};
}
#endif // VECTOR_ITERATOR_H_INCLUDED
接下来是容器的实现，从我们使用vector就可以看出，vector的成员变量应该就是iterator，用来指示容器的起始地址和终止地址的。其实现如下：
//my_vector.h
#ifndef MY_VECTOR_H_INCLUDED
#define MY_VECTOR_H_INCLUDED
#include"iterator_vector.h"
#include"my_iterator_function.h" //for my_distance
#include"simple_allocator.h" //for simple_alloc
#include<cstddef> //for ptrdiff_t
#include<cstdlib>
using std::cout;
using std::endl;
namespace juine
{
template<typename T,typename ALLOC=my_alloc>
class my_vector
{
public:
typedef T value_type;
typedef T& reference;
typedef T* pointer;
typedef size_t size_type;
typedef Iterator_vector<T> iterator; //vector<int>::iterator
typedef simple_allocator<T,ALLOC> data_container;
private:
iterator start;
iterator finish;
iterator end_of_range;
protected:
void fill_uninitialized(size_t n,value_type value)
{
pointer p =data_container::alloc(n);
uninitialized_fill_n(p,n,value);
start.get_pointer()=p;
finish=start+n;
end_of_range=finish;
}
void fill_uninitialized(Iterator_base<T> first,Iterator_base<T> last)
{
int n=last-first;
pointer p =data_container::alloc(n);
pointer temp=p;
while(first!=last)
{
construct(p,*first);
p++;
first++;
}
start.get_pointer()=temp;
finish=start+n;
end_of_range=finish;
}
void fill_uninitialized(pointer first,pointer last)
{
int n=last-first;
pointer p =data_container::alloc(n);
pointer temp=p;
while(first<last)
{
construct(p,*first);
p++;
first++;
}
start.get_pointer()=temp;
finish=start+n;
end_of_range=finish;
}
/*template<class InputIterator>
void fill_uninitialized(InputIterator first,InputIterator last)
{
int n=last-first;
pointer p =data_container::alloc(n);
pointer temp=p;
while(first!=last)
{
construct(p,*first);
p++;
first++;
}
start.get_pointer()=temp;
finish=start+n;
end_of_range=finish;
}*/
//容器在不需要以后释放内存
void dealloc()
{
cout<<"容器释放内存！"<<endl;
destroy(start.get_pointer(),finish.get_pointer());
data_container::dealloc(start.get_pointer());
}
public:
explicit my_vector():start(0),finish(0),end_of_range(0){ cout<<"默认vector构造函数"<<endl;}
explicit my_vector(int n,int value):end_of_range(0)
{
fill_uninitialized(n,value);
}
my_vector(pointer first,pointer last):end_of_range(0)
{
fill_uninitialized(first,last);
}
my_vector(const Iterator_base<T>& first,const Iterator_base<T>& last):end_of_range(0)
{
fill_uninitialized(first,last);
}
/*template<class InputIterator>
my_vector(InputIterator first,InputIterator last):end_of_range(0)
{
fill_uninitialized(first,last);
}*/
~my_vector(){ dealloc() ;}
iterator& begin(){ return start; }
iterator& end(){ return finish; }
size_type size(){ return finish-start; }
size_type capacity(){ return end_of_range-start; }
bool empty(){ return start==finish; }
value_type& front(){ return *start; }
value_type& back(){ return *(finish-1); }
value_type& operator[](size_type n)
{
iterator iter=start+n;
return *iter;
}
value_type& at(size_type n)
{
iterator iter=start+n;
if(finish<=iter)
{
cout<<"out of memory"<<endl;
exit(1);
}
return *iter;
}
void pop_back()
{
finish--;
destroy(finish.get_pointer());
}
void insert(iterator position,value_type value)
{
if(end_of_range!=finish)
{
iterator temp=finish;
while(temp!=position)
{
*temp=*(temp-1);
temp--;
}
construct(position.get_pointer(),value);
finish++;
}
else
{
size_type len=(size()==0)?1:size()*2;
size_type length=size()+1;
pointer p=data_container::alloc(len);
pointer temp=p;
iterator first=start;
iterator last=finish;
while(first!=last)
{
construct(p,*first);
p++;
first++;
}
construct(p,value);
//释放掉以前的内存，防止内存泄漏
destroy(start.get_pointer(),finish.get_pointer());
data_container::dealloc(start.get_pointer());
start.get_pointer()=temp;
finish=start+length;
end_of_range=start+len;
}
}
template<class InputIterator>
void insert(iterator position,InputIterator first,InputIterator last)
{
int num=last-first;
if((end_of_range-finish)>=num)
{
iterator my_temp=finish+(num-1);
while(my_temp!=(position+(num-1)))
{
*my_temp=*(my_temp-num);
my_temp--;
}
while(first!=last)
{
construct(position.get_pointer(),*first);
position++;
first++;
}
finish=finish+num;
}
else
{
size_type len=(capacity()>(size_type)(last-first)*2)?capacity()*2:(capacity()+(last-first)*2);
size_type length=size()+(last-first);
pointer p=data_container::alloc(len);
pointer temp=p;
iterator temp1=start;
while(temp1!=position)
{
construct(p,*temp1);
p++;
temp1++;
}
while(first!=last)
{
construct(p,*first);
p++;
first++;
}
while(temp1!=finish)
{
construct(p,*temp1);
p++;
temp1++;
}
//释放掉以前的内存，防止内存泄漏
destroy(start.get_pointer(),finish.get_pointer());
data_container::dealloc(start.get_pointer());
start.get_pointer()=temp;
finish=start+length;
end_of_range=start+len;
}
}
void push_back(value_type value){ insert(finish,value); }
void erase(iterator position)
{
if(finish<=position)
{
cout<<"删除已越界，失败！"<<endl;
return ;
}
while(position!=finish-1)
{
*position=*(position+1);
++position;
}
pop_back();
}
void erase(iterator first,iterator last)
{
if(last==finish)
{
destroy(first.get_pointer(),last.get_pointer());
finish=first;
}
else
{
iterator temp=last;
iterator temp1=first;
while(temp!=finish)
{
*temp1=*temp;
temp1++;
temp++;
}
int len=my_distance(first,last);
destroy((finish-len).get_pointer(),finish.get_pointer());
finish=finish-len;
}
}
void clear(){ erase(start,finish); }
};
}
#endif // MY_VECTOR_H_INCLUDED
然后就是测试代码：
//test_vector.cpp
#include<iostream>
#include<typeinfo>
#define _USE_ALLOC
#include"my_vector.h"
using namespace std;
using namespace juine;
int main()
{
int a[6]={1,2,3,4,5,6};
my_vector<int> vec(a,a+6);
vec.back()+=vec.front();
vec.front()+=vec.back();
my_vector<int>::iterator iter;
for(iter=vec.begin();iter!=vec.end();iter++)
cout<<*iter<<endl;
cout<<"3:"<<vec[3]<<endl;
cout<<"1:"<<vec.at(1)<<endl;
cout<<"大小为:"<<vec.size()<<endl;
cout<<"删除:"<<endl;
vec.erase(vec.begin()+3,vec.end()-1);
for(iter=vec.begin();iter!=vec.end();iter++)
cout<<*iter<<endl;
my_vector<int> vec1(4,4);
vec1.push_back(1);
cout<<"capacity:"<<vec1.capacity()<<endl;
vec1.push_back(2);
cout<<"插入："<<endl;
vec1.insert(vec1.begin()+1,vec.begin(),vec.end());
for(iter=vec1.begin();iter!=vec1.end();iter++)
cout<<*iter<<endl;
cout<<"容量:"<<vec1.capacity()<<endl;
return 0;
}
结果截图：
从运行结果上来看，已基本实现STL容器vector的功能，已达到我们的预期