首先要先了解vector的使用，对于vector类成员和类函数使用还不清楚的可以自行去vector - C++ Reference查看。这里会首先提出几个使用的注意事项，接着会对vector的实现进行简单的剖析。
vector使用注意事项；
reserve的使用
在VS2019中，capacity 不会减容，只能扩容。但这个实现还是看编译器的，毕竟c++库里没有规定；
这种是比较好的；一般内存的释放都是一次性的；不存在一次一点一次一点；在哪创造的就在那里释放就很麻烦；所以不缩容很正确，也提高了效率；
迭代器失效
迭代器失效主要分为两种
- 存在扩容现象，类似与野指针的东西。
- 不存在扩容，由于数据已经挪动，位置已经改变，指针已不在指向原来的位置，我们就认为它失效了，不要访问。但是有的编译器会自动识别并拦截，有的遇到这种情况还能访问，出于安全性还是都不要访问的好；
这种情况在自己模拟实现vector时也会出现，毕竟这是确确实实的错误
这种就是VS的自动识别，会造成迭代器失效；但是自己实现vector时不会出现报错，但就尽量不使用就行了，（g++实现的vector 也不会有这个报错，但上一种情况就会出现）
还有就是 几乎所有容器 erase 之后都会迭代器失效；Insert是否失效看情况 看是否扩容
但是正确使用就行，erase 是有返回值的，用原来的p接收返回的删除后，原位置是数；如果是删除的最后一个则会返回最后一个值。
删除最后一个，在取pos值会造成迭代器失效
vector的模拟实现
成员函数
通过stl_vector的底层我们可以看到 vector的类成员是由三个组成的；
类似于这样
vector是从堆上分配内存的，大小与元素个数无关；（存的是地址）
一个共是四个成员函数，根据对齐原则我们可以判断，其大小应为16字节
但是通过打印可以知道
实际上编译器对vector的容量是32字节，那剩下了的字节编译器会实现什么内容，我们现在也无从而知；
毕竟STL是完全放开的东西，怎么实现vector类就看编译器了。
构造函数
要完成vector的基本构造函数，要写很多；
第一个就是vector<T> v1;类型的
第二个是要满足这种的
但是若使用 vector<int> v1(int , int)类型的 会先调用（vector(InputIterator first, InputIterator last)）
而不是（vector(size_t n, const T& val = T())），因为 int 转 size_t 类型比模板转换要更麻烦；所以要加一个 （vector(int n, const T& val = T())） 防止出错
//C++11 前置生成默认构造
vector() = default;
vector(size_t n, const T& val = T())
{
reserve(n);
for (size_t i = 0; i < n; ++i)
{
push_back(val);
}
}
//防止出错 (int ,int)类型构造优先走下面那个模板 而不是上面size_t 那个
vector(int n, const T& val = T())
{
reserve(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
reserve(last - first);
auto i = first;
while (i != last)
{
push_back(*i);
++i;
}
}插入删除
在VS编译器的insert 和 erase会自动识别迭代器失效，但是我们自己实现的就很难识别，所以在使用时要注意，insert 和 erase 之后 不要再次使用pos；除非自己已经了实现更新了pos的新位置；
使用memcpy拷贝问题
因为memecpy的拷贝是浅拷贝，若_start 中存储的是堆上的数据/自定义类型，还是会出现问题的；
因此，不要使用memcpy 。
void reserve(size_t n)
{
if (capacity() < n)
{
size_t count = size();
iterator new = new T(n);
//memcpy(new, _start);
for (size_t i = 0; i < count; ++i)
{
new.push_back(*(_start + i));
}
//防止内存泄漏
delete[] _start;
_start = new;
_finish = _start + count;
_end_of_storage = _start + n;
}
}代码参考
vector.h
#pragma once
#include<assert.h>
#include<list>
#include<string>
namespace xryq {
template<class T>
class vector {
public:
typedef T* iterator;
typedef const T* const_iterator;
//vector(int n, const T& val = T())
// :_start(new T(n, val))
// ,_finish(_start + n)
// ,_end_of_storage(_start + n)
//{}
vector()
{}
// C++11 前置生成默认构造
/*vector = default;*/
vector(size_t n, const T& val = T())
{
reserve(n);
for (size_t i = 0; i < n; ++i)
{
push_back(val);
}
}
//防止出错 (int ,int)类型构造优先走下面那个模板 而不是上面size_t 那个
vector(int n, const T& val = T())
{
reserve(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
reserve(last - first);
auto i = first;
while (i != last)
{
push_back(*i);
++i;
}
}
vector(const vector<T>& v)
{
reserve(v.capacity());
for (size_t i = 0; i < v.size(); ++i)
{
this[i] = v[i];
}
}
size_t capacity()
{
return _end_of_storage - _start;
}
size_t size()
{
return _finish - _start;
}
T& operator [](const size_t i) const
{
assert(i < capacity());
return _start[i];
}
void clear()
{
_start = _finish;
}
//vector& operator =(const vector<T>& v)
//{
// if (this != &v)
// {
// clear();
// reserve(v.capacity());
// for (size_t i = 0; i < v.size(); i++)
// {
// push_back(v[i]);
// }
// }
//}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
}
//现代写法
vector& operator =(vector<T> v)
{
if (this != &v)
{
swap(v);
}
return *this;
}
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
}
void reserve(size_t n)
{
if (capacity() < n)
{
size_t count = size();
T* tmp = new T[n];
memcpy(tmp, _start,size() * 4);
//for (size_t i = 0; i < count; ++i)
//{
// tmp[i] = _start[i];
//}
//防止内存泄漏
delete[] _start;
_start = tmp;
_finish = _start + count;
_end_of_storage = _start + n;
}
}
void resize(size_t n, const T& x)
{
if (n > size())
{
if (n > capacity())
{
reserve(n);
}
for (size_t i = 0; i < n - size(); i++)
{
push_back(x);
}
}
}
void push_back(const T& x)
{
if (_finish == _end_of_storage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = x;
++_finish;
}
bool empty()
{
return _start == _finish;
}
void pop_back()
{
assert(!empty());
--_finish;
}
iterator insert(iterator pos, const T& x)
{
assert(pos <= _finish);
assert(pos >= _start);
size_t oldsize = pos - _start;
if (_finish == _end_of_storage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + oldsize;
}
for (size_t i = size() - oldsize; i > 0; --i)
{
pos[i] = pos[i - 1];
}
pos[0] = x;
++_finish;
return pos;
}
iterator erase(iterator pos)
{
assert(pos < _finish);
assert(pos >= _start);
iterator i = pos + 1;
while (i != _finish)
{
*(i - 1) = *(i);
++i;
}
--_finish;
return pos;
}
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _end_of_storage = nullptr;
};
void test_vector()
{
std::list<int> l1;
l1.push_back(1);
l1.push_back(1);
l1.push_back(1);
l1.push_back(1);
l1.push_back(1);
//vector<std::list<int>> v1(++l1.begin(), l1.end()--);
}
void test_vector1()
{
vector<std::string> v;
v.push_back("1111111111111111111111111111111111111111");
v.push_back("2222222222222222222222222222222222222222");
v.push_back("3333333333333333333333333333333333333333");
v.push_back("4444444444444444444444444444444444444444");
v.insert(v.begin() + 2, "9999999999999999999999999999999999999999");
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
