vector
vector是C++标准模板库中的部分内容，中文偶尔译作“容器”，但并不准确。它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。
【文件包含】
1，头文件#include<vector>
2，加上using namespace std;
【vector操作】
一，vector的初始化：
（1），vector<int> a(10);//定义10个int型元素的向量，每个元素值不确定。
（2），vector<int> a(10,1)//定义10个int型元素的向量，并且把每个元素赋初值1
（3），vector<int> a(b)//用b向量创建a向量。
（4），vector<int> a(b.begin(),b.begin()+2)//定义a值是b中第0个到第2个（共三个）元素。
（5），int b[] = {0,1,2,3,};vector<int> a(b,b+4)//从数组中获初值。
（6），vector <int> a = {0,1,2,3}//自定义初值
二，vector对象的常用操作函数！
vector::assgin( num , value ); 将新内容分配给向量，替换其当前内容，并相应地修改其大小。(nun是要分配的元素个数，value是每个元素的值)
vector <int> a;//其size = 0，capacity = 0；
a.assgin(2,3);//size=2，capacity=2，a[0]=a[1]=3;vector::front();返回容器中第一个元素的引用。
vector::back():返回容器中最后一个元素的引用。
vector::begin();返回容器中第一个元素的迭代器。
vector::end();返回容器中最后一个元素的下一个位置的迭代器。
vector::clear();删除容器的所有元素，使size=0，但是capacity不改变
vector::empty();判断容器是否为空，true表示容器size=0。
vector::push_back();在容器尾部插入
vector <int> a;
a.push_back(0);
a.push_back(1);
a.push_back(2);vector::pop_back();在容器尾部删除。
vector::erase迭代器删除
iterator erase(iterator pos);
iterator erase (iterator first, iterator last);
vector <int> a;
for (int i = 1; i <= 10; ++i)
{
a.push_back(i);
}
a.erase(a.begin() + 5); //删除第5个位置的元素（从第0个位置开始）。还剩 1 2 3 4 5 7 8 9 10
a.erase(a.begin(), a.begin() + 5);//删除位置[0,5)第元素。还剩7 8 9 10vector::insert插入
iterator insert (iterator pos, val);在pos位置插入val
a.insert(b.begin()+1,100);//在b的第1个位置（从第0个开始）100void insert (iterator pos, n, val);在pos位置，插入n个val；
a.insert(b.begin()+1,3,100);//在b的第1个位置（从第0个开始）插入3个数，每个数都是100；void insert (iterator pos, InputIterator first, InputIterator last)
vector <int> a;
int b[] = {1,2,3,4};
a.insert(a.begin(),b+1,b+3);//从a的第0个位置开始，插入b的第1个到第2个（不包括第3个）元素。vector::size(); 返回容器中元素的个数；
vector <int> a = {0,1,2,3,4};
int n = a.size;//n=5;vector::capacity(); 返回容器在内存中总共可以容纳的元素个数
vector::a.resize(num); 将容器的现有元素个数调至num个，多则删，少则补，其值随机
vector::a.resize(num,value); 将a的现有元素个数调至num个，多则删，少则补，其值补为value
vector <int> a = {0,1,2}；
a.resize(5);//size=5,其元素为0，1，2，0，0
a.resize(8,2);//size=8，其元素为0，1，2，0，0，2，2，2vector:: void reserve(newcapacity); 将a的容（capacity）扩充至newcapacity，但是当newcapacity< a.capacity时则不会发生变化。也就是说现在测试a.capacity();的时候返回值是newcapacity.这种操作只有在需要给a添加大量数据的时候才 显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能）
vector <int> a(10,10);//a.capacity=10
a.reserve(100);//a.capacity=100;
a.reserve(50);//capacity不会发生变化，还是100vector:swap( vector & x ); 将a和x的元素全部交换
vector <int> a = {1,2,3};
vector <int> b = {4,5,6,7,8};
a.swap(b);//a是4，5，6，7，8；b是1，2，3vector:operator [] (size_t pos);返回对矢量容器中位置n的元素的引用
vector <int> a={1,2,3,4};
cout<<a[0]<<endl;//输出1【误区，一种错误的操作】
vector <int> a;
for(int i=0;i<10;++i)
{
a[i]=i;
}
//该操作是错误的，下标只能访问已存在的元素，而a[i]还没创建【读取元素的方法】
1，下标访问
vector <int> a = {0,1,2,3,4};
for(int i=0;i<a.size();++i)
{
cout<<a[i];
}2，通过遍历器方式
vector <int> a = {0,1,2,3,4};
vector <int>::iterator it；
for (i = d.begin(); i < d.end(); ++i)
{
cout << *i;
} 简单模拟实现vector
#include<iostream>
#include<stdio.h>
using namespace std;
template <class T>
class my_vector
{
public:
typedef T* Iterator;
my_vector()
{
_start = NULL;
_finish = NULL;
_endofstorage = NULL;
}
my_vector(size_t n, const T& value = T()) //构造函数，构造一个里面有n个相同值的顺序表
:_start(new T[n])
{
for (size_t idx = 0; idx<n; ++idx)
_start[idx] = value;
_finish = _start + n;
_endofstorage = _finish;
}
my_vector(const my_vector<T>& v)
{
size_t capacity = v._endofstorage - v._start;
_start = new T[capacity];
size_t size = v._finish - v._start;
for (size_t i = 0; i < size; ++i)
{
_start[i] = v._start[i];
}
_finish = _start + size;
_endofstorage = _start + capacity;
}
my_vector<T>& operator = (const my_vector<T>& v) //赋值运算符重载
{
if (this != &v)
{
size_type capacity = v._endofstorage - v._start;
size_type size = v._finish - v._start;
if (Capacity() < size)
{
_start = new T[capacity];
for (size_type idx = 0; idx<size; ++idx)
{
_start[idx] = v._start[idx];
}
_finish = _start + size; //不能用_finish = v._finish;因为改变指向会引发错误
_endofstorage = _start + capacity;
}
}
return *this;
}
~my_vector()
{
if (_start)
{
delete[] _start;
_start = NULL;
_finish = NULL;
_endofstorage = NULL;
}
}
Iterator Begin()
{
return _start;
}
Iterator End()
{
return _finish;
}
T& Front()
{
return *_start;
}
T& Back()
{
return*(--_finish);
}
size_t Capacity()const
{
return (_endofstorage - _start);
}
size_t Size()
{
return _finish - _start;
}
bool Empty()const//判断是否是为空
{
return _start == _finish;
}
T& operator[](size_t indix)
{
return _start[indix];
}
void PushBack(const T& x)//尾插
{
CheckCapacity();
Insert(_finish, x);
}
Iterator Insert(Iterator pos, const T& x)// 在pos位置上插入元素x
{
CheckCapacity();
Iterator it = _finish;
while (it > pos)
{
*it = *(it - 1);
--it;
}
*pos = x;
_finish++;
return pos;
}
Iterator Erase(Iterator pos) // 删除pos位置上面的元素
{
Iterator it = pos;
while (it < _finish - 1)
{
*it = *(it + 1);
++it;
}
--_finish;
return pos;
}
private:
void CheckCapacity()
{
if (_finish >= _endofstorage)
{
size_t newcapacity = 2 * (_endofstorage - _start) + 3;
T* tmp = new T[newcapacity];
size_t size = _finish - _start;
for (size_t i = 0; i < size; ++i)
{
tmp[i] = _start[i];
}
delete[] _start;
_start = tmp;
_finish = _start + size;
_endofstorage = _start + newcapacity;
}
}
void Swap(my_vector<T>& V)
{
std::swap(_start, V._start);
std::swap(_finish, V._finish);
std::swap(_endofstorage, V._endofstorage);
}
private:
Iterator _start;
Iterator _finish;
Iterator _endofstorage;
};