文章目录：
🛰️vector模拟实现底层结构
🛰️vector基础框架
namespace hy
{
template<class T>
class vector
{
public:
//vector的迭代器是一个原生指针
typedef T* iterator;
typedef const T* const_iterator;
vector()
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{}
~vector()
{
if (_start)
{
delete[] _start;
}
_start = _finish = _endofstorage = nullptr;
}
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
};
}
🛰️vector中reserve 、resize
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size();
T* tmp = new T[n];
if (_start)
{
//这里直接使用memcpy拷贝会出现一些深层次问题，文章末尾分析
//memcpy(tmp, _start, size() * sizeof(T));
for (size_t i = 0;i < sz;++i)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}
//void resize(size_t n,T val = T())
void resize(size_t n, const T& val = T())
{
//空间不够，增容
if (n > capacity())
reserve(n);
//如果n大于当前的size,则多出空间用val填充
if (n > size())
{
while (_finish < _start + n)
{
*_finish = val;
++_finish;
}
}
//如果n小于当前的size,则数据个数缩小到n
else
{
_finish = _start + n;
}
}
🛰️vector的构造函数
❗理论上来说，提供了vector(size_t n,const T& val = T())后，就不需要提供vector(int n, const T& val = T())，但是对于vector的构造函数（vector v(10,5);），编译器编译代码时，认为T被实例化为int，10和5编译器默认为是int类型，就不会匹配vector(size_t n,const T& val = T())，编译器识别10和5两个数据类型一致，因此编译器匹配了 vector(InputIterator first, InputIterator last)，导致编译器将模板参数InputIterator实例化为int，导致后序匹配失败，编译器报错。所以需要重载size_t和int两个版本的构造函数。
template<class InputIterator>
vector(InputIterator first, InputIterator last)
: _start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector(size_t n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n);
for (size_t i = 0;i < n;++i)
{
push_back(val);
}
}
vector(int n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n);
for (size_t i = 0;i < n;++i)
{
push_back(val);
}
}
🛰️vector的push_back、pop_back
void push_back(const T& val)
{
if (_finish == _endofstorage)
{
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
}
*finish = val;
++finish;
}
void pop_back()
{
assert(!empty());
--_finish;
}
🛰️vector的insert、erase
🎯注意：insert插入数据时，若vector空间满了，则需要扩容，扩容后之前传入的pos还是指向旧空间，这时我们需要更新pos的位置，使它指向新空间对应的位置。否则程序就会崩溃。
iterator insert(iterator pos , const T& val)
{
assert(pos >= _start && pos <= _finish);
//扩容以后pos就失效了，需要更新pos的位置
if (_finish == _endofstorage)
{
//计算出pos位置相对于起始位置的相对位置
size_t n = pos - _start;
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
//更新pos,解决增容后pos失效的问题
pos = _start + n;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = val;
++_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的拷贝构造和赋值运算符重载
写法一：
iterator erase(iterator pos)
{
assert(pos >= _start && pos < _finish);
iterator it = pos + 1;
while (it !=_finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}
//vector(const vector& v)
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(v.capacity());
/*for (auto e : v)
push_back(e);*/
_start = new T[v.capacity()];
memcpy(_start, v._start, sizeof(T) * v.size());
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
}
写法二：
拷贝构造：用v构造一个tmp对象，再将tmp交换到需要拷贝构造的对象。
赋值运算符重载：使用传值传参，v是由传参时拷贝的临时对象，将拷贝的对象直接交换给最终被赋值的对象。
void swap(vector<T>& v)
{
::swap(_start, v._start);
::swap(_finish, v._finish);
::swap(_endofstorage, v._endofstorage);
}
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
vector<T> tmp(v.begin(), v.end());
swap(tmp);
}
vector<T>& operator=(vector<T> v)//v是由传参时拷贝构造的
{
swap(v);
return *this;
}
🛰️memcpy的深层次拷贝问题
❓若vector接口中的增容接口reserve中使用memcpy进行拷贝数据，那么会有什么问题吗?
🎯以杨辉三角的打印为例，我们来看看vector中memcpy的深拷贝问题：
class Solution {
public:
vector<vector<int>> generate(int numRows) {
vector<vector<int>> vv;
//构建结构空间
vv.resize(numRows);
for (size_t i = 0;i < vv.size();++i)
{
vv[i].resize(i + 1);
}
for (size_t i = 0;i < vv.size();++i)
{
vv[i][0] = vv[i][vv[i].size() - 1] = 1;
}
for (int i = 0;i < vv.size();++i)
{
for (int j = 0;j < vv[i].size();++j)
{
if (vv[i][j] != 1)
{
vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
}
}
}
for (size_t i = 0; i < vv.size(); ++i)
{
for (size_t j = 0; j < vv[i].size(); ++j)
{
cout << vv[i][j] << " ";
}
cout << endl;
}
return vv;
}
};
void test_vector1()
{
vector<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;
}
}
当杨辉三角的行数为5时，vector<vector<int>>中结构如下：
运行结果如下：
1、memcpy是内存中的二进制格式拷贝，它会将一段内存空间中的内容原封不动的拷贝到另外一段内存空间里面。
2、若memcpy拷贝的是自定义类型的数据，memcpy高效且不会出错。但是如果拷贝的是自定义类型的元素，并且自定义类型中元素涉及资源管理时，使用memcpy就会出错，因为memcpy是浅拷贝。
🎯对于这个问题的解决方案：
🪩总结一下：若拷贝的对象中涉及资源管理时，不能使用memcpy进行对象之间的拷贝，memcpy只能进行浅拷贝，继续使用可能导致内存泄漏和程序崩溃等问题，所以我们使用memcpy的时候一定要谨慎。
🛰️vector模拟实现代码
vector.h
#pragma once
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
namespace hy
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
vector()
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{}
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
template<class InputIterator>
vector(InputIterator first, InputIterator last)
: _start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector(size_t n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n);
for (size_t i = 0;i < n;++i)
{
push_back(val);
}
}
vector(int n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n);
for (size_t i = 0;i < n;++i)
{
push_back(val);
}
}
size_t size()const
{
return _finish - _start;
}
size_t capacity()const
{
return _endofstorage - _start;
}
bool empty()const
{
return _start == _finish;
}
T& operator[](size_t i)
{
assert(i < size());
return _start[i];
}
const T& operator[](size_t i) const
{
assert(i < size());
return _start[i];
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size();
T* tmp = new T[n];
if (_start)
{
//这里直接使用memcpy拷贝会出现一些深层次问题，文章末尾分析
//memcpy(tmp, _start, size() * sizeof(T));
for (size_t i = 0;i < sz;++i)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}
//void resize(size_t n,T val = T())
void resize(size_t n, const T& val = T())
{
//空间不够，增容
if (n > capacity())
reserve(n);
//如果n大于当前的size,则多出空间用val填充
if (n > size())
{
while (_finish < _start + n)
{
*_finish = val;
++_finish;
}
}
//如果n小于当前的size,则数据个数缩小到n
else
{
_finish = _start + n;
}
}
void push_back(const T& val)
{
if (_finish == _endofstorage)
{
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
}
*_finish = val;
++_finish;
}
void pop_back()
{
assert(!empty());
--_finish;
}
iterator insert(iterator pos , const T& val)
{
assert(pos >= _start && pos <= _finish);
//扩容以后pos就失效了，需要更新pos的位置
if (_finish == _endofstorage)
{
//计算出pos位置相对于起始位置的相对位置
size_t n = pos - _start;
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
//更新pos,解决增容后pos失效的问题
pos = _start + n;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = val;
++_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;
}
void swap(vector<T>& v)
{
::swap(_start, v._start);
::swap(_finish, v._finish);
::swap(_endofstorage, v._endofstorage);
}
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
vector<T> tmp(v.begin(), v.end());
swap(tmp);
}
vector<T>& operator=(vector<T> v)//v是由传参时拷贝构造的
{
swap(v);
return *this;
}
vector(const vector& v)
//vector(const vector<T>& v)
// :_start(nullptr)
// , _finish(nullptr)
// , _endofstorage(nullptr)
//{
// reserve(v.capacity());
// /*for (auto e : v)
// push_back(e);*/
// _start = new T[v.capacity()];
// memcpy(_start, v._start, sizeof(T) * v.size());
// _finish = _start + v.size();
// _endofstorage = _start + v.capacity();
//}
//vector<T>& operator=(const vector<T>& v)
//{
// if (this != &v)
// {
// delete[] _start;
// _start = new T[v.capacity()];
// memcpy(_start, v._start, sizeof(T) * v.size());
// _finish = _start + v.size();
// _endofstorage = _start + v.capacity();
// }
// return *this;
//}
~vector()
{
if (_start)
{
delete[] _start;
}
_start = _finish = _endofstorage = nullptr;
}
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
};
}
本文含有隐藏内容，请 开通VIP 后查看