目录
1.vector的介绍
vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。与其它动态序列容器相比（deques, lists and forward_lists),vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和forward_lists统一的迭代器和引用更好。
2.vector类方法的模拟实现
2.1 vector类构造函数的实现
namespace rzp
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
//采用列表初始化 进行对指针初始化
vector()
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
}
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
}
}首先定义了相应的构造函数类型,并对其进行初始化,vector类模板中内置函数类型包括 _start,_finish,_endofstorage三种类型的模板类型指针.
其中,_start指向类模板的第一个变量的位置,_finish指向最后一个变量的下一个位置,_endofstorage-_start则对应的是整个类模板的capacity().
2.2 begin()和end()
分别指向第一个元素的迭代器指针和指向最后一个元素的迭代器指针
//通过这个接口访问刚开始的内容
iterator begin()
{
return _start;
}
//通过这个接口访问最后的内容
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}很明显,有两个begin()和end()的接口函数分别对应的意义是:第一个不带const修饰的begin()和end()，是可以进行改变的;但是加上const修饰的 const_iterator begin()是不能进行修改的,更加安全可靠.
2.3 size()、capacity()和empty()
//const修饰 不能修改更加安全
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _endofstorage - _start;
}
bool empty() const
{
return _start == _finish;
}
这里均加上const,保证数据的安全性.
2.4 运算符[]的重载
T& operator[](size_t i)
{
assert(i < size());
return _start[i];
}
//const修饰体
const T& operator[](size_t i)const
{
assert(i < size());
return _start[i];
}const修饰的话,可以防止访问权限的扩大,保证数据的安全性.
2.5 reserve()
void reserve(size_t n)
{
//要对其进行初始化
if (n > capacity())
{
//说明这时候要进行增容处理
size_t sz = size();
T* tmp = new T[n];
if (_start)
{
//memcpy(tmp, _start, sz * sizeof(T));
//用for循环进行改变
for (size_t i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}这里很明显是进行深拷贝,我们重新new了一个新的空间,利用范围for将原来空间的内容拷到新的空间中去,并最后delete删除原来的内容.这里仅仅也是对vector模板类的数据进行改变,并不会初始化开辟后空间的值.
2.6 resize()
这里的resize(),就包括将capacity()进行改变,对应分为以下三种情况:
1.n<size()
2.size()<n<capacity()
3.n>capacity()
void resize(size_t n, T val = T())
{
if (n < size())
{
//这个说明我们是要删除空间的
_finish = _start + n;
}
else
{
//此时的容量应该是size()<n<capacity()
if (n < capacity())
{
while (_finish < _start + n)
{
*_finish = val;
++_finish;
}
}
else
{
//开空间并对应初始化
reserve(n);
while (_finish < _start + n)
{
*_finish = val;
++_finish;
}
}
}
}2.6.1 n<size()
这里对应的就是将整个vector中的值进行删除,修改最后的_finish就可以进行改变.
2.6.2 size()<n<capacity()
这里没有涉及到开辟新的空间,只需要将数据填入对应的空间里即可.
2.6.3 n>capacity()
当n>capacity(),需要将vector类模板的capacity()进行扩容,然后再将需要填入的数据填到对应的空间中去.
2.7 insert()
void insert(iterator pos, const T& x)
{
assert(pos <= _finish);
if (_finish == _endofstorage)
{
//存储对应的len
size_t len = pos - _start;
//这块就是开辟对应的空间
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
pos = _start + len;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
//插入数据
*pos = x;
++_finish;
/*pos = pos + 1;*/
}这个insert的模拟实现,刚开始需要进行断言,当_finish=_endofstorage的时候就涉及到开辟新的空间,利用reserve进行开辟新的空间,再接着就是将x值插入到pos位上.下面用图来表示一下整个操作过程:
2.8 erase()
iterator erase(iterator pos)
{
//在这里其实也涉及到了迭代器失效的情况
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}这个erase的移动也是跟insert比较类似,下面我们也还是利用画图板进行演示一下:
最后返回的这个pos位也就是对应的下一个位置的地址.
2.9 push_back()
//尾插的形式
void push_back(const T& x)
{
if (_finish == _endofstorage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
//尾插
*_finish = x;
++_finish;
}这个很明显,就是在_finish处插入值,如果当_finish=_endofstorage的时候,就需要开辟新的内存空间,利用reserve进行深拷贝新的空间,然后把最后的_finish处的位置内容填入x值即可.
2.10 pop_back()
//是否为空
bool empty() const
{
return _start == _finish;
}
void pop_back()
{
assert(!empty());
--_finish;
}尾删的话,并不需要进行开辟新的空间,首先检查一下vector模板类是否为空,然后--_finish就可以完成尾删的操作.
2.11 拷贝构造函数v1(v2)和赋值构造函数v1=v2
//拷贝构造函数
vector(const vector<T>& v)
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{
/* this->reserve(v.capacity());
for (auto e : v)
{
push_back(e);
}*/
//处理一下_finish的参数
_start = new T[v.capacity()];
//memcpy(_start, v._start, sizeof(T) * v.size());
//进行拷贝构造
for (size_t i = 0; i < v.size(); ++i)
{
_start[i] = v._start[i];
}
_endofstorage = _start + v.capacity();
_finish = _start + v.size();
}
//赋值构造函数
vector<T>& operator=(vector<T> v)
{
//直接利用swap函数的现代用法
/* swap(_start, v._start);
swap(_finish, v._finish);
swap(_endofstorage, v._endofstorage);*/
swap(v);
return *this;
}swap函数的代码:
void swap(vector<T>& v)
{
//这是一个局部域的函数类型
//将局部域改成一个全局的变量类型
::swap(_start, v._start);
::swap(_finish, v._finish);
::swap(_endofstorage, v._endofstorage);
}这个只要区分开:拷贝是浅拷贝和赋值是深拷贝即可.
2.12 析构函数~vector()
//析构函数
~vector()
{
if (_start)
{
delete[] _start;
}
_start = _finish = _endofstorage = nullptr;
}3.删除所有偶数的样例分析
3.1.1 正确代码:
void test_vector1()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
//vector<int>::iterator it = v.begin();
//while (it != v.end())
//{
// cout << *it << " ";
// ++it;
//}
//cout << endl;
范围for的打印
//for (size_t i = 0; i < v.size(); ++i)
//{
// cout << v[i] << " ";
//}
//cout << endl;
PrintVector(v);
//删除掉所有的偶数
vector<int>::iterator it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
v.erase(it);
}
else
{
++it;
}
}
//v.erase(&v[0]);
PrintVector(v);
}这个要结合erase的模拟实现进行说明,下面还是以实现图为例进行说明:
这个最后当_end==_it的时候,到达终点,当然还有一种情况容易导致错误:
3.1.2 错误代码
void test_vector1()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
//vector<int>::iterator it = v.begin();
//while (it != v.end())
//{
// cout << *it << " ";
// ++it;
//}
//cout << endl;
范围for的打印
//for (size_t i = 0; i < v.size(); ++i)
//{
// cout << v[i] << " ";
//}
//cout << endl;
PrintVector(v);
//删除掉所有的偶数
vector<int>::iterator it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
v.erase(it);
++it;
}
}
//v.erase(&v[0]);
PrintVector(v);
}这个很明显,无论什么情况下均会进行++it,这个会产生一定的错误,因为erase删除了之后,就是返回下一个位置了,不进行判断都进行++it的话,会导致结果出现错误.
很明显,这时候_end与it最后不能碰到一起进行判断,导致输出结果错误.大家在进行写代码的时候要注意这个问题.
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
