C++入门 vector的使用 + 进阶模拟实现
Posted IT莫扎特
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++入门 vector的使用 + 进阶模拟实现相关的知识，希望对你有一定的参考价值。
基本接口函数介绍
| 函数名 | 功能 |
|---|---|
| vector()（重点） | 无参构造，构造一个空容器，没有元素。 |
| vector（size_type n, const value_type& val = value_type()） | 构造并初始化n个val |
| vector (const vector& x); （重点） | 拷贝构造 |
| vector (InputIterator first, InputIterator last); | 使用迭代器进行初始化构造 |
测试：
void func()
int arr[] = 8,4,3,6,1;
vector<int> vc;//构造一个空容器,没有元素
vector<int> vc1(10,5);//构造并初始化n个val
vector<int> vc2(vc1);//拷贝构造
//使用迭代器进行初始化构造
vector<int> vc3(arr ,arr + sizeof(arr) / sizeof(arr[0]));
test(vc);
test(vc1);
test(vc2);
test(vc3);
//test(vc);
测试效果
调用不带参数的构造函数，成员属性初始值值会给0
迭代器
| iterator的使用 | 接口说明 |
|---|---|
| begin +end（重点） | 获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置 |
| rbegin + rend | 获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的 |
//使用正向迭代器
void test1(vector<int> &v)
vector<int>::iterator it = v.begin();
while (it != v.end())
cout << *it++ << " ";
cout << endl;
//使用反向迭代器
void test2(vector<int>& v)
vector<int>::reverse_iterator it = v.rbegin();
while (it != v.rend())
cout << *it++ << " ";
cout << endl;
空间容量
| 容量空间 | 接口说明 |
|---|---|
| size | 获取数据个数 |
| capacity | 获取容量大小 |
| empty | 判断是否为空 |
resize（重点）
1、调整容器大小，使其包含n个元素。
2、如果n小于当前容器的大小，则将内容减少到其前n个元素，并删除(并销毁)超过的元素。
3、如果n大于当前容器的大小，则在容器的末尾插入足够多的元素来扩展容器的内容，使容器的大小达到n。如果指定了val，则将新元素初始化为val的副本，否则将对它们进行值初始化。
reserve （重点）
请求向量容量至少足以容纳n个元素。
如果n大于当前的容量，该函数将导致容器重新分配其存储空间，将其容量增加到n(或更大)。
在所有其他情况下，函数调用不会导致重新分配，vector容量也不会受到影响。 也不能改变它的元素。
1、capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。这个问题经常会考察，不要固化的认为，顺序表增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL。
2、reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。
3、resize在开空间的同时还会进行初始化，影响size
用一份测试代码去观察：
void func1()
vector<int> v;
int size = v.capacity();
cout << size << endl;
for (int i = 0; i < 100; i++)
v.push_back(i);
if (v.capacity() != size)
size = v.capacity();
cout << "扩容后：" << size << endl;
vs下capacity是按1.5倍增长的
在linux下以2倍增长
增删查改
| vector增删查改 | 接口说明 |
|---|---|
| push_back（重点） | 尾插 |
| pop_back （重点） | 尾删 |
| find | 查找。（注意这个是算法模块实现，不是vector的成员接口） |
| insert | 在position之前插入val |
| erase | 删除position位置的数据 |
| swap | 交换两个vector的数据空间 |
| operator[] （重点） | 返回此下标位置的值 |
void func1()
//插入5个值
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
for (auto val : v)
cout << val << " ";
cout << endl;
//在一段迭代去区间查找值为2的元素，找到返回此位置的迭代器，
//没有找到就返回end()处的迭代器
vector<int>::iterator pos = find(v.begin(),v.end(),2);
if (pos != v.end())
//将值插入到pos位置之前
v.insert(pos,30);
for (auto val : v)
cout << val << " ";
cout << endl;
//在一段迭代去区间查找值为2的元素，找到返回此位置的迭代器，
//没有找到就返回end()处的迭代器
pos = find(v.begin(), v.end(), 30);
if (pos != v.end())
//删除pos位置的值
v.erase(pos);
for (auto val : v)
cout << val << " ";
迭代器失效问题探讨
野指针问题
//测试二
void func2()
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;
//查找 pos位置，找到后返回此位置的迭代器
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
//在pos位置前插入10，空间会扩容并释放旧的空间，
//重新分配一块新的空间，由于旧空间已经被释放完了，所以不可访问
v.insert(pos,10);
it = v.begin();
while (it != v.end())
cout << *it << " ";
it++;
cout << endl;
//pos是野指针，使用pos去访问旧空间是一个隐患
v.erase(pos);
it = v.begin();
while (it != v.end())
cout << *it << " ";
it++;
这个程序的运行是会存在错误的，错误的原因是pos还在访问那块旧的空间，pos迭代器却早已经失效了，旧空间释放后内存使用权限已经归还给操作系统了，而pos还指向那块旧的空间，v.erase(pos);这句代码就是去访问一块非法内存，所以就会程序崩溃
图解：
下面这块程序的功能是将容器中所有的偶数都删除掉，只保留奇数数据
这段程序在不同的平台上是不一样的
//测试一
void func1()
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
v.push_back(6);
//v.push_back(7);
vector<int>::iterator it = v.begin();
while (it != v.end())
if (*it % 2 == 0)
v.erase(it);
it++;
for (auto e : v)
cout << e << " ";
在vs上，程序就直接崩溃了
在linux上出现段错误
图解析:
从图中我们可以看出it每次删元素的时候都会跳过一个元素，end的位置每次也都在发生变化，直到删除6的时候 it 和 end已经开始错开了，分道扬镳，此后再也不会相遇，it此时就是野指针了，访问了一块非法的内存，但是在linux上平台上我们只需要将尾插一个7(奇数)就能解决这个问题，vs下无论是最后一个值是奇数还是偶数都会报错，it已经失效，编译器会直接对it++检查
是因为当插入7的时候刚好检查到最后一个位置不会再erase掉，it再往后迭代的时候就遇到了end，循环也就终止了，但是这段代码还是错误的代码，因为不同的平台跑出的结果是不一样的
解决方案
vector<int>::iterator it = v.begin();
while (it != v.end())
if (*it % 2 == 0)
//erase删除it位置的元素后,会返回it位置的下一个位置,
//再回去检查这个元素是否是偶数
it = v.erase(it);
else
it++;
总结：
insert和erase都会导致迭代器失效
1、insert(it, x) 或者 erase(it) 以后迭代器的意义变了
2、insert(it, x) 或者 erase(it) 以后it变成了野指针
vector模拟实现
namespace mzt
template<class T>
class vector
public:
typedef T* iterator;
iterator begin() return _start;
iterator end() return _finish;
size_t capacity() return _endofstroage - _start;
size_t size() return _finish - _start;
vector()
:_start(nullptr)
, _finish(nullptr)
, _endofstroage(nullptr)
vector(vector<T>& v)
:_start(nullptr)
,_finish(nullptr)
,_endofstroage(nullptr)
reserve(v.capacity());
for (auto &e : v)
push_back(e);
void swap(vector<T>& v)
::swap(_start,v._start);
::swap(_finish,v._finish);
::swap(_endofstroage,v._endofstroage);
vector<T>& operator=(vector<T> v)
if (this != &v)
swap(v);
return *this;
void reserve(size_t n)
size_t sz = size();
T* tmp = new T[n];
if (n > capacity())
//memcpy(tmp,_start,sizeof(T) * n);
if (_start)
for (size_t i = 0; i < sz; i++)
tmp[i] = _start[i];
delete[]_start;
_start = tmp;
_finish = _start + sz;
_endofstroage = _start + n;
//尾插
void push_back(const T& v)
if (_finish == _endofstroage)
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
*_finish++ = v;
void erase()
assert(!empty());
--_finish;
void resize(size_t n,T a = T())
if (n < capacity())
_finish = _start + n;
else
if (n > capacity())
reserve(n);
while (_finish < _endofstroage)
*_finish++ = a;
size_t operator[](size_t n)
assert(n < size());
return _start[n];
iterator insert(iterator pos, const T& x)
if (_finish == _endofstroage)
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
//pos失效后重新计算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(!empty());
iterator it = pos + 1;
while (it != _finish)
*(it - 1) = *it;
it++;
--_finish;
return pos;
bool empty() return _start == _finish;
~vector()
if (_start)
delete[] _start;
_start = _finish = _endofstroage = __nullptr;
private:
iterator _start;
iterator _finish;
iterator _endofstroage;
;
私有成员
iterator _start;//返回起始位置
iterator _finish;//返回最后一个元素的下一个位置
iterator _endofstroage;//返回空间的结束标记位置
reserve
//返回最后一个元素的下一个位置
size_t size()const
return _finish - _start;//指针相减计算中间差的元素个数
void reserve(size_t n)
if(n > capapcity())
size_t sz = size();
//提前备份好sz大小，防止扩容后_start 指向了新的空间，
T* tmp = new T[n];
if (_start)
//旧的空间_start的值拷贝到新空间上tmp上
//memcpy(tmp, _start, sizeof(T) * n);
//memcpy针对内置类型是可以的，但是如果针对
//的是自定义类型的话，可能会存在浅拷贝的问题，
//所以不管T类型是否是自定义类型也好，内置类型也好
//一律都去调用T类型的operator=
for(size_t i = 0; i < sz; i++)
tmp[i] = _start[i];
//回收旧空间
delete[] _start;
_start = tmp;
_finish = _start + sz;//提前备份sz的大小，防止计算错误
//错误示范：_finish = _start + size();
//_start 已经指向了一块新分配的空间地址就变了
_endofstroage = _start + n;
//实际空间开多大
这里需要注意的是_start = tmp;的时候_start 就已经指向新的空间了，如果使用_start + size()回去调用size函数
那就成了这样了：_start + (_finish - _start)，那就会很有可能是一个负数了，当然我们的编译器也不会这么傻
当断点执行到这一行的时候_finish指向的位置还是0x00000000，那么_finish压根就没变，解决办法，防止_start指向新空间后地址变了，我们先提前备份好size个数据
void push_back(const T& v)
//满了考虑扩容
if (_finish == _endofstroage)
C++从入门到入土第十三篇：vector的模拟实现