C++-----vector
本期我们来学习C++中的vector，因为有string的基础，所以我们会讲解的快一点
目录
vector介绍
vector常用接口
构造函数
sort
迭代器
size，max_size，capacity，empty
reserve和resize
front和back
data
insert和erase
find
swap和clear
assign
vector扩容机制
vector模拟实现
全部代码
vector介绍
1. vector是表示可变大小数组的序列容器。
2. 就像数组一样， vector 也采用的连续存储空间来存储元素。也就是意味着可以采用下标对 vector 的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。3. 本质讲， vector 使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector 并不会每次都重新分配大小。4. vector 分配空间策略： vector 会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。5. 因此， vector 占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。6. 与其它动态序列容器相比（ deque, list and forward_list ）， vector 在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list 和 forward_list统一的迭代器和引用更好
简单理解，vector就是一个数组，顺序表
我们先简单写一点代码来了解一下， 我们用三种方法遍历vector
我们看代码里我们定义vector时，是vector
我们可以用vector代替string吗？答案是不可以，首先，他俩的结构就不相同，string结尾是有\0的，可以更好兼容C语言，vector是没有的。string的接口是比vector更丰富的，比如+=，比较大小等等
vector里是可以放string的，我们这里有三种插入方式，第一种就是常规的，第二种是借助匿名对象，但我们最喜欢的是第三种，是单参数的构造函数支持隐式类型转换
还可以存vector，这里就是二维数组了
vector常用接口
我们上面注意到，vector是一个模板，我们看第二个模板参数Alloc，他是一个=空间配置器，也就是一个内存池，stl所有容器都用的这个内存池，因为需要频繁是申请释放空间，要提升效率
这里是给了默认参数的，如果我们感觉他的不好，我们可以自己写一个传过去，不过我们平时是不需要管的，因为他的那个就很好了
构造函数
第一个是全缺省的，第二个是n个value初始化，后面有个value_type，这个是typedef出来的
其实就是T，这些在文档里都有介绍
还有迭代器的初始化和拷贝构造，下面我们来使用一下
我们使用n个value的进行初始化
我们看迭代器里有个inputiterator，并且是一个模板，这是一个模板区间，但不一定是vector，我们可以给其他类型，只要按迭代器的规范使用就行
这里最后一行打出来的为什么是数字？其实是整形提升，把char转换为了int，变成了ASCII码
我们把这里改成char就可以了
还可以这样初始化
总结上面的，可以用自己类型的迭代器，其他类型的迭代器，还有数组来初始化，这个数组本质是指针，迭代器的行为就是模拟的指针，所以都是可以的
sort
stl是容器和算法，容器和算法是分开的，容器是存储数据，算法是处理数据，比如查找，排序等等，算法通过迭代器来访问容器里的数据，这里的两个sort底层使用的是快排，他不仅仅只作用于vector，只要符合条件的都可以使用
要使用算法，要先加头文件#include
这里我们是升序，如果想排降序，我们要用第二个sort，我们看第三个参数Compare comp
这里我们可以自己写，也可以用库里面的
我们先学习如何使用，我们创建一个greater传过去就可以了
而且我们更推荐使用匿名对象，这样更舒服
我们上面的string也是可以用sort的
我们上面的数组a也是可以使用的
下面我们来看迭代器
迭代器
第一个是读写迭代器，第二个const是只读迭代器
还有反向迭代器
反向迭代器会使排序从变为降序排序
size，max_size，capacity，empty
这些过于简单，我们就不再多说
reserve和resize
reserve是扩容
我们看这种错误的写法，这里vector里size是0，capacity是10，方括号是operator[ ](size_t i)，他里面有assert(i<_size)，就会崩溃，reserve只是扩容，如果我们想这样访问，是要用resize的，他会把size也设为10
就像这样
如果就像要用reserve，下面的插入数据就不能用方括号，而是要用push_back
operator[ ]和at
at是抛异常，operator[ ]是断言，断言更暴力一些
front和back
这两个接口也非常简单，就是第一个元素和最后一个，其实我们用方括号0，和方括号size-1就可以完成了
data
这个接口和string里的c_str非常像，返回一个数组指针
push_back和pop_back
我们发现没有头插头删，只有尾插尾删，原因是头插头删是需要挪动数据的，和string是一样
但我们要头插头删也是可以的
insert和erase
使用insert和erase就可以了
我们进行头插头删
删除第三个位置的
如果我们想删除2，那我们可以和find配合，但是我们找了半天文档，发现没有find
find
这是因为其实find在算法里 ，而string是有自己的find的，因为string的find比较多样化，而vector是要和别的容器复用的
我们使用find要传一个迭代区间，是左闭右开，传[ first , last )，找到返回位置，找不到返回last
比如我们这里删除了2
这么长的是可以用auto替代的
如果我们想要删除所有的3，这样写缺崩溃了 ，原因是这里涉及迭代器失效的问题，这个知识点我们在未来底层实现来讲
我们可以从头开始找，但是效率低 ，这个问题我们暂时保留
swap和clear
一个是交换，一个是清理，也是非常简单，这里就不多说
assign
清空当前的值然后重新赋值
比如我们之前有很多数，然后我们assgin，就变成了10个1 ，这个函数我们也不常用
vector扩容机制
// 测试vector的默认扩容机制
void TestVectorExpand()
{
size_t sz;
vector 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';
}
}
} 
在vs下vector基本是1.5倍扩容，在Linux下是2倍扩容
两个扩容还是有区别的，大家了解一下即可
vector模拟实现
我们先来简单看看vector官方的源代码
我们发现，vector的迭代器使用的就是指针，因为vector的空间是连续的，就是一个数组
再看他的成员，发现和我们想的不太一样，我们设想的是有个size，capacity等等
我们再看他的构造函数， 第一个构造就是把三个指针初始化为空了，剩下的我们也看不出什么
我们看push_back，这个看起来就顺眼多了
我们看finish，是结束的意思，而storage是存储的意思，所以我们可以猜测，finish指向的是数据结束的位置，就像size，end _of_storage指向空间的结束，就像capacity
我们再根据if和else里的逻辑来猜测，construct是什么我们暂时不知道，但是看到++finish，我们就大概可以确认我们前面的猜想是合理的，所以if里的语句是空间没满的逻辑，else里是满了的逻辑，满了一般会进行扩容，我们再找找insert_aux
我们看ifelse，这里再次判断是因为inset不是仅仅给pushback使用，还有可能是别人直接调用等等，所以按照我们前面的逻辑此时我们应该进入else，这里面是非常复杂的，有一个old_size，是二倍增长的，我们还可以看到copy什么什么的，这里就是扩容的逻辑了
我们再看看reserve，我们看最后三句，tmp是新开的空间（上面有个什么什么copy，数据拷贝过去了），tmp给了start，tmp+oldsize给了finish，n是空间的大小，又有end_of_storage，allocate是申请空间，那么deallocate就是释放空间，
我们看construct和destroy，下面有一个定位new，是用来显示调用构造函数的，这里没有直接赋值等等的原因是，我们的空间都是空间配置器，也就是内存池开的，如果是自定义类型，比如vector
这里本质就是为了提高效率，其实使用new和delete就可以了
看了这么多，下面我们开始模拟实现
namespace bai {
template
class vector
{
public:
typedef T* iterator;
vector()
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{}
void push_back(const T x)
{
}
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
};
} 首先我们把框架搭建好，我们按照源码那样来写，模拟一样，看看他们那样写有什么好处
void push_back(const T& x)
{
if (_finish == _endofstorage) //满了扩容
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_finish = x;
++_finish;
}
size_t capacity() const
{
return _endofstorage - _start;
}
size_t size() const
{
return _finish - _start;
}我们实现一下pushback，以及capacity和size
void reserve(size_t n)
{
if (n > capacity())
{
//扩容
T* tmp = new T[n];
if (_start)//原空间不为空则进行拷贝
{
memcpy(tmp, _start, sizeof(T) * size());
delete[] _start;
}
_start = tmp;
_finish = _start + size();
_endofstorage = _start + n;
}
}再实现一下reserve
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}我们再补充一下迭代器，此时我们就可以简单测试代码了
我们运行发现代码崩溃了，我们进行调试
最后发现在finish这里出现了问题 ，原因就是size有问题，最开始的时候三个成员都是空的，然后start指向我们创建的tmp空间，finish和start指向的不在一块空间
我们的第一种解决方法是这里的finish=tmp+size();，同时交换finish和start的顺序
下面我们再看第二种方法
第二种方法就是我们提前保存一下size
没有问题
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
}我们继续补充，首先是析构函数
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}还有我们经常使用的方括号，我们再测试一下
没有问题
还有记得补充const迭代器
void insert(iterator pos, const T& x)
{
assert(pos >= _start && pos <= _finish);
if (_finish == _endofstorage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
}还有insert，不过此时的insert是有bug的
我们多次pushback，有时候会出现问题，有时候不会，这就是迭代器失效
4和8的时候都是扩容的节点，一旦扩容，我们要把数据拷贝到新的空间，然后释放旧空间，此时我们insert里的pos就不对了，start，finish都指向了新的空间，而pos还在旧空间，就变成了野指针
我们需要更新一下pos，这样就没有问题了
有insert我们就可以复用了，就不需要pushback了
我们上面解决了内部迭代器失效的问题，下面还有外部迭代器失效问题
为什么第一个是310，第二个是300呢？还没有报错
因为insert是传值传参，pos改变不会影响p，但是给pos加引用就编译不通过了
我们的begin是传值返回，返回的是他的拷贝，是临时变量，临时变量具有常性
所以我们在外部一定要记住，insert的迭代器可能会失效，但是什么情况失效我们不知道，因为平台不同，扩容机制不同，扩容的时候会失效，所以insert以后就不要使用形参迭代器了，因为他可能失效了，我们修改的话可能是一个高危行为
如果真的要用，就用返回值吧 ，库里面的也有迭代器失效的问题，我们现在模拟的就是一样的
void erase(iterator pos)
{
assert(pos >= _start && pos <= _finish);
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
}我们再实现一下erase，然后测试一下
没有问题，这里有迭代器失效问题码？
其实还是有问题的 ，所以erase迭代器也是会失效的
如果我们使用库里面的，使用vs的话就会直接报错，也就是说erase以后迭代器失效不能访问，vs会进行强制检查，直接报错
如果在Linux下的话就变成了这样，二者的结果是不一样的
不过在Linux下，有些情况是非常危险的，比如我们要删除所有的偶数
看着没有问题，其实这是一个偶然，我们改变一下测试用例
就会变成这样
如果最后一个位置是6
这里就是一个段错误，出了一个大问题，在vs下上面这三种情况都是直接报错的
我们看第二种情况，1，2，2，3，4，5的情况
it指向第一个2的时候，我们进行删除，就变成了1，2，3，4，5，此时it还是指向2的，我们没有进行检查，然后++it，it就指向了3，就跳过了第二个2
再看第三种情况，1，2，2，3，4，5，6的情况
前面和第二种是一样的，先是错过了第二个2，指向4的时候，删除4，然后往前挪，变成1，2，3，5，6，，此时是指向5的，然后++it，指向6，此时finish在it的下一个位置，我们要删除这个位置，是挪动后面的覆盖前面的，但是这里是最后一个位置，所以没有覆盖，会让finish--，到达6的这个位置，然后++it，此时it就在finish之后了，之后在循环条件里，it永远就不会等于end了，会不断往后走，不断的越界
有人可能会想加一个else，其实这样做还是有问题的，我们这样写在Linux下可以跑，但是如果换在vs下的话就出事了
就直接崩溃了 ，++是没有问题的，问题在于下一次erase时，不管怎么解引用访问都是会报错的
（这里迭代器用的不是原生的指针，而是使用了封装，我们学完list后就可以理解了）
然后我们再走下一步就会报错了
我们看官方文档的话，官方是考虑了这种情况的，我们要使用返回值来解决
返回的是刚被删除的元素的下一个位置
所以代码最后是这样写的，此时Linux和vs下都是可以跑的，问题也都解决了
我们最后再修改一下我们的代码
总结一下，vector的erase和insert使用迭代器对象后，不能再访问该迭代器，我们认为它失效，访问结果是未定义的
迭代器的失效可能是野指针问题，也可能是位置的问题
我们再复用实现一下头删
还有resize，resize要给初始值，但是这里我们不能给0，因为T是什么我们不知道，有可能是string，也有可能是vector等等，所以这里我们这样写，这是一个匿名对象， 比如T是string，这里就会调用默认构造，不过这里如果是int，理论上不行的，因为int是没有构造函数的，但是有了模板后，C++等于对内置类型进行了升级，也支持内置类型有默认构造
就像这样写都是没问题的
void resize(size_t n,const T& val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
reserve(n);
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}我们再测试一下
没有问题
vector(const vector& v)//拷贝构造
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
_start = new T[v.capacity()];
memcpy(_start, v._start,sizeof(T)*v.size());
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
} 我们再来实现一下拷贝构造
测试一下也没有问题
vector(const vector& v)//拷贝构造
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(v.capacity());
for (auto e : v)
{
push_back(e);
}
} 还可以这样写
void swap(vector& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
vector& operator=(vector v)//赋值
{
swap(v);
return *this;
} 我们再完成一下赋值，使用swap来辅助一下
我们再看一个问题
此时是没有问题的
但是多了一个就出问题了，我们分析问题应该在扩容上
我们有一个vector，里面都是string，每个string都有str，size，capacity，每个string对象都是new出来的
现在我们要进行扩容，要开辟一个新的空间，也是new出来的
而我们的字符串（“1111”，“2222”这些）都在堆上面，我们原来的vector（上面的）都指向他们，现在扩容后要进行拷贝，我们的reserve，使用了memcpy，他会把上面的string每个字节都拷贝下来，导致新的空间里的string也指向了堆上面的这些字符串，然后旧的空间被delete，调用了析构函数，T是自定义类型，依次调用数组每个对象的析构函数，再释放整个空间，但是我们扩容后的新空间还指向堆上的这些空间
也就是说，vector是深拷贝，但是vector空间上的对象是string数组，使用memcpy导致string对象浅拷贝
我们把reserve里的memcpy换成这样的代码就可以解决了
我们在这个地方需要深拷贝，这里的本质调的是string的赋值
我们拷贝构造也有一样的问题（使用push_back的没有问题），使用的也是memcpy
修改如上即可 ，如果T是string，我们调用的是string的赋值重载，实现string对象的深拷贝
涉及到深拷贝问题的还有vector
大家理解最好画图理解一下前面为什么那样修改代码
我们再看vector里的这两个构造
第一个是n个val初始化
我们可以使用resize偷懒
没有问题
第二个构造是用一个迭代器区间初始化
我们先看参数，我们直接这样写是不好的，这样写只能使用vector的迭代器来初始化，我们看到之前是可以使用其他迭代器初始化的，比如string的，所以我们要换一种写法
template
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
我们可以在类模板里套用类模板，是不是很神奇？
不过此时还有一些问题，我们在使用n个val初始化时会出现冲突
这里会调用我们新写的inputiterator构造
库里面为了解决这个问题还专门提供了方案
我们加一个int的即可
全部代码
#pragma once
#include
#include
#include
#include
#include
using namespace std;
namespace bai {
template
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
vector(size_t n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
resize(n, val);
}
vector(int n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
resize(n, val);
}
//[first,last)
template
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector()
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{}
vector(const vector& v)//拷贝构造
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
_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];
}
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
}
//vector(const vector& v)//拷贝构造
// :_start(nullptr)
// , _finish(nullptr)
// , _endofstorage(nullptr)
//{
// reserve(v.capacity());
// for (auto e : v)
// {
// push_back(e);
// }
//}
void swap(vector& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
vector& operator=(vector v)//赋值
{
swap(v);
return *this;
}
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
}
void reserve(size_t n)
{
if (n > capacity())
{
//扩容
size_t sz = size();
T* tmp = new T[n];
if (_start)//原空间不为空则进行拷贝
{
//memcpy(tmp, _start, sizeof(T) * size());
for (size_t i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}
void resize(size_t n,const T& val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
reserve(n);
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}
void push_back(const T& x)
{
/*if (_finish == _endofstorage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_finish = x;
++_finish;*/
insert(end(), x);
}
size_t capacity() const
{
return _endofstorage - _start;
}
size_t size() const
{
return _finish - _start;
}
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
iterator insert(iterator pos, const T& x)
{
assert(pos >= _start && pos <= _finish);
if (_finish == _endofstorage)
{
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
//解决pos迭代器失效
pos = _start + len;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
return pos;
}
iterator erase(iterator pos)
{
assert(pos >= _start && pos <= _finish);
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}
void pop_back()
{
erase(--end());
}
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
};
} 以上即为本期全部内容，希望大家可以有所收获
如有错误，还请指正