前言
作为STL的容器之一，vector的名字通常令人疑惑？在字面上，我们通常会翻译成向量，但感觉又解释不通，总觉得应该叫dynamic array翻译成动态数组/顺序表，更容易理解？那为啥呢？
我从知乎上看到这样的一个回答看起来挺有道理的~
- 下面有一条评论也觉得挺有意思的，体会到STL的设计者的苦衷——并不是不想取，而是这个
dynamic array这个名字已经被占了，不得已才取这个名字。
原文链接：c++里如何理解vector是动态数组，而这个单词本义是向量？为什么这么叫？
再查看文档对这个词的解释~
Vectors are sequence containers representing arrays that can change in size.
翻译： Vectors是一些表示动态数组顺序的容器。——就是顺序表的意思。
再查看一下定义~
template < class T, class Alloc = allocator<T> > class vector;
//第一个参数是模板参数，第二个参数是空间配置器也叫内存池，这个参数我们先不做了解。
一、vector简单使用
①接口
这里的常用接口跟string的差不多我就讲个别跟string有区别的。
1.reserve
这个reserve 只会扩容，其它情况不做处理，而其他情况string会给出一个模棱两可的答案——优化（具体看编译器的实现）。
②用法
1.内置类型
这里举一个int
vector<int> v;
2.二维
比如你要开一个二维动态数组（int）
vector<vector<int>> vv;
内存布局：
3.自定义类型
比如string
vector<string> vv;
string str("shun_hua");
vv.push_back(str);
//用类定义变量，再用变量进行初始化
vv.push_back(string("shun_hua"));
//用匿名对象初始化
vv.push_back("shun_hua");
//隐式类型转换直接初始化
说明：只要是类型，皆可以进行模板实例化。
③迭代器失效
我们只需记住两句话：
- 数据的储存空间改变（常见的为扩容）可能会导致迭代器失效。
因为迭代器的底层是类似于指针的东西，当发生扩容时，指向旧空间的迭代器如果没有更新指向新空间，就会伴随着失效的问题。
比如：push_back,reserve,insert,swap
- 移动数据可能会使迭代器失效。
比如：erase，在vs下使用过后判定为失效，再使用会直接出错，但是在Linux下，则不会。因此为了考虑平台移植性，我们统一认为迭代器会失效。
二、模拟实现
①要点说明
- 1.为了
不与库里面的vector冲突，我们需要命名空间对自己实现的类进行封装 - 2.这里我们实现的框架是按照
顺序表的数据结构进行实现的。 - 3.为了理解，下面的接口是
分开讲解的，最后我会给出源码。
②基本框架
namespace my_vector
{
template<class T>
class vector
{
public:
typedef T value_type;
typedef const T const_value_type;
typedef T* iterator;
typedef const T* const_iterator;
//迭代器的类型重定义
private:
iterator _begin = nullptr;
iterator _finish = nullptr;
iterator _end_of_storage = nullptr;
//给缺省值，构造函数无需写初始化列表了，方便一些。
};
}
大致框架图解：
有的小伙伴问了，为啥不用顺序表的标准形式实现呢？这里实现主要是为了学习库里的底层原理，所以库里是这样实现的，我们就这样写了，其实这样写也有好处，下面讲。
③迭代器
1.begin
iterator begin()
{
return _begin;
}
const_iterator begin()const
{
return _begin;
}
2.end
iterator end()
{
return _finish;
}
const_iterator end()const
{
return _finish;
}
浅浅的提一下：库里的cbegin与cend返回值只有const_iterator,且this指针经过特殊处理~
④ size
size_t size() const
{
return _finish - _begin;
}
⑤capacity
size_t capacity()const
{
return _end_of_storage - _begin;
}
- size与capacity 运用的是
指针减指针等于相邻元素个数，区间是左闭右开。
⑥构造函数与析构函数
构造函数
1.默认构造函数
vector()
{
}
2.构造函数
//为了与下面的构造函数关联起来，这里就直接给出了。
void resize(size_t n, value_type val = value_type())
{
if (n < size())
{
_finish = _finish + n;
}
else
{
reserve(n);
iterator end = _begin + n;
while (_finish != end)
{
*_finish = val;
_finish++;
}
//这里直接对_finish进行调整，最后省去了一步操作。
}
}
vector(size_t n, const value_type& val = value_type())
{
resize(n, val);
}
//这个是用迭代器区间进行初始化
template<class InputIterator>
vector(InputIterator first , InputIterator last)
{
size_t old_size = last - first;
_begin = new value_type[old_size];
InputIterator begin = first;
while (begin != last)
{
push_back(*begin);
begin++;
}
}
这里有几个问题需要谈，我们先来谈第一个——value_type()
- 这是C++语法支持的，适用于内置类型和自定义类型，对于内置类型会去调用它的默认构造，而对于内置类型也是可以的。
第二个问题，编译器不会按照我们想的去调用某个模板，而会去走最合适的模板。
//第一种写法
my_vector::vector<int> v(10,1);
//第二种写法
my_vector::vector<int> v(10u,1);
- 其实第一种写法，我们是想走第一种构造函数的，但是这里的类型一样，更适合第二种构造，所以这里编译器会调用第二种，那这里如何解决呢？显然这里无法对迭代器进行显示声明，那我们只能走强制类型转换，也就是我们看到的第二种写法。
3.拷贝构造
vector(const vector& v)
{
_begin = new value_type[v.size()];
//大多数小伙伴可能会写第一种
//memcpy(_begin, v._begin, sizeof(value_type) * v.size());
//第二种
for (size_t i = 0; i < v.size(); i++)
{
_begin[i] = v[i];//不要小瞧这一步操作，下面细讲。
}
_finish = _end_of_storage = _begin + v.size();
}
//这个用到了reserve 和push_back，也比较方便
vector(const vector& v)
{
reserve(v.capacity());
for (auto e : v)
{
push_back(e);
}
}
- 这里涉及深拷贝的浅拷贝的问题。
这里举个例子。
vector<string> v;
v.push_back("1111");
v.push_back("2222");
vector<string> v1(v);
如果我们采用第一种写法：
- 这里典型的是浅拷贝，运行结束，同一块空间析构两次，会报错的。
而第二种写法，会调用string类的赋值重载，完成深拷贝，如果你要说string类的赋值重载是浅拷贝，那是string类的问题不是我们的问题。
析构函数
~vector()
{
delete[]_begin;
_begin = _finish = _end_of_storage = nullptr;
}
⑦reserve
void reserve(size_t n = 0)
{
if (n > capacity())
{
size_t old_size = size();
iterator tmp = new value_type[n];
//这里在自定义类型也会出深拷贝的浅拷贝问题
//memcpy(_tmp, _begin, sizeof(value_type)*old_size);
for (size_t i = 0; i < size(); i++)
{
tmp[i] = _begin[i];
}
delete[] _begin;
_begin = tmp;
_finish = _begin + old_size;
_end_of_storage = _begin + n;
}
}
⑧push_back
void push_back(const value_type & val)
{
if (_finish == _end_of_storage)
{
size_t new_capacity = size() == 0 ? 4 : capacity() * 2;
//扩容
reserve(new_capacity);
}
*(_finish++) = val;
}
⑨[]
value_type& operator[](size_t pos)
{
assert(pos < size());
return _begin[pos];
}
const_value_type& operator[](size_t pos)const
{
assert(pos < size());
return _begin[pos];
}
⑩insert
void insert(iterator pos, const size_t val)
{
assert(pos <= _finish && pos >= _begin);
//是可以等于_finish的相当于尾插了
if (_finish == _end_of_storage)
{
size_t rpos = pos - _begin;
size_t new_capacity = size() == 0 ? 4 : capacity() * 2;
//扩容
reserve(new_capacity);
pos = _begin + rpos;
}
iterator end = _finish;
while (end != pos)
{
*(end) = *(end - 1);
end--;
}
*pos = val;
_finish++;
}
⑪erase
iterator erase(iterator pos)
{
assert(pos < _finish&& pos >= _begin);
//只能删除有效数据
iterator cur = pos;
while (cur != _finish)
{
*(cur) = *(cur + 1);
cur++;
}
_finish--;
return pos;
}
举例：删除偶数的代码
my_vector::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
//这是通用的代码
my_vector::vector<int>::iterator it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
it = v.earse(it);
}
else
{
it++;
}
}
//这是不具有平台移植性的代码
my_vector::vector<int>::iterator it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
v.earse(it);
}
else
{
it++;
}
}
//这是错误的代码，想想为什么。
my_vector::vector<int>::iterator it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
v.earse(it);
}
it++;
}
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
- 因此：用返回值解决迭代器失效的问题，使代码具有了平台移植性。
⑫pop_back
void pop_back()
{
earse(--end());
}
⑬swap
void swap(vector & x)
{
std::swap(_begin, x._begin);
std::swap(_finish, x._finish);
std::swap(_end_of_storage, x._end_of_storage);
}
⑭ =
- 这里我们还是采用现代写法
vector& operator =(vector tmp)
{
swap(tmp);
return *this;
}
源码
namespace my_vector
{
template<class T>
class vector
{
public:
typedef T value_type;
typedef const T const_value_type;
typedef T* iterator;
typedef const T* const_iterator;
//迭代器
iterator begin()
{
return _begin;
}
const_iterator begin()const
{
return _begin;
}
iterator end()
{
return _finish;
}
const_iterator end()const
{
return _finish;
}
vector(const vector& v)
{
_begin = new value_type[v.size()];
//这里也会发生深拷贝的浅拷贝现象
/*memcpy(_begin, v._begin, sizeof(value_type) * v.size());*/
for (size_t i = 0; i < v.size(); i++)
{
_begin[i] = v[i];
}
_finish = _end_of_storage = _begin + v.size();
}
vector(size_t n, const value_type& val = value_type())
{
resize(n, val);
}
template<class InputIterator>
vector(InputIterator first , InputIterator last)
{
size_t old_size = last - first;
_begin = new value_type[old_size];
InputIterator begin = first;
int i = 0;
while (begin != last)
{
push_back(*begin);
begin++;
}
}
//这个比较简单
//vector(const vector& v)
//{
// reserve(v.capacity());
// for (auto e : v)
// {
// push_back(e);
// }
//}
~vector()
{
delete[]_begin;
_begin = _finish = _end_of_storage = nullptr;
}
size_t size() const
{
return _finish - _begin;
}
size_t capacity()const
{
return _end_of_storage - _begin;
}
void reserve(size_t n = 0)
{
if (n > capacity())
{
size_t old_size = size();
iterator tmp = new value_type[n];
//这里在自定义类型会出大坑
//memcpy(_tmp, _begin, sizeof(value_type)*old_size);
for (size_t i = 0; i < size(); i++)
{
tmp[i] = _begin[i];
}
delete[] _begin;
_begin = tmp;
_finish = _begin + old_size;
_end_of_storage = _begin + n;
}
}
void push_back(const value_type & val)
{
if (_finish == _end_of_storage)
{
size_t new_capacity = size() == 0 ? 4 : capacity() * 2;
//扩容
reserve(new_capacity);
}
*(_finish++) = val;
}
value_type& operator[](size_t pos)
{
assert(pos < size());
return _begin[pos];
}
const_value_type& operator[](size_t pos)const
{
assert(pos < size());
return _begin[pos];
}
void insert(iterator pos, const size_t val)
{
assert(pos <= _finish && pos >= _begin);
if (_finish == _end_of_storage)
{
size_t rpos = pos - _begin;
size_t new_capacity = size() == 0 ? 4 : capacity() * 2;
//扩容
reserve(new_capacity);
pos = _begin + rpos;
}
iterator end = _finish;
while (end != pos)
{
*(end) = *(end - 1);
end--;
}
*pos = val;
_finish++;
}
iterator erase(iterator pos)
{
assert(pos < _finish&& pos >= _begin);
iterator cur = pos;
while (cur != _finish)
{
*(cur) = *(cur + 1);
cur++;
}
_finish--;
return pos;
}
//尾删
void pop_back()
{
earse(--end());
}
void swap(vector & x)
{
std::swap(_begin, x._begin);
std::swap(_finish, x._finish);
std::swap(_end_of_storage, x._end_of_storage);
}
//赋值
vector& operator =(vector tmp)
{
swap(tmp);
return *this;
}
//value_type()这里匿名算是调用默认构造，对缺省参数进行初始化
//1.对内置类型,C++对其做了升级，有对应的默认构造
//2.对自定义类型，会去调用其默认构造。
void resize(size_t n, value_type val = value_type())
{
if (n < size())
{
_finish = _finish + n;
}
else
{
reserve(n);
iterator end = _begin + n;
while (_finish != end)
{
*_finish = val;
_finish++;
}
}
}
private:
iterator _begin = nullptr;
iterator _finish = nullptr;
iterator _end_of_storage = nullptr;
};
}
总结
今天的分享就到这里了，如果觉得文章不错，点个赞鼓励一下吧！我们下篇文章再见！