自己动手写vector

最近学习c++的STL，把STL中的vector自己写了一下，写的过程中对c++进行学习。

主要的几个模块：

(1)构造析构函数、拷贝构造和赋值函数（类的几个基本函数）

（2）增加、删除函数

（3）遍历函数

（4）大小及判空函数

（5）其它（swap或者assign）

// MyVector.cpp : 定义控制台应用程序的入口点。
/*******************我的Vector实现*********************************
**功能：自己动手写stl中的vector
**作者：谢凡凡
****************************************************/
#include "stdafx.h"
#include <iostream>
#include <assert.h>

using namespace std;

//vector类模板
template <class T>
class MyVector
{
public:
typedef T* iterator;           //迭代器类型
typedef T* pointer;
typedef T & reference;
//构造函数
MyVector():start(0),endx(0),end_of_storage(0),nsize(0),ncapacity(0){}             //列表初始化  默认的构造函数
MyVector(int nSize,const T& val)                     //n个元素，且初始化为val
{
if (!nSize)
{
start = 0;
endx = 0;
end_of_storage = 0;
nsize = 0;
ncapacity = 0;
}
else
{
int iTotalLen = 1;
while (iTotalLen < nSize)                     //空间大小是2倍增长
{
iTotalLen *= 2;
}
start = new T[iTotalLen];                     //申请空间
iterator start_cc = start;
endx = start + nSize;
end_of_storage = start + iTotalLen;
nsize = nSize;
ncapacity = iTotalLen;
while(nSize--)
{
*start_cc++ = val;
}
}
}
MyVector(int nSize)                                       //n个元素，初始化为0
{
if (!nSize)
{
start = 0;
endx = 0;
end_of_storage = 0;
nsize = 0;
ncapacity = 0;
}
else
{
int iTotalLen = 1;
while (iTotalLen < nSize)
{
iTotalLen *= 2;
}
start = new T[iTotalLen];                     //申请空间
iterator start_cc = start;                    //一份拷贝
endx = start + nSize;
end_of_storage = start + iTotalLen;
nsize = nSize;
ncapacity = iTotalLen;
}
}
MyVector(const MyVector& mv)                              //拷贝构造函数
{
if (this == &mv)
{
return ;
}
if (mv.empty())
{
start = 0;
endx = 0;
end_of_storage = 0;
nsize = 0;
ncapacity = 0;
}
else
{
int iTotalLen = mv.capacity();                            //当前容器最大容量
int isize = mv.size();
start = new T[iTotalLen];
endx  = start + isize;
end_of_storage = start + iTotalLen;
nsize = isize;
ncapacity = iTotalLen;
}
}

~MyVector()                               //析构函数  注意对容器中的元素调用析构函数
{
iterator index;
for (index = start;index < end_of_storage;++index)
{
index->~T();                       //调用容器中的元素的析构函数
}
delete [] start;
start = NULL;
endx  = NULL;
end_of_storage = NULL;
nsize = 0;
}

iterator begin() const                    //获取起始迭代器
{
return start;
}
iterator end() const
{
return endx;
}

int size() const                              //返回容器中元素的个数
{
return nsize;
}
void resize(int newSize,const reference x);       //调整容器尺寸
int capacity() const                             //获取容器最多可以存储多少个元素
{
return ncapacity;
}
bool empty() const                               //容器是否为空
{
return (start == endx);
}
reference operator[](int n)                      //对下标运算符进行重载，返回该位置的一个引用
{
assert(n >= 0 && n < ncapacity);
return *(start + n);
}
reference operator=(const T& other)             //赋值运算符
{
if (this != &other)
{
if (other.empty())
{
this->clear();
}
else
{
if (ncapacity < other.capacity())                //左边空间不够  重新分配足够的空间
{
start = new T[other.capacity()];
endx  = start + other.nsize;
end_of_storage = start + other.capacity();
nsize = other.nsize;
ncapacity = other.ncapacity;
for (int index =0;index < nsize;++index)
{
*(start + index) = *(other.begin() + index);
}
}                                                //左边有足够空间  用原来的空间
else
{
endx  = start + other.nsize;
end_of_storage = start + other.capacity();
nsize = other.nsize;
ncapacity = other.ncapacity;
for (int index =0;index < nsize;++index)
{
*(start + index) = *(other.begin() + index);
}
}
}
return *this;
}
}
reference front()                         //返回首元素引用
{
return *start;
}
reference back()                          //返回尾元素引用
{
return *(endx - 1);
}
reference at(int pos)                     //返回指定位置的一个引用  超出范围应该抛出异常
{
if (pos >= 0 && pos < ncapacity)
{
return *(start + pos);
}
else                                   //抛出异常
{
throw out_of_range("MyVector out of range");
}
}

void push_back(const T& x)                 //尾端插入
{
if (endx != end_of_storage)            //容器还有余量
{
*endx = x;
nsize = nsize + 1;
endx++;
}
else                                   //容器没有余量，重新分配空间，并进行数据拷贝，然后删除原来的空间
{
insert(end(),1,x);
}
}
void insert(iterator it,const T& x)          //某一个元素前  增加一个元素x
{
insert(it,1,x);
}
void  insert(iterator it,int n,const T& x);       //某一个元素前  增加n个元素x
void pop_back()                                   //删除尾端元素
{
endx--;
endx->~T();
nsize--;
}
void erase(iterator pos)                          //删除指定位置的元素
{
erase(pos,pos+1);
}
void erase(iterator _first,iterator _end)             //删除范围元素  [_first,_end)
{
int j = end() - _end;
for (int index = 0;index < j;++index)             //后边的元素前移
{
*(_first + index) = *(_end + index);
}
while(end() - _first > j)
{
pop_back();
}
}
void clear()                                          //清除容器中的所有元素
{
erase(start,endx);
}
void swap(MyVector& other)                                   //交换数据
{
MyVector tem;
tem = other;
other = *this;
*this = tem;
}
void assign(int n,const T& x)                  //给容器中某一个位置赋值
{
*(start + n - 1) = x;
}
private:
iterator start;                //指向数据区起始地址
iterator endx;                 //指向数据区末尾地址
iterator end_of_storage;       //指向容量的末尾，一般留有多余的空间

int nsize;                     //当前容器中元素个数
int ncapacity;                 //容器可以存储最多元素个数

};

