vector:能够操作多种数据结构和算法的模板类和函数库的C++标准模板库;是一个容器可以存放任意类型的对象,所以可以看作是一个能够存放任意类型的动态数组或顺序表。
STL里的vector是由三个指针来维护的:_start(数据存放开始的位置),_finish(数据存放结束位置的下一个),_endofstorage(容量的最后一个位置)。
Vector的简单使用:
^使用vector需要加上头文件#include<vector>
;
^vector属于std命名域,前面需写上using namespace std;
^vector<int> vec(n);
像数组一样可以存放n个int型数据;
^ vec[i]=2;
像数组一样访问修改数据;
^可以装入自定义的数据类型
struct AA{ };
vector<AA> vec;
^定义容器的时候可以进行初始化,并可以给其他容器对象赋值
vector<int> vec1(15,0);//容纳15个int类型的数据,初值为0;
vector<int> vec2;
vec2=vec1;
^对于容器,使用迭代器操作容器中对应位置的值,当迭代器指向了容器中的某位置,则可以使用 * 加迭代器操作该位置了.
Vector函数实现功能:
vector vec;
vec.clear() 移除容器中所有数据。
vec.empty() 判断容器是否为空。
vec.erase(pos) 删除pos位置的数据
vec.insert(pos,elem) 在pos位置插入一个elem拷贝
vec.pop_back() 删除最后一个数据。
vec.push_back(elem) 在尾部加入一个数据。
vec.resize(num) 重新设置该容器的大小
vec.size() 回容器中实际数据的个数。
vec.begin() 返回指向容器第一个元素的迭代器
vec.end() 返回指向容器最后一个元素的迭代器
Vector的简单实现:
#include<iostream>
#include<stdlib.h>
#include<assert.h>
using namespace std;
template<class T>
class Vector
{
public:
typedef T* Iterator;
typedef const T* ConstIterator;
Vector()
:_start(NULL)
, _finish(NULL)
, _endofstorage(NULL)
{}
Iterator Begin()
{
return _start;//第一个元素的位置
}
Iterator End()
{
return _finish;//最后一个元素的下一个位置
}
size_t Size()
{
return _finish - _start;
}
size_t Capacity()
{
return _endofstorage - _start;
}
void PushBack(const T& x)
{
Iterator end = End();
Insert(end, x);
}
void PopBack()
{
assert(Size() > 0);
Erase(End());
}
void Insert(Iterator pos, const T& x)
{
size_t n = pos - _start;
//插入前应该先检查容量
if (_finish == _endofstorage)
{
size_t len = Size() == 0 ? 2 : 2 * Capacity();
Expand(len);
}
pos = _start + n;
//把pos位置之后的数据往后挪
for (Iterator end = End(); end != pos; --end)
{
*(end) = *(end - 1);
}
*pos = x;
++_finish;
}
void Erase(Iterator pos)
{
//防御式编程,先要判断所给位置是否合法
assert(pos != NULL);
//把pos之后的数据往前挪
for (Iterator end = pos; end < End(); ++end)
{
_start[end - _start] = _start[(end + 1) - _start];
}
--_finish;
}
void Expand(size_t n)
{
size_t size = Size();
size_t capacity = Capacity();
//当需要的空间大于容量的时候,扩容并拷贝内容
if (n > capacity)
{
//vector是一个可以存放任意类型的动态数组,所以这里在扩容的时候开辟的是数组
T* ret = new T[n];
for (size_t i = 0; i < Size(); ++i)
{
ret[i] = _start[i];
}
delete[] _start;
//改变数组的指向和容量大小
_start = ret;
_finish = _start + size;
_endofstorage = _start + n;
}
}
void Resize(const size_t n, const T& val = T())
{
//当要扩充的容量小于数组的元素个数时,只改变_finish的位置,不改变_capacity的位置
if (n < Size())
{
_finish=_start - n;
}
//当要扩充的容量大于数组的元素个数时,增容之后,没有数据的位要进行初始化
else
{
Expand(n);
size_t size = n - Size();
for (size_t i = 0; i < size; ++i)
{
PushBack(val);
}
}
}
void Reverse(const size_t n)
{
//只扩容然后进行依次赋值,不进行初始化
Expand(n);
}
T& operator[](size_t pos)
{
assert(pos < Size());
return _start[pos];
}
const T& operator[](size_t pos)const
{
assert(pos < Size());
return _start[pos];
}
void Print()
{
for (size_t i = 0; i < Size(); ++i)
{
cout << _start[i] << " ";
}
cout << endl;
}
protected:
Iterator _start;//数组的首元素
Iterator _finish;//数组的元素个数
Iterator _endofstorage;//数组的容量
};
int main()
{
Vector<int> p;
p.PushBack(1);
p.PushBack(2);
p.PushBack(3);
p.PushBack(4);
p.PushBack(5);
p.PushBack(6);
Vector<int>::Iterator pos=p.Begin();
for (; pos != p.End();)
{
cout << *pos << " ";
++pos;
}
cout << endl;
p.PopBack();
p.PopBack();
Vector<int>::Iterator it=p.Begin();
p.Erase(it);
p.Resize(7,0);
p.Reverse(6);
p.Print();
system("pause");
}