vector的模拟实现
文章目录
- vector的模拟实现
-
- vector的基础框架
- 常用函数的实现
- 完整模拟实现代码
vector的模拟实现
先了解vector底层的成员变量的表示的含义
vector成员变量由三个start、finish、end_of_storage三个迭代器组成，分别表示不同的迭代器地址
注意：capacity的初始值和初始化有关，std中vector的初始化如果是默认构造，capacity默认为0，如果是vector
vector的基础框架
将我们模拟实现的基础框架放在命名空间why中，主要是对于成员变量、构造函数、析构函数、push_back、reserve的实现
注意：reserve中使用old_size变量提前得到当前数据个数，是防止扩容后迭代器失效，能正确的更新_finish,更新成员变量都是通过以_start为基准的偏移量实现，_finish=_start+size(),_end_of_storage=_start+capacity()
namespace why
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
//构造函数
vector()
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{}
//析构函数
~vector()
{
if (_start)
{
//如果不为空的话，那么就进行释放_start的空间，并指向空nullptr
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
}
void push_back(const T& x)
{
//添加元素，先进行判定当前容量
if (_finish == _end_of_storage)
{
//需要进行扩容
size_t new_capacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(new_capacity);
}
*_finish = x;
++_finish;
}
void reserve(size_t n)
{
//判断是否需要扩容
if (n > capacity())
{
//进行扩容
//防止迭代器失效
size_t old_size = size();
T* tmp = new T[n];
if (_start)
{
//如果不为空
memcpy(tmp, _start, sizeof(T) * old_size);
delete[] _start;
}
_start = tmp;
_finish = _start + old_size;
_end_of_storage = _start + n;
}
}
//得到pos下标的数值
T& operator[](size_t pos)
{
return _start[pos];
}
const T& operator[](size_t pos) const //对于静态变量
{
return _start[pos];
}
size_t capacity() const
{
return _end_of_storage - _start;
}
size_t size() const
{
return _finish - _start;
}
private:
iterator _start;//表示开头地址
iterator _finish;//表示当前结尾元素的地址
iterator _end_of_storage;//表示当前vector最大容量的地址
};
}
常用函数的实现
常用的函数实现，比如insert、erase、resize等，以此来了解stl中vector函数实现机制，更好的理解vector
insert的实现
在pos位置上插入val，要考虑迭代器失效的问题，所以在扩容之前就要得到相对位置len，然后得到扩容后的pos位置
iterator insert(iterator pos, const T& x)
{
assert(pos >= _start && pos <= _finish);
if (_finish == _end_of_storage)
{
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
// 解决pos迭代器失效问题
pos = _start + len;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
return pos;
}
erase的实现
erase的实现比较简单，就是在指定pos位置的后一位，统一向前移动数组，--_finsh,返回pos的地址
iterator erase(iterator pos)
{
assert(pos >= _start && pos < _finish);
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}
resize的实现
对于容器来讲，先实现reserve就能方便实现其他内容，因为很多接口的底层中包含reserve，我们先实现resize
void resize(size_t n, const T& val = T())
{
if (n < size())
{
_finish = _start + n; //直接更新_finish
}
else
{
reserve(n);//判断是否需要扩容
//从_finish位置开始添加元素
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}
vector的拷贝构造
对于一些自定义类型，如果涉及到资源管理（开辟空间，比如string，会开辟char*的空间），当进行拷贝构造的时候，我们需要的是深拷贝，而不是简单的值拷贝
vector(const vector<T>& v)
{
_start = new T[v.capacity()];
//memcpy(_start, v._start, sizeof(T)*v.size());
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
_end_of_storage = _start + v.capacity();
}
/// operator= 函数
考虑到自定义对象，所以我们还是使用深拷贝的方式。使用现代的手法，swap交换成员变量
void swap(vector<T>& v)
{
//交换地址即可，这样给了当前对象，然后v和当前对象没有指向同一块空间，不会出现析构两次的问题
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
}
// v1 = v2
vector<T>& operator=(vector<T> v) //传值即可，会调用拷贝构造，深拷贝到得到一块新空间，但是数据是一样的，然后将这个空间的数据通过swap与当前self对象进行交换，完毕之后，不会改变实参vector对象的的成员变量，只是改变了拷贝构造之后的v的成员变量
{
swap(v);
return *this;
}
函数测试
void test11()
{
why::vector<string> v;
v.push_back("123");
v.push_back("123");
v.push_back("123");
v.push_back("123");
for (auto c : v)
{
cout << c << " ";
}
cout << endl;
why::vector<string> v1(v);
for (auto c : v1)
{
cout << c << " ";
}
cout << endl;
why::vector<string> v2;
v2 = v;
for (auto c : v2)
{
cout << c << " ";
}
cout << endl;
}
int main()
{
test11();
return 0;
}
完整模拟实现代码
namespace why
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
//构造函数
vector()
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{}
~vector()
{
if (_start)
{
//如果不为空的话，那么就进行释放_start的空间，并指向空nullptr
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
}
void resize(size_t n, const T& val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
reserve(n);
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}
iterator insert(iterator pos, const T& x)
{
assert(pos >= _start && pos <= _finish);
if (_finish == _end_of_storage)
{
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
// 解决pos迭代器失效问题
pos = _start + len;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
return pos;
}
iterator erase(iterator pos)
{
assert(pos >= _start && pos < _finish);
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}
//vector(size_t n, const T& val = T())
//{
// resize(n, val);
//}
//vector(int n, const T& val = T())
//{
// resize(n, val);
//}
// [first, last)
//template& v)
//{
// _start = new T[v.capacity()];
// //memcpy(_start, v._start, sizeof(T)*v.size());
// for (size_t i = 0; i < v.size(); i++)
// {
// _start[i] = v._start[i];
// }
// _finish = _start + v.size();
// _end_of_storage = _start + v.capacity();
//}
void push_back(const T& x)
{
//添加元素，先进行判定当前容量
if (_finish == _end_of_storage)
{
//需要进行扩容
size_t new_capacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(new_capacity);
}
*_finish = x;
++_finish;
}
vector(const vector<T>& v)
{
_start = new T[v.capacity()];
//memcpy(_start, v._start, sizeof(T)*v.size());
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
_end_of_storage = _start + v.capacity();
}
void reserve(size_t n)
{
//判断是否需要扩容
if (n > capacity())
{
//进行扩容
//防止迭代器失效
size_t old_size = size();
T* tmp = new T[n];
if (_start)
{
//如果不为空
memcpy(tmp, _start, sizeof(T) * old_size);
delete[] _start;
}
_start = tmp;
_finish = _start + old_size;
_end_of_storage = _start + n;
}
}
/// & v)
// :_start(nullptr)
// , _finish(nullptr)
// , _end_of_storage(nullptr)
//{
// reserve(v.capacity());
// for (auto e : v)
// {
// push_back(e);
// }
//}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
}
// v1 = v2
vector<T>& operator=(vector<T>& v)
{
swap(v);
return *this;
}
//得到pos下标的数值
T& operator[](size_t pos)
{
return _start[pos];
}
const T& operator[](size_t pos) const //对于静态变量
{
return _start[pos];
}
size_t capacity() const
{
return _end_of_storage - _start;
}
size_t size() const
{
return _finish - _start;
}
private:
iterator _start;//表示开头地址
iterator _finish;//表示当前结尾元素的地址
iterator _end_of_storage;//表示当前vector最大容量的地址
};
}