vector的介绍及使用
1.vector是表示可变大小数组的序列容器
2.就像数组一样，vector也采用连续的存储空间来存储元素。
3.vector使用动态分配数组来存储它的元素
4.vector分配空间策略：vector会分配额外的空间以适应增长，因为存储空间比实际需要的存储空间大
5.与其他动态序列容器相比，vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效，但其他操作效率低。比起list和forward_list统一的迭代器和引用更好
vector的使用
1.vector的定义
| constructor构造函数声明 | 接口说明 |
|---|---|
| vector() | 无参构造 |
| vector(const vector& x) | 拷贝构造 |
| vector(size_t n,const value& val=value_type()) | 构造并初始化n个val |
| vector (inputIterator first,inputiterator last | 使用迭代器进行初始化构造 |
2.vector iterator的使用
| iterator的使用 | 接口说明 |
|---|---|
| begin+end | 获取第一个数据位置的iterator/const_iterator,获取最后一个数据的下一个位置的iterator/const_iterator |
| rbegin+rend | 获取最后一个数据位置的reverse_iterator,获取第一个数据前一个位置的reverse_iterator |
3.vector 空间增长问题
| 容量空间 | 接口说明 |
|---|---|
| resize | 改变vector的size |
| reserve | 改变vector的capacity |
| size | 获取数据个数 |
| capacity | 获取容量大小 |
| empty | 判断是否为空 |
1.vs下的capacity是按1.5倍增长的，g++是按照2倍增长的
2.reserve只负责开辟空间，如果确定需要多少空间，可以缓解vector扩容的代价缺陷问题
3.resize在空间的同时还会进行初始化，影响size
4.resize在增多元素个数时可能会扩容
5.resize(size_t n,const T& data=T())将有效元素个数设置为n,如果增多时，增多的元素使用data填充
4.vector增删查改
| vector增删查改 | 接口说明 |
|---|---|
| push_back | 尾插 |
| pop_back | 尾删 |
| operator[] | 像数组一样访问 |
| find | 查找(是算法模块实现的，不是vector的成员接口 |
| insert | 在pos前插入val |
| erase | 删除pos上的数据 |
| swap | 交换两个vector的数据空间 |
vector的迭代器失效问题
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，vector的迭代器就是原生态指针T* .
迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，使用一块已经被释放的空间会造成程序崩溃
引起底层空间改变的操作，都有可能使迭代器失效
比如：resize,resrve,insert,assign,push_back等
出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的空间，而引起代码运行时崩溃。
解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
赋值即可。
删除指定位置元素-erase
erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。
看下删除数组中偶数的代码，发现给迭代器赋初值就可以避免失效问题。
再看看string类的迭代器失效
发现空间改变后，迭代器都会失效
迭代器失效解决办法：在使用前，堆迭代器重新赋值即可
在vs下代码检查严格，但在g++下相对没那么严格。SGI STL中，迭代器失效后，代码并不一定会崩溃，但是运行结果肯定不对，如果it不在begin和end范围内，肯定会崩溃的。
vector模拟实现
#include <iostream>
using namespace std;
#include <assert.h>
namespace Kai
{
template<class T>
class vector
{
public:
// Vector的迭代器是一个原生指针
typedef T* iterator;
typedef const T* const_iterator;
///
// 构造和销毁
vector()
: _start(nullptr)
, _finish(nullptr)
, _endOfStorage(nullptr)
{}
vector(size_t n, const T& value = T())
: _start(nullptr)
, _finish(nullptr)
, _endOfStorage(nullptr)
{
reserve(n);
while (n--)
{
push_back(value);
}
}
/*
* 理论上将，提供了vector(size_t n, const T& value = T())之后
* vector(int n, const T& value = T())就不需要提供了，但是对于：
* vector<int> v(10, 5);
* 编译器在编译时，认为T已经被实例化为int，而10和5编译器会默认其为int类型
* 就不会走vector(size_t n, const T& value = T())这个构造方法，
* 最终选择的是：vector(InputIterator first, InputIterator last)
* 因为编译器觉得区间构造两个参数类型一致，因此编译器就会将InputIterator实例化为int
* 但是10和5根本不是一个区间，编译时就报错了
* 故需要增加该构造方法
*/
vector(int n, const T& value = T())
: _start(new T[n])
, _finish(_start + n)
, _endOfStorage(_finish)
{
for (int i = 0; i < n; ++i)
{
_start[i] = value;
}
}
// 若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器
// 重新声明迭代器，迭代器区间[first,last)可以是任意容器的迭代器
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector(const vector<T>& v)
: _start(nullptr)
, _finish(nullptr)
, _endOfStorage(nullptr)
{
reserve(v.capacity());
iterator it = begin();
const_iterator vit = v.cbegin();
while (vit != v.cend())
{
*it++ = *vit++;
}
_finish = it;
}
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _endOfStorage = nullptr;
}
}
/
// 迭代器相关
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator cbegin() const
{
return _start;
}
const_iterator cend() const
{
return _finish;
}
//
// 容量相关
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _endOfStorage - _start;
}
bool empty() const
{
return _start == _finish;
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t oldSize = size();
// 1. 开辟新空间
T* tmp = new T[n];
// 2. 拷贝元素
// 这里直接使用memcpy会有问题吗？同学们思考下
//if (_start)
// memcpy(tmp, _start, sizeof(T)*size);
if (_start)
{
for (size_t i = 0; i < oldSize; ++i)
tmp[i] = _start[i];
// 3. 释放旧空间
delete[] _start;
}
_start = tmp;
_finish = _start + oldSize;
_endOfStorage = _start + n;
}
}
void resize(size_t n, const T& value = T())
{
// 1.如果n小于当前的size，则数据个数缩小到n
if (n <= size())
{
_finish = _start + n;
return;
}
// 2.空间不够则增容
if (n > capacity())
reserve(n);
// 3.将size扩大到n
iterator it = _finish;
_finish = _start + n;
while (it != _finish)
{
*it = value;
++it;
}
}
///
// 元素访问
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos)const
{
assert(pos < size());
return _start[pos];
}
T& front()
{
return *_start;
}
const T& front()const
{
return *_start;
}
T& back()
{
return *(_finish - 1);
}
const T& back()const
{
return *(_finish - 1);
}
/
// vector的修改操作
void push_back(const T& x)
{
insert(end(), x);
}
void pop_back()
{
erase(end() - 1);
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endOfStorage, v._endOfStorage);
}
iterator insert(iterator pos, const T& x)
{
assert(pos <= _finish);
// 空间不够先进行增容
if (_finish == _endOfStorage)
{
//size_t size = size();
size_t newCapacity = (0 == capacity()) ? 1 : capacity() * 2;
reserve(newCapacity);
// 如果发生了增容，需要重置pos
pos = _start + size();
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
return pos;
}
// 返回删除数据的下一个数据
// 方便解决:一边遍历一边删除的迭代器失效问题
iterator erase(iterator pos)
{
// 挪动数据进行删除
iterator begin = pos + 1;
while (begin != _finish) {
*(begin - 1) = *begin;
++begin;
}
--_finish;
return pos;
}
private:
iterator _start; // 指向数据块的开始
iterator _finish; // 指向有效数据的尾
iterator _endOfStorage; // 指向存储容量的尾
};
}
在实现reserve接口时，会想到使用memcpy进行拷贝。
1.memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中
2. 如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。
扫一扫
2351
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
