vector类的模拟实现

vector的认识：

vector是一个大小可以改变的序列式容器，也称为数组。也就是说vector是一段连续的空间来存储数据。
同样vector也有一系列的接口，我们要熟练使用vector的接口，首先要理解vector接口的底层实现，才能灵活运用。

vector主要也就是实现存储类型T的增删改查，同样，为了方便实现这些操作，vector底层运用了三个迭代器：_start指向数组的首部，_end指向数组中数据的下一个位置，_end_of_storage指向数组中最大容量的位置。
下面是其实现：

模拟实现

#include <iostream>
#include <cassert>
using namespace std;
template <class T>
class Vector
{
public:
typedef T* iterator;
Vector()
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{}
~Vector()
{
if (_start)
{
delete[]_start;
_start = _finish = _end_of_storage = nullptr;
}
}
Vector(const Vector<T>& v)
{
_start = new T[v.size()];
memcpy(_start, v._start,sizeof(T)*v.size());
_finish = _start + v.size();
_end_of_storage = _start + v.size();
}
void Swap(Vector<T>& v)
{
swap(_start, v._start);
swap(_finish, v._finish);
swap(_end_of_storage, v._end_of_storage);
}
Vector<T>& operator=(Vector<T> v)
{
Swap(v);
return *this;
}
void resize(size_t n, const T& val = T())
{
if (n < size())
{
_finish = _start + n;
}
if (n > capacity())
{
reverse(n);
}
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
void reverse(size_t n)
{
if (n > capacity())
{
T * tmp = new T[n];
int sz = size();
//拷贝数据
memcpy(tmp,_start,sizeof(T)*size());
delete[] _start;
_start = tmp;
_finish = _start + sz;
_end_of_storage = _start + n;
}
}
void push_back(const T& val)
{
if (_finish == _end_of_storage)
{
size_t newcapacity = capacity() == 0 ? 2 : 2 * capacity();
reverse(newcapacity);
}
*_finish = val;
++_finish;
}
void pop_back()
{
assert(_finish > _start);
--finish;
}
void insert(iterator pos, const T& x)
{
if (_finish == _end_of_storage)
{
//这里是先选出pos在原来空间上的绝对位置是多少
size_t n = pos - _start;
size_t newcapacity = capacity() == 0 ? 2 : 2 * capacity();
reverse(newcapacity);
//在新空间上的绝对位置
pos = _start + n;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
}
void erase(iterator pos)
{
assert(pos >= _start &&
pos < _finish);
iterator begin = pos + 1;
while (begin < _finish)
{
*(begin - 1) = *begin;
begin++;
}
--_finish;
}
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _end_of_storage - _start;
}
T& operator[](size_t pos) const
{
return _start[pos];
}
const T& operator[](size_t pos) const
{
return _start[pos];
}
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
private:
iterator _start;
iterator _finish;
iterator _end_of_storage;
};
void test1()
{
Vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.insert(v.begin(), 10);
auto it = v.begin();
v.erase(it);
v.erase(it);
v.erase(it);
for (int i = 0; i < v.size(); i++)
{
cout << v[i] << " ";
}
cout << endl;
}
int main()
{
Vector<int> v1;
v1.push_back(1);
v1.push_back(1);
v1.push_back(1);
v1.push_back(1);
Vector<int> v(v1);
for (auto e : v)
{
cout << e << " ";
}
system("pause");
}

最后

以上就是兴奋紫菜为你收集整理的【C++】vector类的模拟实现vector类的模拟实现的全部内容，希望文章能够帮你解决【C++】vector类的模拟实现vector类的模拟实现所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。