在C语言中,数组的大小是只能设为常量的,使用起来很不方便,于是在C++中就诞生了vector
1.vector是个可变大小的动态数组,是一个容器;
2.vector采用连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问;
3.vector使用动态分配数组来存储元素,当数组为了增加存储空间时,会重新分配新大小的数组空间,然后将之前的全部元素移到这个数组,时间代价很大;
4.vector空间分配策略:vector会分配一些额外的空间以适应可能的增长,因为存储空间比实际需要的存储空间更大。不同库采用不同的策略权衡空间的使用和重新分配。但是无论如何,重新分配都应该是对数增长的间隔大小,以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的,但在中间插入元素时需要移动元素,时间效率很低;
5.vector访问元素的时候相比其他容器更高效。
在使用库中的vector时需要引头文件
代码如下(示例):
构造函数 | 接口说明 |
---|---|
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数组为区间创建数组
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;
容量空间 | 接口说明 |
---|---|
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在开辟空间时还会进行初始化。
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;
迭代器的主要作用就是让算法能够不用关心底层数据结构,其底层实际就是一个指针,或者是对指针进行了封装,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。
#include
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;//空间尾部
};
}
少了几个接口,暂时没能搞出来,等解决了再到评论区补充。