迭代器实现Vector

vector模型是一个动态数组，它本身是“将元素至于动态数组中加以管理”的一个抽象概念，但是c++标准并未要求以动态数组实作vector。

在使用标准库里面的vector时，必须包含头文件

#include<vector>

其中型别vector是一个定义于namespace std的template。

namespace std{
template<class T,class Allocator =allocator<T>>
class vector;
}

通过查看标准库里面的vector函数，利用迭代器Iterator，模拟实现vector，代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
template<typename T>
class Vector
{
public:
typedef T* Iterator;
Vector()
:_start(0)
, _finish(0)
, _endOfstorage(0)
{}
Vector(const T* str, size_t size)//构造size个元素
:_start(new T[size])
, _finish(_start)//（没放空间时）//_finish(_start+size)（放了空间）
, _endOfstorage(_start + size)
{
//memcpy(_start,str,sizeof(T)*size);
for (size_t i = 0; i<size; ++i)
{
*_finish++ = str[i];//_start[i]=str[i];
}
}
Vector(const Vector<T>& v)//拷贝构造函数
{
size_t size = Size();
_start = new T[size];
for (size_t i = 0; i<size; i++)
{
_start[i] = v._start[i];
}
_finish = _start + size;
_endOfstroage = _finish;
}
Vector& operator=(const Vector<T>& v)//赋值运算符重载
{
size_t size = v.Size();
if (this != &v)
{
T*tmp = new T[size];
for (size_t i = 0; i<size; i++)//深拷贝
{
tmp[i] = _start[i];
}
delete[] _start;
_start = tmp;
_finish = _start + size;
_endOfstorge = _finish;
}
return *this;
}
~Vector()
{
if (_start)
{
delete[] _start;
_start = NULL;
}
}
//////////////////////Iterator////////////////////////////
Iterator Begin()    //迭代器
{
return _start; //Begin和_start类型一致
}
Iterator End()
{
return _finish;
}
///////////////////Modify////////////////////////////////
void PushBack(const T& data)
{
CheckCapacity();
*_finish = data;
++_finish;
}
void PopBack()
{
--_finish;
}
void Insert(size_t pos, const T& data)
{
size_t size = Size();
CheckCapacity();
assert(pos<size);
for (size_t i = size; i>pos; --i)
{
_start[i] = _start[i - 1];
}
_start[pos] = data;
++_finish;
}
void Erase(size_t pos)
{
size_t size = Size();
assert(pos<size)
for (size_t i = pos; i<size; i++)
{
_start[i] = start[i + 1];
}
--_finish;
}

//////////////////capacity////////////////////////////
size_t Size()const
{
return _finish - _start;
}
size_t CapaCity()const
{
return _endOfstorage - _start;
}
bool Empty()const//判空
{
if (_atart == _finish)
{
return true;
}
return false;
}
void Resize(size_t newSize, const T& data = T())//改变大小
{
size_t size = Size();//原来元素大小
size_t capacity = CapaCity();//原来容量
//1.newSize比size小
if (newSize<size)
{
_finish == _start + newSize;
}
//2.newSize比size大，但比capacity小
else if (newSize>size&&newSize<capacity)
{
for (size_t i = size; i<newSize; i++)
{
//*finish++=data;
_start[i] = data;
}
_finish = _start + newSize;
}
//newSize比capacity大
else
{
T* tmp = new T[newSize];//开辟新空间
for (size_t i = 0; i<size; i++)//搬移原空间的元素
{
tmp[i] = _start[i];
}
for (size_t i = size; i<newSize; i++)//把新增加的元素加进来
{
tmp[i] = data;
}
delete[] _start;//释放旧空间
_start = tmp;
_finish = _start + newSize;
_endOfstorage = _finish;
}
}

//////////////Element Acess(元素访问)///////////////////////////
T& operator[](size_t index)//随机访问（下标）
{
size_t capacity = CapaCity();
assert(index <= capacity);
return _start[index];
}
const T& operator[](size_t index)const
{
size_t capacity = C
ab86
apaCity();
assert(index <= capacity);
return _start[index];
}
T& Front()
{
return *_start;
}
const T& Front()const
{
return *_start;
}
T& Back()
{
return *(_finish - 1);
}
const T& Back()const
{
return *(_finish - 1);
}
void Clear()
{
_finish = _start;
}

friend ostream& operator<<(ostream& os, const Vector<T>& v)
{
for (size_t i = 0; i<v.Size(); i++)
{
os << v[i] << " ";
}
os << endl;
return os;
}
/*friend ostream& operator<<(ostream& os,  Vector<T>* v)//通过迭代器重载
{
Vector<int>::Iterator it = v.Begin();
while(it!=v.End())
{
cout<<*it<<" ";
++it;
}
os << endl;
return os;
}*/
private:
void CheckCapacity()
{
size_t size = Size();
size_t capacity = CapaCity();
size_t newcapacity = 2 * capacity + 2;
if (size >= capacity)
{
//增容
T* tmp = new T[newcapacity];
//拷贝元素
//if(_start)
//memcpy(tmp,_start,size*sizeof(T));//浅拷贝（导致两个字符串公用同一块空间）但是效率高
//出了函数作用域，要销毁v，销毁旧空间时出现问题
for (size_t i = 0; i<size; i++)
{
tmp[i] = _start[i];
}
delete[] _start;//释放旧空间
_start = tmp;
_finish = _start + size;
_endOfstorage = _start + newcapacity;
}
}

private:
T* _start;
T* _finish;
T* _endOfstorage;
};
void TestVector()//测试函数
{
int arr[]={1,2,3,4};
Vector<int>v(arr,sizeof(arr)/sizeof(arr[0]));
cout<<"Size="<<v.Size()<<endl;
cout<<"Capacity="<<v.CapaCity()<<endl;
cout<<v<<endl;
Vector<int>::Iterator it=v.Begin();
while(it!=v.End())
{
cout<<*it<<" ";
++it;
}
cout<<endl;
v.PushBack(5);
cout << v << endl;
v.Insert(0, 0);
cout << v << endl;

v.Resize(20);
cout << "Size=" << v.Size() << endl;
cout << "Capacity=" << v.CapaCity() << endl;

v.Clear();
cout << "Size=" << v.Size() << endl;
cout << "Capacity=" << v.CapaCity() << endl;
}

int main()
{
TestVector();
system("pause");
return 0;
}