vector的模拟实现
由于自己实现的vector会跟标准库中的vector产生命名冲突，模拟实现vector时需要放在自己的命名空间中。
namespace myVector
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* iterator;
private:
iterator _start;//指向首元素
iterator _finish;//指向最后一个元素的下一个位置
iterator _endofstorage;//指向容量
};
}
接口演示
namespace myVector//自己的命名空间
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
T& operator[](size_t pos)
{
assert(pos < size());
//iterator _start类似于 int* a
return _start[pos];//a[pos]
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
//默认构造函数
vector()
:_start(nullptr),
_finish(nullptr),
_endofstorage(nullptr)
{}
//先写reserve函数，这样开空间可以直接调用
void reserve(size_t n)
{
if (n > capacity())
{
//先记录之前的size
size_t oldSize = size();
T* tmp = new T[n];
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * oldSize);
for (size_t i = 0; i < oldSize; ++i)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + oldSize;
_endofstorage = _start + n;
}
}
void resize(size_t n, T val = T())//T()匿名对象,传内置类型，或自己定义的都可以
{
if (n > capacity())
{
reserve(n);
}
if (n > size())
{
while (_finish < _start + n)
{
*_finish = val;
++_finish;
}
}
else
{
_finish = _start + n;
}
}
void push_back(const T& x)
{
if (_finish == _endofstorage)
{
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
}
*_finish = x;
++_finish;
}
void pop_back()
{
assert(!empty());
--_finish;
}
//迭代器失效：野指针问题
//传值，地址是拷贝的，并不影响实参
void insert(iterator pos, const T& val)
{
assert(pos >= _start);
assert(pos < _finish);
if (_finish == _endofstorage)
{
size_t len = pos - _start;//记录原来的位移
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
//扩容会导致pos迭代器失效，需要更新处理
//原来的pos是在原来的_start基础数位移，扩容_start的位置不一样了
//用新的_start加上位移就是现在的pos
pos = _start + len;
}
//挪动数据
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = val;
++_finish;
}
//vector<int> v1(10,1);
//vector<char> v1(10, 'A');
vector(int n, const T& val = T())
:_start(nullptr),
_finish(nullptr),
_endofstorage(nullptr)
{
reserve(n);
for (int i = 0; i < n; ++i)
{
push_back(val);
}
}
//为什么要函数重载，因为int不能匹配size_t,而char可以强制提升成size_t
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);
}
}
//为拷贝构造做准备
template<class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr),
_finish(nullptr),
_endofstorage(nullptr)
{
while (first != last)
{
push_back(*first);
++first;
}
}
//拷贝构造
vector(const vector<T>& v)
:_start(nullptr),
_finish(nullptr),
_endofstorage(nullptr)
{
vector<T> tmp(v.begin(), v.end());
//传了this指针
swap(tmp);
}
//v1 = v2
//v1 = v1//极少数情况，能确保正确性
//调用一次拷贝构造vector<T> v = v2
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
~vector()
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
bool empty() const
{
return _start == _finish;
}
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _endofstorage - _start;
}
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
iterator begin = pos + 1;
while (begin < _finish)
{
*(begin - 1) = *(begin);
++begin;
}
--_finish;
return pos;
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
void clear()
{
_finish = _start;
}
private:
iterator _start;//指向首元素
iterator _finish;//指向最后一个元素的下一个位置
iterator _endofstorage;//指向容量
};
}成员函数
构造函数
默认构造函数
对于默认构造函数直接进行列表初始化即可
vector()
:_start(nullptr),
_finish(nullptr),
_endofstorage(nullptr)
{}区间构造函数
vector函数支持使用迭代器区间进行对对象的构造。因为迭代器的区间也可以是其他容器的迭代器区间，所以函数迭代器的类型是不确定的，我们要用函数模板，实现就是直接一个一个元素尾插进容器即可
template<class InputIterator>//模板函数
vector(InputIterator first, InputIterator last)
:_start(nullptr),
_finish(nullptr),
_endofstorage(nullptr)
{
//将迭代器区间[first, last)的元素尾插进vector
while (first != last)
{
push_back(*first);
++first;
}
}用n个val构造函数
vector还支持用n个val来构造函数。
该构造函数我们可以先用reserve函数将空间开好，然后再用push_back()函数一个一个尾插进容器即可。
vector(size_t n, const T& val)//参数为size_t
:_start(nullptr),
_finish(nullptr),
_endofstorage(nullptr)
{
reserve(n);//直接扩容
for (size_t i = 0; i < n; ++i)
{
push_back(val);
}
}有两个需要注意的点：
1）该函数知道需要存储多少空间，先用reserve函数将空间开好，避免调用push_back()函数需要扩容多次
2）该函数需要重载
为什么需要重载该函数
当我们使用int初始化
vector<int> v(10, 1);编译器会优先匹配模板函数而不是n个val函数，因为n个val函数会发生类型转换，编译器优先匹配不会发生类型转换的。而匹配了模板函数，会发现模板函数里面有解引用，对内置类型（int）解引用会发生错误，所以我们要重载"n个val构造函数"。
重载"n个val构造函数"：
vector(int n, const T&val)//重载函数，参数为int
:_start(nullptr),
_finish(nullptr),
_endofstorage(nullptr)
{
reserve(n);
for (size_t i = 0; i < n; ++i)
push_back(val);
}拷贝构造函数
拷贝构造函数会涉及深拷贝
写法一：传统写法
拷贝构造我们很容易想到：先开辟一块和原空间一样的空间，将该容器的数据一个一个的拷贝过来即可，最后更新一下finish和endofstorage的值
vector(const vector<T>& v)
:_start(nullptr),
_finish(nullptr),
_endofstorage(nullptr)
{
_start = new T(v.capacity());//开辟跟v大小一样的空间
for (size_t i = 0; i < v.size(); ++i)
_start[i] = v[i];//数据一个一个拷贝
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
}我们赋值的时候并没有用到memcpy函数，主要是因为vector存储的数据是内置类型时使用memcpy函数时没有什么问题的，但是vector存储的数据是需要进行深拷贝的自定义类型时，memcpy只是按字节复制内存内容，并不会递归复制指针所指向的内容。因此，它不能实现深拷贝。
例如，当vector存储的数据是string类的时候
并且vector存储的每一个string都指向自己的字符串
如果用memcpy函数进行拷贝，只是简单的将地址拷贝给我们，两个vector对应的string成员都指向同一个字符串空间
vector(const vector<T>& v)
:_start(nullptr),
_finish(nullptr),
_endofstorage(nullptr)
{
_start = new T(v.capacity());//开辟跟v大小一样的空间
memcpy(_start, v._start, sizeof(T)*v.size());//简单的赋值
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
}
这样析构的时候同一块空间被析构两次，所以我们不能用memcpy来拷贝构造。
我们自己写一个for循环来解决这个问题。
for (size_t i = 0; i < v.size(); ++i)
_start[i] = v[i];//调用string的赋值重载运算符
//_start[i] = v[i];调用string类的赋值运算符重载函数进行深拷贝看似简单的“=”其实是调用了string的赋值运算符重载函数。string的赋值运算符重载函数是深拷贝，结果如下
总结:memcpy只适用在浅拷贝，vector内置类型或者不需要深拷贝的自定义类型可以用memcpy，否则还是用赋值重载运算符好。
写法二：现代写法1
现代写法1简单，使用范围for（或者其他遍历的模式）对容器v进行遍历，进行一遍又一遍的尾插
vector(const vector<T>& v)
:_start(nullptr),
_finish(nullptr),
_endofstorage(nullptr)
{
reserve(v.capacity());//先开辟空间
for (const auto& a : v)
push_back(a);
}使用范围for对v进行遍历的过程中，变量a就是v的每个数据，将a尾插到构造的容器中。
现代写法2
现代写法2调用区间构造函数，构造一个新的tmp对象，tmp对象是我们想要的拷贝。
tmp完成构造后与this进行了交换，出了作用域tmp对象自动销毁，就可以得到我们想要拷贝的对象。
//拷贝构造
vector(const vector<T>& v)
:_start(nullptr),
,_finish(nullptr),
,_endofstorage(nullptr)
{
vector<T> tmp(v.begin(), v.end());
//传了this指针
swap(tmp);//调用的是自己的swap，不是std库里的swap
}
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的赋值运算符重载函数跟拷贝构造函数一样涉及深拷贝问题，这里也有两种写法。
写法一：传统写法
vector<T>& operator=(const vector<T>& v)
{
if (this != &v) //不能自己给自己赋值
{
delete[] _start;//释放原来空间
_start = new T[v.capacity()];
for (size_t i = 0; i < v.size(); ++i)
_start[i] = v[i];
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
}
return *this;
}写法二：现代写法
赋值运算符的现代写法很巧妙，在函数传递时并没有使用引用传递，这样可以间接调用拷贝构造函数，然后这个拷贝出来的容器v可以与this进行交换，从而实现赋值操作，拷贝出来的容器也会在函数调用结束时自动析构。
vector<T>& operator=(vector<T> v)//间接调用拷贝构造
{
swap(v);//交换两个对象
return *this;
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
}赋值运算符重载的现代写法也是进行的深拷贝，是调用了拷贝构造的v进行了深拷贝，然后将拷贝出来的对象与this进行了交换。
为什么要自己实现swap函数？
swap在库里的实现：
template <class T>
void swap (T& a, T& b)
{
T tmp = a;
a = b;
b = tmp;
}如过直接使用库里的swap进行交换，自定义类型的对象需要进行三次赋值构造函数，代价太大，所以自己实现swap函数。
析构函数
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
}迭代器相关函数
iterator实际上是typedef出来的指针
typedef T* iterator;
typedef const T* const_iterator;begin()和end()
iterator begin()
{
return _start;
}
iterator begin() const
{
return _start;
}
iterator end()
{
return _finish;
}
iterator end() const
{
return _finish;
}容量大小相关函数
size和capacity
看图可以清楚知道三个成员的指向
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _endofstorage - _start;
}reserve
reserve操作：
- 当n大于当前的capacity时，将capacity扩大到n
- 当n小于当前capacity时，什么都不做
void reserve(size_t n)
{
if (n > capacity())
{
size_t oldSize = size();//记录当前容器中的有效数据个数
T* tmp = new T[n];
if (_start)//判断是否为空容器
{
for (size_t i = 0; i < oldSize; ++i)
tmp[i] = _start[i];//将容器中的数据一个个拷贝到tmp当中
delete[] _start;//将容器本身的空间释放
}
_start = tmp;//将tmp的数据给_start;
//下面的oldSize不能用size（）代替
//因为size（）的finish-start中start的地址改变了
_finish = _start + oldSize;
_endofstorage = _start + n;
}
}使用reserve有两个地方需要注意
1）提前记录当前容器中的有效数据个数
因为我们要更新_finish指针指向,而finish指针是通过start加上容器中的有效数据个数，但是start指针指向改变后通过调用_finish - start计算出的有效个数就是一个随机值了。
2）拷贝容器数据时也要用for循环一个一个深拷贝
resize
resize规则：
1、当n大于当前的size时，将size扩大到n，扩大的数据为val，若val未给出，则默认为容器所存储类型的默认构造函数所构造出来的值。
2、当n小于当前的size时，将size缩小到n。
3、不管是内置类型还是自定义类型都可以用临时对象T（）设置缺省值
void resize(size_t n, T val = T())//T()匿名对象,传内置类型，或自己定义的都可以
{
if (n > capacity())
{
reserve(n);
}
if (n > size())
{
while (_finish < _start + n)//n大于当前的size时，将size扩大到n，扩大的数据为val
{
*_finish = val;
++_finish;
}
}
else
{
_finish = _start + n;//当n小于当前的size时，将size缩小到n
}
}empty
判空函数比较的是首位两个指针，指针相等说明容器为空。
bool empty()const
{
return _start == _finish;
}修改容器函数
push_back
尾插函数，先要判断容器空间是否足够，不够需要扩容，扩容用的是类里面的reserve函数。将数据尾插到finish指向的位置，然后finish++
void push_back(const T&val)
{
if (_start == _finish)//容器空间不足
{
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);//增容
}
*_finsh = x;//尾插
_finish++;//指向最后一个元素的下一个位置
}pop_back
尾删函数。判断元素是否为空，不为空直接将_finish--即可
void pop_back()
{
assert(!empty());//判断元素是否为空
--_finish;
}insert
insert函数也需要判断是否需要扩容，并且insert函数还会有迭代器失效的问题。
扩容会导致pos迭代器失效，所以需要更新处理。原来的pos是在start基础上数位移，扩容后start的位置是new出来的，地址变了，相对应的pos的位置也会发生改变，所以我们要记录pos与_start的距离，扩容后重新计算pos的位置。
void insert(iterator pos, const T& x)
{
if (_finish == _endofstorage)
{
size_t len = pos - _start;//记录pos与_start的距离
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCpacity);
pos = _start + len;
}
iterator end = _finish;
while (end >= pos)//挪动数据
{
*(end + 1) = *end;
--end;
}
*pos = x;//x插入pos的位置
++_finish;//有元素加入，迭代器更新
}erase
erase函数是将pos位置的数据干掉。首先判断pos的位置是否准确，然后开始挪动数据，将pos的数据覆盖。
iterator erase(iterator pos)
{
assert(pos >= _start);//pos位置要大于头
assert(pos < _finish);//pos位置要小于尾
iterator begin = pos + 1;
while (begin < _finish)
{
*(begin - 1) = *begin;
++begin;
}
--finish;
return pos;
}swap
swap函数，传进一个容器，交换两个容器的内容，直接使用std的swap进行成员变量的交换。
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}像数组一样访问的函数
operator[]
vector支持我们用下标+[]来对vector进行访问。
T& operator[](size_t i)
{
assert(i < size());//i要在合法范围
return _start[i];
}
const T& operator[](size_t i) const
{
assert(i < size());
return _start[i];
}总结
vector作为变长数组来理解还是很好理解的，主要还是迭代器失效比较困扰，所以要多多思考迭代器为什么会失效。
2844
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
