STL
STL-vector
前言
在C语言中，数组的大小是只能设为常量的，使用起来很不方便，于是在C++中就诞生了vector
一、vetcor是什么？
1.vector是个可变大小的动态数组，是一个容器；
2.vector采用连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问；
3.vector使用动态分配数组来存储元素，当数组为了增加存储空间时，会重新分配新大小的数组空间，然后将之前的全部元素移到这个数组，时间代价很大；
4.vector空间分配策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的，但在中间插入元素时需要移动元素，时间效率很低；
5.vector访问元素的时候相比其他容器更高效。
二、vector的使用
在使用库中的vector时需要引头文件
1.定义
代码如下（示例）：
| 构造函数 | 接口说明 |
|---|---|
| vector() | 无参构造 |
| vector（size_type n,const value_type&val = value_type(）) | 构造并初始化n个val |
| vector（const vector& x） | 拷贝构造 |
| vector（inputiterator first， Inputiterator last） | 使用迭代器进行初始化构造 |
vector<int> iv;//创建一个长度为0的空数组
vector<int> iv1(10, 2);//创建长度为10且每个元素都为2的数组
vector<int> iv11(iv1);//通过iv1拷贝创建iv11
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int num = sizeof(arr) / sizeof(arr[0]);
vector<int>iv2(arr, arr + num);//以arr数组为区间创建数组
2.vector iterator的使用
| iterator的使用 | 接口说明 |
|---|---|
| begin+end | 获取第一个数据位置的iterator/const_iterator，获取最后一个数据的下一个位置的iterator/const_iterator |
| rbegin+rend | 获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的reverse_iterator |
代码如下（示例）：
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int num = sizeof(arr) / sizeof(arr[0]);
vector<int>iv2(arr, arr + num);//以arr数组为区间创建数组
vector<int>::iterator it = iv2.begin();
cout << "iv2: ";
while (it != iv2.end())
{
cout << *it << " ";
++it;
}
cout << endl;
vector<int>::reverse_iterator rit = iv2.rbegin();
cout << "iv2Reverse: ";
while (rit != iv2.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
3.vector 空间增长
| 容量空间 | 接口说明 |
|---|---|
| size | 获取数据个数 |
| capactiy | 获取容量大小 |
| empty | 判断是否为空 |
| resize | 改变vector的size |
| resserve | 改变vector放入的capacity |
int n = iv2.size();
cout << "size = " << n << endl;
cout << "capacity = " << iv2.capacity() << endl;
iv2.resize(11);//重新设置大小
cout << "iv2: ";
for (auto &e : iv2)
{
cout << e << " ";
}
cout << endl;
cout << "capacity = " << iv2.capacity() << endl;
iv2.reserve(10);
cout << "capacity = " << iv2.capacity() << endl;
iv2.resize(16, 6);
cout << "iv2: ";
for (auto &e : iv2)
{
cout << e << " ";
}
cout << endl;
capacity在VS下是1.5倍增长的，g++是按2倍增长的，VS是PJ版本的STL，g++是SGI版本的STL。
reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。
resize在开辟空间时还会进行初始化。
4.vector 增删查改
| vector 增删查改 | 接口说明 |
|---|---|
| push_back | 尾部插入 |
| pop_back | 尾部删除 |
| find | 查找。（不是成员函数） |
| insert | 在position之前插入val |
| erase | 删除position位置的数据 |
| swap | 交换两个vector的数据空间 |
| operator[] | 像数组一样访问 |
iv2.push_back(666);//尾部插入666
cout << "iv2: ";
for (auto &e : iv2)
{cout << e << " ";}
cout << endl;
iv2.insert(iv2.begin(), 666);//在开头插入666
iv2.pop_back();//尾部删除
cout << "iv2: ";
for (auto &e : iv2)
{cout << e << " ";}
cout << endl;
auto pos = find(iv2.begin(), iv2.end(), 0);
iv2.insert(pos, 99);//在值为0的位置前插入99
cout << "iv2: ";
for (auto &e : iv2)
{cout << e << " ";}
cout << endl;
auto pos1 = find(iv2.begin(), iv2.end(), 5);
iv2.erase(pos1);//删除值为5位置的元素
cout << "iv2: ";
for (auto &e : iv2)
{cout << e << " ";}
cout << endl;
vector<int> iv3(5, 2);//创建长度为5的数组数据都为2
iv2.swap(iv3);//交换iv2和iv3
cout << "iv2: ";
for (auto &e : iv2)
{cout << e << " ";}
cout << endl;
5.迭代器失效的问题
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，vector的迭代器就是原生态指针*T，因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，就会造成程序崩溃。
vector<int>::iterator it2 = (iv2.begin());
cout << "*it2= " << *it2 << endl;
cout << "size = " << iv2.size() << endl;
cout << "capacity = " << iv2.capacity() << endl;
iv2.push_back(5);//插入导致需要重新开辟空间
cout << "*it2= " << *it2 << endl;//再次访问it2时，it2已经失效
1.会引起vector底层空间改变的操作，都有可能是迭代器失效，比如，resize，reserve，insert，assign，push_back等这些可能会使底层原有空间被释放掉（因为要扩容），而在打印时，使用的依然还是被释放的原有空间，从而使程序崩溃。
解决方法：在以上操作完成后，给迭代器重新赋值。
it2 = find(iv2.begin(), iv2.end(), 5);
2.指定位置元素的删除操作erase
（根据编译器不同而不同，VS是删除哪个位置，就会导致该位置的迭代器失效，erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上来说迭代器应该不会失效），但是如果刚好是最后一个元素，删完之后刚好是end的位置，而end位置是没有元素的，pos的it就会失效。因此在删除vector任意位置的元素时，vs就认为该位置迭代器失效了。
int arr1[] = { 1, 2, 3, 4 };
vector<int> iv6(arr1, arr1 + sizeof(arr1) / sizeof(arr1[0]));
vector<int>::iterator it3 = find(iv6.begin(), iv6.end(), 3);
iv6.erase(it3);//删除值为3的元素
cout << "iv6: ";
for (auto &e : iv6)
{cout << e << " ";}
cout << endl;
cout << "*it3 = " << *it3 << endl;//再次访问it3
因为我用的是VS所以会报错。
我们再来看一下erase之后是返回指向下一个数据的迭代器还是指向原位置。
int arr1[] = { 1, 2, 3, 4,5 };
vector<int> iv6(arr1, arr1 + sizeof(arr1) / sizeof(arr1[0]));
vector<int>::iterator it3 = find(iv6.begin(), iv6.end(), 3);
auto it4 = iv6.erase(it3);//删除值为3的元素
cout << "*it4 = " << *it4 << endl;//看一下it4指的是4还是5
可见erase的返回值依旧是指向原来位置的迭代器，只不过删除原位置的数据后，其后面的元素往前挪，所以是4。
三、vector的简单模拟
#include <iostream>
using namespace std;
namespace LJL
{
template<class _Ty>
class vector
{
public:
typedef _Ty* iterator;//迭代器就是原生指针
public:
vector() :_First(nullptr),
_Last(nullptr),
_End(nullptr)
{}
vector(int n, const _Ty &x = _Ty())
:_First(nullptr), _Last(nullptr), _End(nullptr)
{
reserve(n);
while (n--)
push_back(x);
}
vector(vector<_Ty> &v) :
_First(nullptr), _Last(nullptr), _End(nullptr)
{
reserve(v.capacity());
iterator it = begin();
iterator it1 = v.begin();
while (it1 != v.end())
{
*it++ = *it1++;
}
_Last = it;
}
vector<_Ty> & operator=(vector<_Ty> v)
{
vecter<_Ty> tmp(v);
swap(tmp);
return *this;
}
~vector()
{
delete _First;
_First = _Last = _End = nullptr;
}
public:
size_t size()const
{return _Last - _First;}
size_t capacity()const
{return _End - _First;}
bool empty()
{return _First == _Last;}
iterator begin()
{return _First;}
iterator end()
{return _Last;}
iterator rbegin()
{return _Last;}
iterator rend()
{return _First;}
_Ty& operator[](size_t pos)
{return _First[pos];}
void push_back(const _Ty &x)
{insert(end(), x);}
void pop_back(const _Ty &x)
{erase(--end());}
void swap(vector<_Ty> &v)
{
swap(_First, v._First);
swap(_Last, v._Last);
swap(_End, v._End);
}
public:
void reserve(size_t n)
{
if (n > capacity())
{
//扩容
size_t old_size = size();
_Ty *new_first = new _Ty[n];
//memcpy(new_first, _First, sizeof(_Ty)*old_size);
//delete[]_First;
if (_First)
{
for (size_t i = 0; i < old_size; ++i)
new_first[i] = _First[i];
}
_First = new_first;
_Last = _First + old_size;
_End = _First + n;
}
}
void resize(size_t n, const _Ty &x = _Ty())
{
if (n <= size())
{
_Last = _First + n;
return;
}
else
{
if (n > capacity())
{
reserve(n);
}
iterator cur = _Last;
_Last = _First + n;
while (cur != _Last)
{
*cur = x;
++cur;
}
}
}
iterator insert(iterator _P, const _Ty &x)//返回的迭代器指向新插入的元素
{
//确定空间是否够
if (_Last == _End)
{
size_t p_size = _P - _First;
size_t new_size = size() == 0 ? 1 : size() * 2;
reserve(new_size);
_P = _First + p_size;//修改_P迭代器
}
//后移
iterator end = _Last;
while (end > _P)
{
*end = *(end - 1);
--end;
}
*_P = x;
++_Last;
return _P;
}
iterator erase(iterator pos)
{
// 挪动数据进行删除
iterator begin = pos + 1;
while (begin != _Last)
{
*(begin - 1) = *begin;
++begin;
}
--_Last;
return pos;
}
private:
iterator _First;//指向空间起始
iterator _Last;//指向空间内任一位置
iterator _End;//空间尾部
};
}
少了几个接口，暂时没能搞出来，等解决了再到评论区补充。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
