Vector
Vector同样是STL六大组件之一，简单来讲他就是一个封装了动态大小数组的顺序容器，同时他可以存入各种各样的对象，比如int，char，string类型等等
因为其本质上是一个顺序容器，所以他是按照顺序的方式进行存储，和数组类似，并且他能够动态的存储，即容器可以进行插入删除，改变大小
类成员
private:
iterator _start;
iterator _last;
iterator _endofstorage;
_start是头指针，_last是尾指针，_endofstorage是最多能够存储到的为位置（容器大小）
ps：iterator迭代器指针在后面哦
构造函数，拷贝构造函数和析构函数
vector()
:_start(nullptr)//均为空指针
,_last(nullptr)
,_endofstorage(nullptr)
{}
template <class InputIterator>
vector(InputIterator first, InputIterator last)//此构造函数，可以让别的容器
: _start(nullptr) //能够存入vector容器中
, _last(nullptr)
, _endofstorage(nullptr)
{
while (first != last)
{
push_back(*first);//逐个插入
++first;
}
}
// v2(v1)，传统写法
vector(const vector<T>& v)
:_start(nullptr)
, _last(nullptr)
, _endofstorage(nullptr)
{
reserve(v.capacity());
for (const auto& e : v)//可以直接通过范围for来逐个插入到v2中，不用像现代写法重新开辟tmp的vector对象
{
push_back(e);
}
}
~vector()
{
delete[] _start;//记得加[]哦
_last = nullptr;
_start = nullptr;
_endofstorage = nullptr;
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_last, v._last);
std::swap(_endofstorage, v._endofstorage);
}
//现代写法v1=v2
vector<T>& operator=(vector<T> v)//这里没用使用引用，即在创建v时会开辟一个新的空间
{
swap(v);//此时直接调用swao函数即可，且v为形参，swap后获得this原本的数据，函数结束时v同原本this数据一同释放
return *this;
}
在Vector容器内同样是进行深拷贝的
这里我没有写=的传统写法和()的现代写法，感兴趣的小伙伴可以自己去了解一下哦
迭代器
这里使用了模板，使得vector可以传入各种类型的数据
typedef T* iterator;//对象的内容可以进行读写操作
typedef const T* const_iterator;//对象的内容只能进行读操作
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _last;
}
iterator begin()
{
return _start;
}
iterator end()
{
return _last;
}
在这里和String的迭代器一样，他们的本质是指针，但是对于别的容器他们的本质就并不是指针了，后面的写到list容器时我会解释，不过要记住迭代器是为了让我们对容器的操作使用起来像指针一样
函数功能
size_t size()//对象的大小
{
return _last - _start;
}
size_t capacity()//对象的容量
{
return _endofstorage - _start;
}
bool empty()//是否为空
{
return _start == _last;
}
void reserve(size_t n)//开空间
{
if (n > size())
{
size_t sz = size();
T* tmp = new T[n];
memcpy(tmp, _start, sizeof(T) * sz);
_start = tmp;
_last = _start + sz;
_endofstorage = _start + n;
}
}
void resize(size_t n,const T& val=T())
{
if (n <= size())
{
_last = _start + n;//是减小大小，而不是扩大
}
else
{
if (n > capacity())
{
reserve(n);
}
while(_last<_start+n)//不用等于，因为_last是指向有效字符的后一位
{
*_last= val;
_last++;
}
}
}
T& operator[](size_t n)//可以和数组一样使用
{
assert(n < size());
return _start[n];
}
const T& operator[](size_t n) const
{
assert(n < size());
return _start[n];
}
void Push_back(const T& x)
{
/*if (_last==_endofstorage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_last = x;
++_last;*/
insert(end(), x);
}
void Pop_back()
{
assert(!empty());
--_last;
}
iterator insert(iterator pos, const T& x)
{
assert(pos >= _start && pos <= _last);
if (_last == _endofstorage)
{
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
pos = _start + len;
}//此语句是为了提高复用性，可以直接对Push_back进行复用
//size_t len = pos - _start;
//iterator end = _last + 1;
//if (_last == _endofstorage)
//{
// reserve(capacity() + 1);
//}
//pos = _start + len;//注意：重新开空间后pos也变成野指针；所以要重新找回来
//end = _last;//注意：end必须在if语句后面在写一次，因为resrve函数会重新开空间，不然end会变成野指针
iterator end = _last;
while (end >= pos)
{
*end = *(end - 1);//注，这里不能用--end，因为前面的end也会被改变
--end;
}
*pos = x;
++_last;
return pos;//为了给用户能够重新使用原本指向的数，避免野指针的情况
}
iterator erase(iterator pos)
{
assert(pos >= _start && pos <= _last);
iterator end = pos + 1;
while (end < _last)
{
*(end - 1) = *end;//注，这里不能用--end，因为前面的end也会被改变
++end;
}
--_last;
return pos;//同样为了避免野指针问题，给用户一个返回值，是被删元素的后面一个值
}
vector的功能和string的大致相同，值得注意的是，vector里面的insert和erase函数，当使用了他们后，原先的迭代器就没有用了，成为了野指针，这是因为vector对象在插入时候，如果空间不足，会重新开辟一个新的空间，而迭代器指向的是原先空间的指针，便无法使用。但如果空间足够不需要开空间呢？迭代器仍然指向有效的空间，但是迭代器指向的值本不是我们原先的值，因为那个空间的数据经过移动，改变了，此时我们仍然视其为野指针。所以对于insert和erase函数，我们都会给一个返回的迭代器给用户接受使用，insert是插入的数据，erase是删除数据的下一个值
如
vector<int> v;
v.Push_back(1);
v.Push_back(2);
v.Push_back(3);
v.Push_back(4);
vector<int>::iterator it = v.begin();
it = v.insert(it+1 , 9);
cout << *it << " ";
cout << endl;
完整代码
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _last;
}
iterator begin()
{
return _start;
}
iterator end()
{
return _last;
}
vector()
:_start(nullptr)
,_last(nullptr)
,_endofstorage(nullptr)
{}
template <class InputIterator>
vector(InputIterator first, InputIterator last)//此构造函数，可以让别的拥有头尾迭代器的容器能够存入vector容器中
: _start(nullptr)
, _last(nullptr)
, _endofstorage(nullptr)
{
while (first != last)
{
push_back(*first);
++first;
}
}
// v2(v1)，传统写法
vector(const vector<T>& v)
:_start(nullptr)
, _last(nullptr)
, _endofstorage(nullptr)
{
reserve(v.capacity());
for (const auto& e : v)//可以直接通过范围for来逐个插入到v2中，不用像现代写法重新开辟tmp的vector对象
{
push_back(e);
}
}
~vector()
{
delete[] _start;
_last = nullptr;
_start = nullptr;
_endofstorage = nullptr;
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_last, v._last);
std::swap(_endofstorage, v._endofstorage);
}
//现代写法v1=v2
vector<T>& operator=(vector<T> v)//这里没用使用引用，即在创建v时会开辟一个新的空间
{
swap(v);//此时直接调用swao函数即可，且v为形参，swap后获得this原本的数据，函数结束时v同原本this数据一同释放
return *this;
}
size_t size()
{
return _last - _start;
}
size_t capacity()
{
return _endofstorage - _start;
}
bool empty()
{
return _start == _last;
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = capacity();
T* tmp = new T[n];
memcpy(tmp, _start, sizeof(T) * sz);
_start = tmp;
_last = _start + sz;
_endofstorage = _start + n;
}
}
void resize(size_t n,const T& val=T())
{
if (n <= size())
{
_last = _start + n;//是减小大小，而不是扩大
}
else
{
if (n > capacity())
{
reserve(n);
}
while(_last<_start+n)//不用等于，因为_last是指向有效字符的后一位
{
*_last= val;
_last++;//这里改变了size的大小
}
}
}
T& operator[](size_t n)
{
assert(n < size());
return _start[n];
}
const T& operator[](size_t n) const
{
assert(n < size());
return _start[n];
}
void Push_back(const T& x)
{
/*if (_last==_endofstorage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_last = x;
++_last;*/
insert(end(), x);
}
void Pop_back()
{
assert(!empty());
--_last;
}
iterator insert(iterator pos, const T& x)
{
assert(pos >= _start && pos <= _last);
if (_last == _endofstorage)
{
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
pos = _start + len;
}//此语句是为了提高复用性，可以直接对Push_back进行复用
//size_t len = pos - _start;
//iterator end = _last + 1;
//if (_last == _endofstorage)
//{
// reserve(capacity() + 1);
//}
//pos = _start + len;//注意：重新开空间后pos也变成野指针；所以要重新找回来
//end = _last;//注意：end必须在if语句后面在写一次，因为resrve函数会重新开空间，不然end会变成野指针
iterator end = _last;
while (end >= pos)
{
*end = *(end - 1);//注，这里不能用--end，因为前面的end也会被改变
--end;
}
*pos = x;
++_last;
return pos;//为了给用户能够重新使用原本指向的数，避免野指针的情况
}
iterator erase(iterator pos)
{
assert(pos >= _start && pos <= _last);
iterator end = pos + 1;
while (end < _last)
{
*(end - 1) = *end;//注，这里不能用--end，因为前面的end也会被改变
++end;
}
--_last;
return pos;//同样为了避免野指针问题，给用户一个返回值，是被删元素的后面一个值
}
private:
iterator _start;
iterator _last;
iterator _endofstorage;
};
总结
vector和string基本相似，我们经常会使用到此容器，因为他是顺序结构，所以对于随机访问十分的方便，同样尾插尾删也很方便，但是对于插入删除（如头插头删），同样他也是进行深拷贝，所以能用引用尽量用引用，可以减少很多的空间使用
最后感兴趣的小伙伴可以看一下我的String容器的实现哦
