一、vector介绍和使用
1.1 vector的介绍
- vector是表示可变大小数组的序列容器。
- 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
- 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
- vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
- 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
- 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list
统一的迭代器和引用更好。
问题：
vector<char>和string有什么区别？
vector<char>是vector以char类型为模板实例化的类模板，她一次只能对单个字符进行操作，所拥有的也是vector这个类的集体属性，而string类一次可以完成对多个字符的操作（字符串或字符），拥有字符串所具有的特性，例如+=。
1.2vector的使用
1.2.1 vector的构造函数
| 构造函数声明 | 接口说明 |
|---|---|
| vector()(重点) | 无参构造 |
| vector（size_type n, const value_type& val = value_type()） | 构造并初始化,n个val |
| vector (const vector& x); (重点) | vector (const vector& x); |
| vector (InputIterator first, InputIterator last); | 使用迭代器进行初始化构造 |
1.2.2 vector iterator的使用
| iterator的说明 | 接口说明 | 图示 |
|---|---|---|
| begin+end(重点) | 获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置的iterator/const_iterator |  |
| rbegin+rend | 获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的reverse_iterator |  |
1.2.3 vector的空间问题
| 容量空间 | 接口说明 |
|---|---|
| size | 获取数据个数 |
| capacity | 获取容量大小 |
| empty | 判断是否为空 |
| resize(重点) | 改变vector的size |
| reserve (重点) | 改变vector的capacity |
1.2.4 vector的增删查改
| 操作 | 接口说明 |
|---|---|
| push_back（重点） | 尾插 |
| pop_back （重点） | 尾删 |
| find | （注意这个是算法模块实现，不是vector的成员接口）头文件<algorithm> |
| sort | 排序 |
| insert | 在pos之前插入val |
| erase | 删除pos位置的数据 |
| swap | 交换两个vector的数据空间 |
| operator[] (重点) | 像数组一样访问 |
sort函数的使用：
sort(a.begin(), a.end(),greater<int>());降序排序
sort(a.begin(), a.end());升序排序
二、vector的深度剖析及实现
2.1 基本框架
template <typename T>
class vector
{
private:
public:
}
2.2 私有成员
private:
T* _start = nullptr;
T* _finish = nullptr;
T* _end_of_storage = nullptr;
2.3 构造与赋值
//强制使用默认构造
vector() default;
//缺省形参，用n个val构造
vector(size_t n, const T& val=T())
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}
//使用[first,last)构造
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
first++;
}
}
//拷贝构造
vector(const vector<T>& v)
{
reserve(v.capacity());
for (auto e : v)
{
push_back(e);
}
}
//使用初始化列表初始化
vector(initializer_list<T> il)
{
reserve(il.size());
for (auto e : il)
{
push_back(e);
}
}
对initializer_list()的解释:
//赋值
vector<T>& operator=(const vector& v)
{
clear();
reserve(v.capacity());
for (auto e : v)
{
push_back(e);
}
return *this;
}
vector<T>& operator=(const vector v)
{
swap(v);
return *this;
}
2.4 析构函数
//析构
~vector()
{
if(_start)//判空
{
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
}
2.5 迭代器
//迭代器
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;
}
2.6 对容器大小的操作
size_t size() const //元素个数
{
return _finish - _start;
}
size_t capacity() const //容量大小
{
return _end_of_storage - _start;
}
void reserve(size_t n) //扩容操作
{
if (n > capacity())
{
size_t oldsize = size();
T* temp = new T[n];
//if (_start)
//{
//memcpy(temp, _start, sizeof(T) * n);//对字符串进行浅拷贝，会出错
//delete[] _start;
//}
if(_start)
{
for (size_t i = 0; i < oldsize; i++)
{
temp[i] = _start[i];//调用赋值
}
delete[] _start;
}
_start = temp;
_finish = _start + oldsize;
_end_of_storage = _start + n;
}
}
bool empty() //判空
{
return size() == 0;
}
void swap(vector<T>& v) //交换
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
}
对reserve()函数的分析:
- memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中
- 如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且
自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。
如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是
浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。
2.7 对数据的访问
T& operator[](size_t i)
{
assert(i < size());
return _start[i];
}
const T& operator[](size_t i) const
{
assert(i < size());
return _start[i];
}
2.8 对容器的增删查改
void push_back(const T& val) //尾插
{
if (_finish == _end_of_storage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_finish = val;
++_finish;
//insert(end() val); 用insert()插入
}
void pop_back() //尾删
{
assert(size()>0)
_finish--;
}
void clear() //清空
{
_finish = _start;
}
iterator insert(iterator pos, const T& val) //插入
{
assert(pos <= _finish);//==finish就可以实现尾插
assert(pos >= _start);
if (_finish == _end_of_storage)
{
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 = val;
_finish++;
return pos;
}
iterator erase(iterator pos) //删除
{
assert(pos < _finish);
assert(pos >= _start);
size_t len = pos - _start;
iterator cur = pos;
while (cur < _finish)
{
*cur = *(cur + 1);
cur++;
}
--_finish;
return _start + len;
}
};
