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 10
vector::insert插入
iterator insert (iterator pos, val);在pos位置插入val
a.insert(b.begin()+1,100);//在b的第1个位置(从第0个开始)100
void 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,2
vector:: 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不会发生变化,还是100
vector: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,3
vector: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;
};