1.vector的介绍及使用
1.1 vector的介绍
- vector是表示可变大小数组的序列容器
- 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高校。但是又不像数组，它的大小是可以动态改变的，而且他的大小会被容器自动处理。
- 本质上，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
- vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存 储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
- 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增 长。
- 与其它动态序列容器相比（deques, lists and forward_lists）， vector在访问元素的时候更加高效，在 末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和 forward_lists统一的迭代器和引用更好。
1.2 vector的使用
1.2.1 vector的定义
vector () 无参构造
vector(size_type n,const value_type& val = value_type()) 构造并初始化n个val
vector(const vector& x); 拷贝构造
vector(inputIterator first,inputIterator last); 使用迭代器进行初始化构造
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> v1;
vector<int> v2(4, 10);
vector<int> v3(v2.begin(), v2.end());
vector<int> v4(v3);
vector<int>::iterator it = v4.begin();
while (it != v4.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}测试结果如下：
1.2.2 vector iterator 的使用
begin() 获取第一个数据位置的iterator
end() 获取最后一个数据的下一个位置的iterator
rbegin() 获取最后一个数据位置的reverse_iterator
rend() 获取第一个数据前一个位置的reverse_iterator
cbegin() 获取第一个数据位置的const_iterator
cend() 获取最后一个数据的下一个位置的const_iterator
int main()
{
//使用push_back插入4个数据
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
//使用迭代器进行遍历打印
vector<int>::iterator it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
/*使用迭代器进行修改*/
it = v.begin();
while (it != v.end())
{
*it *= 2;
++it;
}
//使用反向迭代器进行遍历打印
vector<int>::reverse_iterator rit = v.rbegin();
while (rit != v.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
//使用const迭代器进行遍历打印
vector<int>::const_iterator cit = v.cbegin();
while (cit != v.cend())
{
cout << *cit << " ";
++cit;
}
cout << endl;
return 0;
}测试结果如下：
1.2.3 vector 空间增长问题
size() 获取数据个数
capacity() 获取容量大小
empty() 判断是否为空
void resize(size_type n,value_type val=value_type()); 改变vector的size
void reserve(size_type n); 改变vector放入capacity
- capacity的代码在vs下和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。vs是PJ版本的STL，g++是SGI版本的STL
- reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vecror增容的代价缺陷问题
- resize在开空间的同时还会进行初始化，影响size。
//vector::capacity
int main()
{
size_t sz;
vector<int> v;
sz = v.capacity();
cout << "making v grow: \n";
for (int i = 0; i < 100; ++i)
{
v.push_back(i);
if (sz != v.capacity())
{
sz = v.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
return 0;
}测试结果如下：
vs下
g++下：
//vector::reserve
int main()
{
size_t sz = 0;
vector<int> v;
cout << "making v grow: \n";
for (int i = 0; i < 100; ++i)
{
v.push_back(i);
if (sz != v.capacity())
{
sz = v.capacity();
cout << "capacity changed: " << sz << endl;
}
}
vector<int> bar;
sz = bar.capacity();
bar.reserve(100);
cout << "making bar grow: \n";
for (int i = 0; i < 100; ++i)
{
bar.push_back(i);
if (sz != bar.capacity())
{
sz = bar.capacity();
cout << "capacity changed: " << sz << endl;
}
}
return 0;
}运行结果如下：
//vector::resize
int main()
{
size_t sz;
vector<int> v;
for (int i = 1; i < 10; ++i)
{
v.push_back(i);
}
v.resize(5);
v.resize(8,100);
v.resize(12);
cout << "v contains:";
for (int i = 0; i < v.size(); ++i)
{
cout << ' ' << v[i];
}
cout << endl;
cout << v.size() << endl;
return 0;
}运行结果如下：
1.2.3 vector 增删查改
void push_back(const value_type& val); 尾插
void pop_back(); 尾删
InputIterator find(InputIterator first,InputIterator last,const T& val); 查找
iterator insert(iterstor position,const value_type& val); 在position之前插入val;
iterator earse(iterator position); 删除position位置的数据
void swap(vector& x); 交换两个vector的数据空间
reference operator[](size_type n); 像数组一样访问
//push_back/pop_back
int main()
{
int a[] = { 1, 2, 3, 4, 5 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
vector<int>::iterator it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
v.push_back(6);
v.push_back(6);
v.pop_back();
it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
return 0;
}运行结果如下：
//find/insert/erase
int main()
{
int a[] = { 1, 2, 3, 4, 5 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
//使用find查找3所在位置的iterator
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
//在pos位置之前插入30
v.insert(pos, 30);
vector<int>::iterator it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
//删除pos位置的数据
pos = find(v.begin(), v.end(), 3);
v.erase(pos);
it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
return 0;
}运行结果如下：
//operaor[]+index 和C++11中vector的新式for+auto遍历
//vector使用这两种便利方式是比较便捷的
int main()
{
int a[] = { 1, 2, 3, 4, 5 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
//通过[]读写第0个位置
v[0] = 10;
cout << v[0] << endl;
//通过[i]的方式遍历vector
for (size_t i = 0; i < v.size(); ++i)
{
cout << v[i] << " ";
}
cout << endl;
vector<int> swapv;
swapv.swap(v);
cout << "v data:";
for (size_t i = 0; i < v.size(); ++i)
{
cout << v[i] << " ";
}
cout << endl;
cout << "swapv data:";
for (size_t i = 0; i < swapv.size(); ++i)
{
cout << swapv[i] << " ";
}
cout << endl;
//C++11支持的新式遍历
for (auto e : swapv)
{
cout << e << " ";
}
cout << endl;
return 0;
}运行结果如下：
1.2.4vector迭代器失效问题
// insert/erase导致的迭代器失效
int main()
{
int a[] = { 1, 2, 3, 4, 5 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
//使用find查找3所在位置的iterator
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
//删除pos位置的数据，导致pos迭代器失效
v.erase(pos);
cout << *pos << endl;//此处会导致非法访问
//在pos位置插入数据，导致pos迭代器失效
//insert会导致迭代器失效，是因为insert可能会导致增容
//增容后pos还指向原来的空间，而原来的空间已经释放了
pos = find(v.begin(), v.end(), 3);
v.insert(pos, 30);
cout << *pos << endl;//此处会导致非法访问
return 0;
}//常见的迭代器失效的场景
int main()
{
int a[] = { 1, 2, 3, 4, 5 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
//实现删除v中所有偶数
//下面的程序会崩溃掉，如果是偶数，erase导致it失效
//对失效的迭代器进行++it，会导致程序崩溃
vector<int>::iterator it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
v.erase(it);
++it;
}
}
//以上程序要改成下面这样，erase会返回 删除位置的下一个位置
vector<int>::iterator it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
it = v.erase(it);
}
else
{
++it;
}
}
return 0;
}
2.模拟实现vector
vector.hpp
#include <iostream>
#include <assert.h>
using namespace std;
namespace zdy
{
template<class T>
class Vector
{
public:
typedef T* Iterator;
typedef const T* ConstIterator;
Iterator begin()
{
return _start;
}
Iterator end()
{
return _finish;
}
ConstIterator cbegin() const
{
return _start;
}
ConstIterator cend() const
{
return _finish;
}
size_t Size() const
{
return _finish - _start;
}
size_t Capcity() const
{
return _endofstorage - _start;
}
Vector()
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{}
Vector(int n, const T&value = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
Reserve(n);
while (n--)
{
PushBack(value);
}
}
template<class InputIterator>
Vector(InputIterator first, InputIterator last)
{
Reserve(last - first);
while (first != last)
{
PushBack(*first);
++first;
}
}
Vector(const Vector<T> &v)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
Reserve(v.Capcity);
Iterator it = begin();
ConstIterator vit = v.cbegin();
while (vit != v.Cend())
{
*it++ = *vit++;
}
_finish = _start + v.Capcity();
_endofstorage = _start + v.Capcity();
}
Vector<T>& operator = (Vector<T> v)
{
Swap(v);
return *this;
}
~Vector()
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
void Reserve(size_t n)
{
if (n > Capcity())
{
size_t size = Size();
T* tmp = new T[n];
if (_start)
{
for (size_t i = 0; i < size; ++i)
{
tmp[i] = _start[i];
}
}
_start = tmp;
_finish = _start + size;
_endofstorage = _start + n;
}
}
void Resize(size_t n, const T& value=T())
{
if (n < size())
{
_finish = _start + n;
return;
}
if (n>Capcity())
{
Reserve(n);
}
Iterator it = _finish;
Iterator _finish = _start + n;
while (it != _finish)
{
*it = value;
++it;
}
}
void Swap(Vector<T>& v)
{
swap(_start, v._start);
swap(_finish, v._finish);
swap(_endofstorage, v._endofstorage);
}
void PushBack(const T& x)
{
Insert(_finish,x);
}
void PopBack()
{
Earse(_finish - 1);
}
void Insert(Iterator pos, const T& x)
{
assert(pos <= _finish);
size_t offset = pos - _start;
//空间不够先增容
if (_finish == _endofstorage)
{
size_t newcapcity = Capcity() == 0 ? 2 : Capcity() * 2;
Reserve(newcapcity);
pos = _start + offset;
}
Iterator end = _finish;
while (end > pos)
{
*end = *(end - 1);
--end;
}
*pos = x;
++_finish;
}
Iterator Earse(Iterator pos)
{
assert(pos < _finish);
Iterator begin = pos;
while (begin < _finish - 1)
{
*begin = *(begin + 1);
++begin;
}
--_finish;
return pos;
}
T& operator[](size_t pos)
{
return _start[pos];
}
private:
Iterator _start;
Iterator _finish;
Iterator _endofstorage;
};
}main.cpp
#include "vector.hpp"
using namespace zdy;
#include<vector>
void Test1()
{
Vector<int> v1;
v1.PushBack(1);
v1.PushBack(2);
v1.PushBack(3);
v1.PushBack(4);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
zdy::Vector<int>::Iterator it = v1.begin();
while (it != v1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
for (size_t i = 0; i < v1.Size(); ++i)
{
cout << v1[i] << " ";
}
cout << endl;
}
void Test2()
{
Vector<int> v2;
v2.PushBack(1);
v2.PushBack(2);
v2.PushBack(3);
v2.PushBack(4);
zdy::Vector<int>::Iterator it = v2.begin();
while (it != v2.end())
{
if (*it % 2 == 0)
{
it = v2.Earse(it);
}
else
{
++it;
}
}
v2.PopBack();
for (auto e : v2)
{
cout << e << " ";
}
cout << endl;
}
int main()
{
Test1();
Test2();
return 0;
}
2262
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
