文章目录
一、前言
在C++的STL中，vector 是一个顺序容器，代表一个可动态增长的数组。因此，自己在进行模拟实现时，跟写动态顺序表类似。
需要注意的是，vector 是一个类模板。
二、模拟实现的意义何在？
为了更好地理解 vector 的底层实现原理，加深对 vector 的认知。
三、vector类的模拟实现
首先，先定义 vector。为了防止命名冲突，将它放在一个叫做 MyLib 的命名空间里。
namespace MyLib
{
template<class T>
class vector
{
public:
//迭代器
typedef T* iterator;
typedef const T* const_iterator;
//成员函数
private:
iterator _start; // 指向数据块的起始位置
iterator _finish; // 指向有效元素的尾
iterator _endofstorage; // 指向存储容量的尾
};
}
下面模拟实现的都是一些比较常用的重载函数。
成员函数：
0.迭代器相关函数
调用库里的话，一般这么写：
vector<int> v1;
for (size_t i = 0; i < 10; ++i)
{
v1.push_back(i);
}
//遍历
vector<int>::iterator it = v1.begin();
while (it != v1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
begin 函数
作用是返回 vector对象内部的指向数据块起始位置的迭代器。
//普通版本
iterator begin()
{
return _start;
}
//const版本
const_iterator begin() const
{
return _start;
}
end 函数
作用是返回 vector对象内部的指向有效元素的尾的迭代器。
//普通版本
iterator end()
{
return _finish;
}
//const版本
const_iterator end() const
{
return _finish;
}
1.构造函数
在定义一个 vector 对象时，调用库里的话，一般这么写：
//将 vector 初始化为空
vector<int> v1;
或
//使用迭代器区间去初始化 vector
vector<string> v3(v2.begin(), v2.end()); // v2的类型是 vector<string>
或
vector<int> v5(v4.begin(), v4.end()); // v4的类型是 vector<int>
作用是构造一个 vector对象。
下面模拟实现构造函数的两个重载函数。
//将 vector 初始化为空
vector()
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{}
//使用迭代器区间去初始化 vector
template<class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr) // 先初始化私有成员变量，避免野指针
,_finish(nullptr)
,_endofstorage(nullptr)
{
while (first != last)
{
push_back(*first); // 复用模拟实现的函数 push_back
++first;
}
}
2.析构函数
作用是在 vector对象销毁时释放内部的空间资源。
~vector()
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
3.拷贝构造函数
调用库里的话，一般这么写：
vector<int> v2(v1);
作用是将已有的对象拷贝一份，去初始化创建新的对象。
//传统写法
vector(const vector<T>& v)
{
_start = new T[v.capacity()];
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
size_t sz = v.size();
//不能用 memcpy！
/*memcpy(_start, v._start, sizeof(T) * v.size());*/
for (size_t i = 0; i < sz; ++i)
{
_start[i] = v[i]; // 元素类型：对自定义类型和内置类型均可
} // 若是涉及空间资源管理的自定义类型，会调用赋值重载函数来实现深拷贝
}
//现代写法
vector(const vector<T>& v)
:_start(nullptr) // 先初始化私有成员变量，避免野指针
,_finish(nullptr)
,_endofstorage(nullptr)
{
vector<T> tmp(v.begin(), v.end()); // 复用模拟实现的使用迭代器区间去初始化的构造函数
swap(tmp); // 复用模拟实现的函数 swap
}
4.赋值重载函数
调用库里的话，一般这么写：
vector<int> v2;
v2 = v1;
作用是将已有的对象赋值给另一个已有的对象。
//更简洁的现代写法
vector<T>& operator=(vector<T> v) // 传值传参，调用拷贝构造函数
{
swap(v); // 复用模拟实现的函数 swap
return *this;
}
5. size 函数
调用库里的话，一般这么写：
for(size_t i = 0; i < v1.size(); ++i)
{
//...
}
作用是返回 vector对象内部元素的个数。
size_t size() const
{
return _finish - _start;
}
6. capacity 函数
调用库里的话，一般这么写：
cout << v1.capacity() << endl;
作用是返回 vector对象内部的容量。
size_t capacity() const
{
return _endofstorage - _start;
}
7. swap 函数
调用库里的话，一般这么写：
v2.swap(v1);
作用是将两个对象的私有成员的值进行交换。
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
8. operator[] 函数
调用库里的话，一般这么写：
//修改
for(size_t i = 0; i < v1.size(); ++i)
{
v1[i] += 1;
}
//遍历
for(size_t i = 0; i < v1.size(); ++i)
{
cout << v1[i] << " ";
}
cout << endl;
作用是返回 _start[ i ]的引用，即返回 vector对象内部元素的引用。
//普通版本（返回引用）
T& operator[](size_t i)
{
assert(i < size()); // 防止访问越界
return _start[i];
}
//const版本（返回常引用，无法修改）
const T& operator[](size_t i) const
{
assert(i < size()); // 防止访问越界
return _start[i];
}
9. reserve 函数
调用库里的话，一般这么写：
v1.reserve(50);
作用是扩容（将储存元素的空间容量扩大为 n，其中 n 大于原来的空间容量）。
如果 n 小于或等于原来的空间容量，则什么都不干。
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size(); // 小细节，在_start的指向改变前，要先把原来的size存起来
T* tmp = new T[n];
//不能用 memcpy！
/*memcpy(tmp, _start, sizeof(T) * size());*/
for (size_t i = 0; i < sz; ++i)
{
tmp[i] = _start[i]; // 元素类型：对自定义类型和内置类型均可
} // 若是涉及空间资源管理的自定义类型，会调用赋值重载函数来实现深拷贝
delete[] _start;
_start = tmp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}
10. resize 函数
调用库里的话，一般这么写：
v1.resize(20);
或
v2.resize(25, 10);
作用是改变 vector对象内部的元素个数 。
void resize(size_t n, const T& val = T())
{
if (n <= size())
{
_finish = _start + n;
}
else
{
//检查是否需要扩容
if (n > capacity())
{
reserve(n);
}
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}
11. insert 函数
调用库里的话，一般这么写：
vector<int>::iterator ret = find(v1.begin(), v1.end(), 4);
if (ret != v1.end()) // 找到了
{
v1.insert(ret, 7);
}
作用是在指定的位置处插入元素。
iterator insert(iterator pos, const T& val)
{
//检查传进来的迭代器是否合法
assert(pos >= _start);
assert(pos <= _finish);
//检查是否需要扩容
if (_finish == _endofstorage)
{
size_t len = pos - _start; // 记录 pos 与 _start 的相对长度
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + len; // 由于扩容后会导致pos失效，需要在这里更新一下pos
}
//往后挪动数据
iterator end = _finish;
while (end > pos)
{
*end = *(end - 1);
--end;
}
//插入新元素
*pos = val;
++_finish;
return pos;
}
关于迭代器失效的问题：
12. erase 函数
调用库里的话，一般这么写：
vector<int>::iterator ret = find(v1.begin(), v1.end(), 8);
if (ret != v1.end()) // 找到了
{
v1.erase(ret);
}
作用是删除某个特定的元素。
iterator erase(iterator pos)
{
//检查传进来的迭代器是否合法
assert(pos >= _start);
assert(pos < _finish);
//往前挪动数据
iterator begin = pos + 1;
while (begin < _finish)
{
*(begin - 1) = *begin;
++begin;
}
--_finish;
return pos;
}
关于迭代器失效的问题：
（迭代器失效）
不论什么容器，只要存在相关接口涉及迭代器的访问，都可能会使迭代器失效。
用了 insert 函数和 erase 函数后，原有的迭代器可能失效，不建议再用了。非要再用的话，要接收函数返回值来更新一下旧的迭代器，或者再定义另一个迭代器。
13. push_back 函数
调用库里的话，一般这么写：
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
作用是尾插一个元素。
void push_back(const T& val)
{
//检查是否需要扩容
if (_finish == _endofstorage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = val;
++_finish;
}
14. pop_back 函数
调用库里的话，一般这么写：
vector<int> v1;
v1.push_back(2);
v1.push_back(4);
v1.push_back(6);
v1.pop_back();
作用是尾删一个元素。
void pop_back()
{
assert(_finish > _start); // 检查是否合法
--_finish;
}
在 vector 的模拟实现中，还有一些细节上的东西，这些在之前写的一篇博客当中有所提及，这里不再重复，有需要的可自行点击查看：C++ STL中 string类的模拟实现
