C++从零开始的打怪升级之路(day29)
这是关于一个普通双非本科大一学生的C++的学习记录贴
在此前，我学了一点点C语言还有简单的数据结构，如果有小伙伴想和我一起学习的，可以私信我交流分享学习资料
那么开启正题
今天分享的是关于vector的底层构造模拟
1.基础函数
vector的底层实现和string不同，不是一个指针加两个下标，而是三个指针，而他的size，capacity将由对象函数来推导
namespace wkl
{
template
class vector
{
public:
//vector的迭代器是一个原生指针
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 cbegin() const
{
return _start;
}
const_iterator cend() const
{
return _finish;
}
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _endofstorage - _start;
}
private:
iterator _start; //指向数据块的开端
iterator _finish; //指向有效数据的尾
iterator _endofstorage; //指向存储容量的尾
};
} 2.元素访问
//元素访问
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
T& front()
{
return *_start;
}
const T& front() const
{
return *_start;
}
T& back()
{
return *(_finish - 1);
}
const T& back() const
{
return *(_finish - 1);
}vector的元素下标访问提供了两个函数，一个是const修饰的，一个是没被const修饰的
3.容量相关
bool empty() const
{
return _start == _finish;
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size();
//1.开辟新空间
T* tmp = new T[n];
//2.拷贝元素
if (_start)
{
size_t i = 0;
for (i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
//3.释放旧空间
delete[] _start;
}
_start = tmp;
_finish = tmp + sz;
_endofstorage = tmp + n;
}
}
void resize(size_t n, const T& value = T())
{
//1.如果小于当前size，则数据缩小到n
if (n <= size())
{
_finish = _start + n;
return;
}
//2.如果空间不够则增容
if (n > capacity())
{
reserve(n);
}
//3.将size扩大到n
iterator it = _finish;
_finish = _start + n;
while (it != _start)
{
*it = value;
++it;
}
}size，capacity函数的情况很多，需控制好条件进行处理
4.增删相关
iterator insert(iterator pos, const T& x)
{
assert(pos <= _endofstorage);
//空间不够先增容
if (_finish == _endofstorage)
{
size_t newcapacity = 0 == capacity() ? 2 : capacity() * 2;
reserve(newcapacity);
//增容后重置pos的位置
pos = _start + size();
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--endl;
}
*pos = x;
++_finish;
return pos;
}
iterator erase(iterator pos)
{
//挪动数据进行删除
iterator begin = pos + 1;
while (pos != _finish)
{
*(begin - 1) = *begin;
++begin;
}
--finish;
return pos;
}
void push_back(const T& x)
{
insert(_end, x);
}
void pop_back()
{
erase(end() - 1);
}我们先实现任意位置的插入删除，要实现尾删和尾插时直接复用即可，由于vector的特殊性，类里面并没有单独提供头删和头插函数
5.交换函数
void swap(vector& v)
{
::swap(_start, v._start);
::swap(_finish, v._finish);
::swap(_endofstorage, v._endofstorage);
} 由于用一般的交换函数需要多次调用拷贝构造函数，消耗比较大，vector内给了一个专属的交换函数，提高了效率
6.拷贝构造函数与赋值运算符重载
vector(size_t n, const T& vaule = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n);
while (n--)
{
push_back(vlaue);
}
}
//这是一个特殊的构造函数
vector(const vector& v)
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{
reserve(v.capacity());
iterator it = begin();
const_iterator vit = v.cbrgin();
while (vit != v.cend())
{
*it++ = *vit++;
}
_finish = it;
}
vector& operator=(vector v)
{
swap(v);
return *this;
} 7.再看reserve函数
前面的reserve函数实现我们用的是遍历赋值，那为什么我们不用memcpy这样的函数直接解决呢
答案显而易见，memcpy是浅拷贝，在遇到vector
如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是 浅拷贝，否则可能会引起内存泄漏甚至程序崩溃
新手写博客，有不对的位置希望大佬们能够指出，也谢谢大家能看到这里，让我们一起学习进步吧！！