vector容器&&模拟实现函数解析
一、vector介绍使用
(1)vector介绍：
概念：
vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
理解：
vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
vector分配空间策略：
vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
对比：
与其它动态序列容器相比， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好。
(2)vector使用：
1.构造函数
vector()： 无参构造。
vector（size_type n, const value_type& val = value_type())：构造并初始化n个val
vector (const vector& x)：拷贝构造。
vector (InputIterator first, InputIterator last) ：使用迭代器进行初始化构造。
2.vector iterator 起始终止使用
begin +end：获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置
的iterator/const_iterator。
rbegin + rend：获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的
reverse_iterator。
3.vector 空间增长和个数接口
size :获取数据个数
capacity :获取容量大小
empty :判断是否为空
resize: 改变vector的size
reserve :改变vector的capacity
4.vector 增删查改
push_back: 尾插
pop_back: 尾删
insert :在position之前插入val
erase: 删除position位置的数据
swap :交换两个vector的数据空间
operator[] :像数组一样访问
find ：查找（这个是算法库函数里的，不是容器接口）
二、vector 迭代器失效问题
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T，但是VS下不是原生指针，它进行了封装，g++是一个原生指针，所以说vector下的迭代器不一定都是原生指针*。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。
对于vector可能会导致其迭代器失效的操作有：
1、空间改变
会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。
也就是说vector底层原理旧空间被释放掉，而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的空间，而引起代码运行时崩溃。
比如在reserve扩容的时候，导致了源空间释放，再看插入的时候，当空间满了需要扩容。
解决：
想要继续通过迭代器操作vector中的元素，只需给it重新赋值即可。
1 如图：在扩容和push_back
这时候reserve了空间，原空间释放，在遍历的时候就会发生奔溃，出了野指针问题，这时候我们就需要对it进行重新赋值，扩容之后更新一下it=v.begin()。push_back的时候也一样。
2 如下代码
iterator insert(iterator pos, const T& val)
{
assert(pos <= _finish);
assert(pos >= _start);
if (_finish == _end_capacity)
{
int len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + pos;
}
iterator end = _finish - 1;
while(end>=pos)
{
*(end+1) = *end;
--end;
}
*pos = val;
++_finish;
return pos;
}
在插入的时候遇到扩容的情况，原空间释放，这是就要用相对位置来计算pos的的位置，这是为了应对挪动数据的情况。在insert的时候需要返回pos，是为了对pos进行操作，也就是插入元素的后面位置，因为后面再使用pos的位置会发生错，虽然pos在栈里面已经改变了，但不影响外面，所以这里进行传值返回，外面接收它，就可以对pos操作，这就相当于对it进行重新赋值。
如图：
2、指定位置元素的删除操作–erase
erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效。
1 但是如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。
2 还有删除vector中所有的偶数，删除pos位置之后就失效了，如果进行++，对它操作就会发生崩溃 。
如图：
这时候需要在while里面需要用it接收，其实还是重新赋值的思想，当是偶数的时候删除之后，迭代器失效，再使用it的时候就失效，如果在g++的情况可能不失效，但是erase删除的时候会往前挪会漏删，所以用it接收返回值对it重新赋值，就能解决以上两种情况。
Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。虽然可能运行，但是输出的结果是不对的。
3、string在进行插入+扩容操作+erase之后，迭代器也会失效
如图：
放开之后代码会崩溃，因为resize到50会string会进行扩容，之后，it指向之前旧空间已经被释放了，该迭代器就失效了，后面打印时，再访问it指向的空间程序就会崩溃。
还有erase之后不赋值接收，运行时程序会崩溃，因为erase(it)之后，it位置的迭代器就失效，s.erase(it);
三、vector容器模拟实现及函数解析
3.1vector构造函数指针初始化
public:
typedef T* iterator;
typedef const T* const_iterator;
vector()//构造函数
{
}
private:
iterator _start=nullptr;
iterator _finish=nullptr;
iterator _end_capacity=nullptr;
vector里面iteraror是一个原生指针，为了保持一致在模模拟的时候用typdef重新定义下T*，里面的构造函数进行初始化，可以在初始化列表中进行也可以直接在私有域里面进行初始化。其中_start是起始位置，_finish是终止位置，_end_capacity是容量位置。
3.2析构函数
~vector()
{
delete[] _start;
_start = _finish = _end_capacity = nullptr;
}
析构也就是释放空间资源，因为_start是指向的空间，直接delete，后面并把成员变量置为空。
3.3vector起始终止位置返回接口
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
begin获取第一个数据位置的iterator/const_iterator，end是 获取最后一个数据的下一个位置的iterator/const_iterator，事实上返回的是一个指针。
3.4vector返回个数和容量接口
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _end_capacity - _start;
}
返回个数直接终止位置减去开始位置，容量大小是容量位置减去开始位置。
3.5vecror两类扩容函数
void resize(size_t n, T val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
if (n>capacity())
{
reserve(n);
}
while (_finish != _start + n)
{
(*_finish) = val;
++_finish;
}
}
}
void reserve(size_t n)
{
if (n > capacity())
{
T* tmp = new T[n];
size_t size1 = size();
if (_start)
{
for (size_t i = 0; i < size1; ++i)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + size1;
_end_capacity = _start + n;
}
}
1、resize扩容函数：它的特点是开空间初始化，_finish会随传入的n的大小而变化，如果是<当前的_size会直接+n删除数据，反之会补充剩余的字符。用一个if esle语句去解决，如果小于就把_finish就更新，else里面需要看是否扩容，如果需要直接复用reserve，反之用while循环进行插入。
2、reserve扩容函数： 它的特点是提前开好空间，size不会变，如果传入的n大于当前容量，就异地扩，开辟另一个空间，把_str的内容赋值过去，再释放掉 _start,然后把tmp重新赋给 _start,再更新终止位置和容量，这里面需要注意更新_finish的时候,不要直接加size，因为它返回的是_finish - _start，这样就变成了_finish,可能为空，所以再定义个变量保存下来。在把内容赋值的时候，不能直接用memcpy了，如果vector里面是一个类对象比如string或者又嵌入一个vector，那么就变成深拷贝了，所以要赋值，比如里面是string的时候，那在赋值的时候就会调用string(它的赋值重载就直接调用库里面的)的赋值重载，如果是再嵌入一个vector，就调用vector它的赋值重载在下面进行分析)的赋值重载，因为赋值重载的逻辑是另外开一个和后者一样大的临时空间，再把旧空间(前者)释放掉，再把开的空间赋值给前者，这样就能解决深拷贝问题。
3.6vector尾插&&头插函数
void push_back(const T& x)
{
if (_finish == _end_capacity)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = x;
++_finish;
}
iterator insert(iterator pos, const T& val)
{
assert(pos <= _finish);
assert(pos >= _start);
if (_finish == _end_capacity)
{
int len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + pos;
}
iterator end = _finish - 1;
while(end>=pos)
{
*(end+1) = *end;
--end;
}
*pos = val;
++_finish;
return pos;
}
1、尾插：尾插就是在尾部插入，那就能想到它的终止位置，就直接在它的尾部进行赋值，再更新_finish的位置，但是vector本质是一个动态数组,插入的时候就需要考虑它的空间够不够用，也即是扩容，如果终止位置等于容量的位置，就直接调用reserve进行扩容。
2、头插：头插就是在头部插入，也即是pos的前面插，首先先进行两次断言必须在_start和_finishd范围进行插入，实现逻辑大致和sring类一样，可以把end位置往后挪一位或者往前挪一位，也即从最后一个位置的下一个位置开始挪动。把end的数赋给end+1，这样end等于pos的时候就停止，而且第一个位置也已经被挪动。再进行赋值并更新_finish。其中扩容的时候需要注意迭代器失效也即是pos，因为在扩容的时候空间是开的新空间，新空间那就对应新地址，pos的相对原先肯定发生变化，会导致pos的位置会变大或变小，如果变小end走完了还没到那个位置，如果变大end还没走完就到了那位置，此时的位置是错的，所以在这里要更新pos的位置，在扩容之前先记录pos到开始的距离，最后在新开的空间加上距离。
3.7vector任意位置的删除函数
iterator erase(iterator pos)
{
assert(pos <= _finish);
assert(pos >= _start);
itetator first = pos + 1;
while (first!=_finish )
{
*(first - 1) = *first;
++first;
}
--_finish;
return pos;
}
首先一样是断言，在可删范围内进行删除，删除的时候就把pos后面元素进行往前覆盖，那么先记录一下pos下一个位置，然后用while循环进行往前覆盖，最后循环完，因为删除的是一个元素，所以进行–_finish,为了防止迭代器失效进行返回pos。
3.8vector构造并初始化n个val
vector(size_t n, const T& val = T())
{
reserve(n);
for (size_t i = 0; i<n; ++i)
{
push_back(val);
}
}
vector(int n, const T& val = T())
{
reserve(n);
for (int i = 0; i<n; ++i)
{
push_back(val);
}
}
构造并初始化n个val，那么里面先进行扩容，直接for循复用尾插函数就可完成，再写一个int型，构成函数重载。
3.9vecror迭代器进行初始化构造
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
在进行迭代器初始化构造的时候，需要考虑到不同迭代器，比如vector和string迭代器是一个random access iterator 随机迭代器，而list是一个bidirectional iterator 双向迭代器,forward_iterator是一个forward iterator 单向迭代器，增强代码适应性，就用一个函数模板，进行把某种迭代器的区间的值进行尾插到实例化对象的空间中去。
3.10vector尾部删除函数
void pop_back()
{
assert(!empty());
--_finish;
}
尾部删除先断言是否为空。如果不为空就直接–_finish。
3.11vector交换函数
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_capacity, v._end_capacity);
}
交换函数那就直接复用库里面的，三个成员变量进行交换。
3.12vector拷贝构造函数
vector(const vector<T>& v)
{
_start = new T[v.capacity()]; // 1
for (size_t i = 0; i < v.size(); ++i)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
_end_capacity = _start + v.capacity();
/*vector<T> tmp(v.begin(), v.end());// 2
swap(tmp);*/
}
如果是默认生成是浅拷贝，如果涉及空间问题就得手动写，因为会指向同一个空间，析构两次，会崩溃，修改还会互相影响。所以要有独立的空间，里面开一个和是capacity()一样大的空间，最后指向_start。但是这面临同样的问题即深拷贝问题在把内容赋值的时候，不能直接用memcpy了，如果vector里面是一个类对象比如string或者又嵌入一个vector，那么就变成深拷贝了。
第一种方法:,一个一个赋值，这种方法是传统的我是比较用这种，比如里面是string的时候，那在赋值的时候就会调用string(它的赋值重载就直接调用库里面的)的赋值重载，如果是再嵌入一个vector，就调用vector它的赋值重载(在下面进行分析)，因为赋值重载的逻辑是另外开一个和后者一样大的临时空间，再把旧空间(前者)释放掉，再把开的空间赋值给前者，这样就能解决深拷贝问题,最后更新_finish和_end_capacity。
第二种方法：调用迭代器进行初始化构造给一个临时变量，其本质还是调用了赋值重载函数，因为在里面调用了push_back,而里面有赋值，在把每个元素进行赋值完之后，就开始再次交换外面的空间，因为外面的两个空间也不能指向同一个空间，就直接调用swap函数，因为swap函数可以把它俩的地址换了一下，在外面来看就没有开空间，即把等号右面的空间指向左面的，左面的空间指向右面的空间。就可解决外面的深拷贝问题。
3.13vector赋值重载函数
vector<T>& operator = (vector<T> v)
{
if (this != &v) //1
{
T* tmp = new T[v.capacity()];
memcpy(tmp, v._start, sizeof(T)*v.size());
delete[] _start;
_start = tmp;
_finish = _start + v.size();
_end_capacity = _start + v.capacity();
}
return *this; //这是常规思路,可以复用swap函数
/*swap(v); //2
return *this;*/
}
第一种是：而在赋重载的时候我先自己写了个传统的，还是先开辟空间，再把要赋值的每个首地址的内容用mecmpy拷进去，释放原来的空间，把_start指向临时空间，更新_finish和_end_capacity。
第二种是：直接调用swap，它的逻辑和拷贝构造一样，返回*this。
3.14vector判空函数
bool empty()
{
return _start == _finish;
}
判空函数是判断一个vector里面是否为空，当开始位置等于终止位置时就是空，因为开始的位置是不会进行++的，所以返回它两是否相等。
3.15vector返回重载函数
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos]
}
返回重载函数直接用首地址加下标解引用进行返回，如果是const对象就直接函数重载一个。
四、vector容器模拟实现代码
(1)simulate_vector.h
# pragma once
#include<assert.h>
#include<algorithm>
//#include<vector>
#include<string>
namespace nza
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
vector()//构造函数
{
}
~vector()
{
delete[] _start;
_start = _finish = _end_capacity = nullptr;
}
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _end_capacity - _start;
}
vector(const vector<T>& v)
{
/*_start = new T[v.capacity()];
for (size_t i = 0; i < v.size(); ++i)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
_end_capacity = _start + v.capacity();*/
vector<T> tmp(v.begin(), v.end());
swap(tmp);
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_capacity, v._end_capacity);
}
vector<T>& operator = (vector<T> v)
{
/* if (this != &v)
{
T* tmp = new T[v.capacity()];
memcpy(tmp, v._start, sizeof(T)*v.size());
delete[] _start;
_start = tmp;
_finish = _start + v.size();
_end_capacity = _start + v.capacity();
}
return *this; */ //这是常规思路,可以复用swap函数
swap(v);
return *this;
}
vector(size_t n, const T& val = T())
{
reserve(n);
for (size_t i = 0; i<n; ++i)
{
push_back(val);
}
}
vector(int n, const T& val = T())
{
reserve(n);
for (int i = 0; i<n; ++i)
{
push_back(val);
}
}
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
void resize(size_t n, T val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
if (n>capacity())
{
reserve(n);
}
while (_finish != _start + n)
{
(*_finish) = val;
++_finish;
}
}
}
void reserve(size_t n)
{
if (n > capacity())
{
T* tmp = new T[n];
size_t size1 = size();
if (_start)
{
for (size_t i = 0; i < size1; ++i)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + size1;
_end_capacity = _start + n;
}
}
void push_back(const T& x)
{
if (_finish == _end_capacity)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = x;
++_finish;
}
void pop_back()
{
assert(!empty());
--_finish;
}
iterator insert(iterator pos, const T& val)
{
assert(pos <= _finish);
assert(pos >= _start);
if (_finish == _end_capacity)
{
int len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + pos;
}
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);
itetator first = pos + 1;
while (first!=_finish )
{
*(first - 1) = *first;
++first;
}
--_finish;
return pos;
}
bool empty()
{
return _start == _finish;
}
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos]
}
private:
iterator _start=nullptr;
iterator _finish=nullptr;
iterator _end_capacity=nullptr;
};
}
(2)test.cpp
#include<iostream>
using namespace std;
#include"simulate_vector.h"
class Solution {
public:
nza::vector<nza::vector<int>> generate(int numRows) {
nza::vector<nza::vector<int>> vv;
vv.resize(numRows, nza::vector<int>());
for (size_t i = 0; i < vv.size(); ++i)
{
vv[i].resize(i + 1, 0);
vv[i][0] = vv[i][vv[i].size() - 1] = 1;
}
for (size_t i = 0; i < vv.size(); ++i)
{
for (size_t j = 0; j < vv[i].size(); ++j)
{
if (vv[i][j] == 0)
{
vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
}
}
}
return vv;
}
};
void test1()
{
nza::vector<int> v1;
v1.push_back(14);
v1.push_back(15);
v1.push_back(16);
v1.push_back(17);
v1.push_back(18);
for (size_t i = 0; i < v1.size(); ++i)
{
cout << v1[i] << " ";
}
cout << endl;
v1.pop_back();
v1.pop_back();
nza::vector<int>::iterator it = v1.begin();
while (it != v1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
v1.pop_back();
v1.pop_back();
for (auto v : v1)
{
cout << v << " ";
}
cout << endl;
}
void test2()
{
std::string s1("hello");
nza::vector<int> v3(s1.begin(), s1.end());
for (auto e : v3)
{
cout << e << " ";
}
cout << endl;
}
void test3()
{
nza::vector<std::string> v3(3, "dddddddddd");
for (auto e : v3)
{
cout<<e<<" ";
}
cout << endl;
nza::vector<std::string> v4(v3);
for (auto e : v4)
{
std::cout << e << " ";
}
cout << endl;
v4.push_back("kkkkkkkkkkk");
v4.push_back("kkkkkkkkkkk");
v4.push_back("kkkkkkkkkkk");
for (auto e : v4)
{
cout << e << " ";
}
cout << endl;
}
void test4()
{
nza::vector<nza::vector<int>> ret =Solution().generate(5);
for (size_t i = 0; i < ret.size(); ++i)
{
for (size_t j = 0; j < ret[i].size(); ++j)
{
cout << ret[i][j] << " ";
}
cout << endl;
}
cout << endl;
}
int main()
{
test1();
test2();
test3();
test4();
return 0;
}
(3)运行结果