template <class T>
void MyVector<T>::insert(iterator it,int n,const T& x)       //某一个元素前  增加n个元素x
{
iterator old_start = start;               //原来的指针
iterator old_endx = endx;
iterator new_start;                       //不扩容的话  指向old_start,扩容的话指向new_start
int numofmove = (endx - it);              //从it到endx中有多少个元素需要向后移动
bool bNeedChange = false;
if (endx + n > end_of_storage)            //剩余空间不够了
{
bNeedChange = true;
const int old_size = size();
const int len = old_size + n;        //加新的元素  有多少个元素
int it1 = 1;
while (it1 < len)
{
it1 *= 2;
}

start = new T[it1];
endx = start + len;
end_of_storage = start + it1;
new_start = start;
ncapacity = it1;
nsize = len;
}
else
{
new_start = start;
endx = endx + n;
nsize = nsize + n;
}
iterator item = old_start;
while (item < it)                  //拷贝原始数据
{
*new_start++ = *item++;
}
iterator itend = endx;
iterator old_endx_cc = old_endx;
while (numofmove--)
{
*(--itend) = *(--old_endx_cc);
}
while (n--)                       //插入特定数据
{
*new_start++ = x;
}
if (bNeedChange)                 //需要释放原始空间
{
while (old_start != old_endx)
{
old_start->~T();
old_start++;
}
}
}

int _tmain(int argc, _TCHAR* argv[])
{
struct Point
{
Point(){}
Point(int a=0,int b=0):x(a),y(b){}
int x,y;
};

cout<<sizeof(Point)<<endl;
MyVector<Point>  myvec(3);
cout<<myvec.size()<<endl;

for (int i=1;i<3;++i)
{
Point ptem(i,2*i);
myvec.push_back(ptem);
}

for (MyVector<Point>::iterator it = myvec.begin();it != myvec.end();++it)
{
cout<<it->x<<" "<<it->y<<endl;
}

return 0;
}

自己写vector的一些感受：

（1）vector其实比string简单

string看似简单，其实内部函数很多，而且有很多重载函数，实现不麻烦，但是很繁琐。vector的函数较少，重载函数也不多，比较简便。

（2）vector使用的c++模板技术

这是我写vector的目的之一，学习一下模板的用法，也没那么难。使用模板技术，则该容器可以存储任意类型（包括内置类型和自定义类型）。

（3）对new运算符理解更深刻了

vector底层数据结构是动态数组，长度可以自动增长，所以使用的new分配内存。new一个内置类型很容易理解（eg. int），但是new一个类对象或者类对象数组，就复杂些了。

a.分配一块足够大的内存，足以存储类对象或者类对象数组

b.对类对象调用构造函数进行初始化

c.返回一个指针，指向分配的内存块

这里边的调用构造函数对类对象初始化，很重要。