进阶顺序表——C++模拟实现vector
vector
我们之前在C语言中，实现过顺序表，但在C++中，我们自己不用再造轮子了，我们C++中的STL中，有这样一个头文件，叫做vector，这个vector说白了，就是我们在C语言中实现的顺序表。可以实现增，删，查，改。
具体的文档可以参考：
https://legacy.cplusplus.com/reference/vector/vector/?kw=vector
现在我们来自己实现一个简易版的vector：
一些基础工作
迭代器
在C++STL中，我们有这么一个概念，迭代器，
通过迭代器可以实现各种操作，现在我们的知识储备还不够，我们就暂时把迭代器暂时理解为被typedef过的指针。
同时迭代器分为const，非const，正向，反向迭代器。大家先了解一下。
typedef int* iterator; //一个int类型的迭代器
为了实现泛型编程，我们要用模板实现vecotr可以实现任意类型的vector。
现在我们用namespace，将自带的vector和我们自己写的vector分隔开来：
namespace My_vector
{
}
现在我们用模板实现泛型编程：
namespace My_vector
{
template<class T>
//泛型编程
class Vector
{
public:
typedef T* iterator;
};
}
我们这个顺序表的私有成员用迭代器实现：
我们以前的顺序表需要三个成员：数组，有效数据个数，容量。但现在我们用指针实现：我们要三个指针，为什么呢？我们来看看STL的源码：
我们实现自己的vector尽量更源码保持接近，所以我们也用三个指针来模拟实现。
那么三个指针怎么实现：
namespace My_vector
{
template<class T>
//泛型编程
class Vector
{
public:
typedef T* iterator;//普通迭代器
typedef T* const_iterator; //const迭代器(针对const对象)
private:
iterator _start;
iterator _finsh;
iterator _end_of_stroage;
};
}
同时我们要写几个函数，来返回_start, _finsh的地址。
namespace My_vector
{
template<class T>
//泛型编程
class Vector
{
public:
typedef T* iterator;//普通迭代器
typedef T* const_iterator; //const迭代器
//针对普通对象，this对象及返回对象都可修改
iterator begin()
{
return _start;
}
iterator end()
{
return _finsh;
}
//const对象，this对象不能修改
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finsh;
}
private:
iterator _start;
iterator _finsh;
iterator _end_of_stroage;
};
}
还要编写两个函数计算有效个数和容量：
namespace My_vector
{
template<class T>
//泛型编程
class Vector
{
public:
typedef T* iterator;//普通迭代器
typedef const T* const_iterator; //const迭代器
//针对普通对象，this对象及返回对象都可修改
iterator begin()
{
return _start;
}
iterator end()
{
return _finsh;
}
//const对象，this对象不能修改
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finsh;
}
size_t size() const //返回有效个数
{
return _finsh - _start;
}
size_t capacity() const //返回容量
{
return _end_of_stroage - _start;
}
private:
iterator _start;
iterator _finsh;
iterator _end_of_stroage;
};
}
扩容
我们都知道顺序表，最重要的就是扩容，我们现在来编写一下：
//扩容
void reserve(size_t n)
{
if (n > capacity())
{
//异地扩容
T* tmp = new T[n];
size_t sz = size();
if (_start)//搬动数据
{
//深拷贝
for (size_t i = 0; i < sz; i++)
{
tmp[i] = _start[i];
}
//删除原来的空间
delete[] _start;
}
//修改tmp的方向
_start = tmp;
//修改原来的_finsh
_finsh = _start + sz;
//修改原来的_end_of_stroage
_end_of_stroage = _start + n;
}
}
构造函数
//构造函数
Vector(size_t n = 4) //缺省参数
:_start(nullptr)
, _finsh(nullptr)
, _end_of_stroage(nullptr)
{
reserve(n);
}
我们来测试一下构造函数：
void test1()
{
Vector<int> v;
}
析构函数
~Vector()
{
delete[] _start;
_start = _finsh = _end_of_stroage = nullptr;
}
push_back( ) （尾插）
在源码中有push_back()这个函数。
其实说白了就是尾插，我们来实现一下：
//尾插
void push_back(const T& val)
{
//判断扩容
if (_finsh == _end_of_stroage)
{
size_t Capacity = capacity();
reserve(Capacity == 0 ? 4 :
2 * Capacity);
}
*_finsh = val;
++_finsh;
}
运算符 [ ] 重载
我们再来看看文档：
重载 [ ] 运算符可以方便访问任意位置的元素：
//重载[ ]
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
我们来测试一下：
void test1()
{
Vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
v.push_back(6);
auto it = v.begin();
while (it != v.end())
{
cout << *it <<" ";
it++;
}
}
insert
insert在某个位置之前插入数据，这里注意，这里的参数是iterator，和push_back()的参数不一样。
//insert
void insert(iterator pos, const T & val)
{
//判断插入位置是否合法
assert(pos >= _start);
assert(pos <= _finsh);
//判断扩容
if (_finsh == _end_of_stroage)
{
size_t Capacity = capacity();
reserve(Capacity == 0 ? 4 :
2 * Capacity);
}
//移动数据
iterator end = _finsh - 1;
while (end >= pos)
{
*(end + 1) = *(end);
--end;
}
*pos = val;
_finsh++;
}
但是，这段代码会报错：
为什么呢？其实答案出现在扩容上：
迭代器失效
现在假设我要头插：
但是在我们插入之前我们会进行异地扩容。
解决方法也很简单：重新计算pos位置。
//insert
void insert(iterator pos, const T & val)
{
//判断插入位置是否合法
assert(pos >= _start);
assert(pos <= _finsh);
//判断扩容
if (_finsh == _end_of_stroage)
{
//计算pos的相对位置
size_t len = pos - _start;
size_t Capacity = capacity();
reserve(Capacity == 0 ? 4 :
2 * Capacity);
//在新空间上pos的位置
pos = _start + len;
}
iterator end = _finsh - 1;
while (end >= pos)
{
*(end + 1) = *(end);
--end;
}
*pos = val;
_finsh++;
}
我们来看看效果：
其实一般我们的返回值会设置为pos位置的迭代器：
//insert
iterator insert(iterator pos, const T & val)
{
//判断插入位置是否合法
assert(pos >= _start);
assert(pos <= _finsh);
//判断扩容
if (_finsh == _end_of_stroage)
{
//计算pos的相对位置
size_t len = pos - _start;
size_t Capacity = capacity();
reserve(Capacity == 0 ? 4 :
2 * Capacity);
//在新空间上pos的位置
pos = _start + len;
}
iterator end = _finsh - 1;
while (end >= pos)
{
*(end + 1) = *(end);
--end;
}
*pos = val;
_finsh++;
return pos;
}
erase
erase删除某个位置的数据。
//erase
void erase(iterator pos)
{
assert(pos >= _start);
assert(pos <= _finsh);
//从后向前依次挪动数据
iterator it = pos + 1;
while (it != end())
{
*(it - 1) = *it;
it++;
}
--_finsh;
}
似乎没有什么问题，但大家想没想过，erase的迭代器是否也会失效呢？
现在我们有一个要求，删除偶数数据：
void test2()
{
Vector<int> v;
v.push_back(2);
v.push_back(2);
v.push_back(8);
v.push_back(4);
v.push_back(5);
v.push_back(6);
v.push_back(7);
v.push_back(8);
for (size_t i = 0; i < v.size(); i++)
{
cout << v[i] << " ";
}
cout << endl;
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
v.erase(it);
it++;
}
else
{
it++;
}
}
for (size_t i = 0; i < v.size(); i++)
{
cout << v[i] << " ";
}
cout << endl;
}
然后：
为什么呢？
为了解决这个问题，我们设置erase有返回值，为pos位置：
//erase
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos <= _finsh);
//从后向前依次挪动数据
iterator it = pos + 1;
while (it != end())
{
*(it - 1) = *it;
it++;
}
--_finsh;
return pos;
}
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
it = v.erase(it);
//删除之后it待在原地，因为下一个位置会前移到it位置
}
else
{
it++; //若不符合，下一个位置
}
}
拷贝构造
//拷贝构造
Vector(const Vector<T>& v)
:_start(nullptr)
, _finsh(nullptr)
, _end_of_stroage(nullptr)
{
reserve(v.capacity());
for (auto e : v)
{
push_back(e);
}
}
重载 =
= 就是将已有的对象拷贝到一个现存的对象之中。
有了拷贝构造函数之后，我们可以省点力气，直接拷贝构造一个临时对象让这个临时对象和我们要构造的对象进行交换资源。
那么如何交换呢？我们C++有一个全局的swap函数：
有了这个函数，我们可以让临时对象中的资源与我们构造的对象进行交换：
void Swap(Vector<T>& tmp)
{
swap(_start, tmp._start);//交换_start
swap(_finsh, tmp._finsh);//交换_finsh
swap(_end_of_stroage, tmp._end_of_stroage);//交换_end_of_stroage
}
//重载=
Vector<T>& operator=(Vector<T>& tmp)
{
Swap(tmp);//又封装了一层
return *this;
}
我们来测试一下：
void test3()
{
Vector<int> v;
v.push_back(2);
v.push_back(2);
v.push_back(8);
v.push_back(4);
v.push_back(5);
v.push_back(6);
v.push_back(7);
v.push_back(8);
const Vector<int> v1(v); //拷贝构造
/*Vector<int> v1;
v1 = v;*/
auto it = v1.begin();
while (it != v1.end())
{
cout << *it << " ";
it++;
}
}
}
void test3()
{
Vector<int> v;
v.push_back(2);
v.push_back(2);
v.push_back(8);
v.push_back(4);
v.push_back(5);
v.push_back(6);
v.push_back(7);
v.push_back(8);
//const Vector<int> v1(v); //拷贝构造
Vector<int> v1;
v1 = v;//赋值拷贝
auto it = v1.begin();
while (it != v1.end())
{
cout << *it << " ";
it++;
}
}
resize
根据字面意思，resize是改变有效数据个数，分为两种情况：
若 n 小于有效数据个数，则缩容，并且丢掉被删减掉的数据。
若 n 大于有效数据个数，则扩容，并且以指定数据填满。
//resize
void resize(size_t n, const T& val = T())
{
//如果小于等于有效数据个数
if (n <= size())
{
_finsh = _finsh + n;
}
else //如果大于有效数据个数
{
reserve(n); //扩容
while (_finsh < _end_of_stroage)
{
*(_finsh) = val;
++_finsh;
}
}
}
用迭代器初始化
在初始化vector时，我们可以拿其他容器的迭代器初始化vector（比如string，list的迭代器）
//模板定义迭代器
template<class InputItreator>
Vector(InputItreator first,InputItreator end)
{
while (first != end)
{
push_back(*first);
++first;
}
}
void test5()
{
const string s("hello world");//string迭代器
Vector<char> S(s.begin(), s.end());
auto it = S.begin();
while (it != S.end())
{
cout << *it << " ";
it++;
}
}
但是如果我们用这段代码，会报错：
void test6()
{
Vector<int> v(10, 90);
auto it = v.begin();
while (it != v.end())
{
cout << *it << " ";
it++;
}
}
这是因为10和90都是有符号整型，编译器为了省事会直接走这段代码：
很明显，不符合我们的逻辑，我们得再写一个函数针对int类型初始化：
Vector(int n, const T& val = T())
{
reserve(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
同时我们仿照这个，写出一个构造函数第一个参数是容量大小，第二个参数表示开辟空间时同时以该值初始化。
Vector(size_t n, const T& val = T())
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}
附上源码：
#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
namespace My_vector
{
template<class T>
//泛型编程
class Vector
{
public:
typedef T* iterator;//普通迭代器
typedef const T* const_iterator; //const迭代器
//针对普通对象，this对象及返回对象都可修改
iterator begin()
{
return _start;
}
iterator end()
{
return _finsh;
}
//const对象，this对象不能修改
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finsh;
}
//模板定义迭代器
template<class InputItreator>
Vector(InputItreator first, InputItreator end)
{
while (first != end)
{
push_back(*first);
++first;
}
}
Vector(size_t n, const T& val = T())
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}
Vector(int n, const T& val = T())
{
reserve(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
Vector(size_t n = 4)
:_start(nullptr)
, _finsh(nullptr)
, _end_of_stroage(nullptr)
{
reserve(n);
}
//拷贝构造
Vector(const Vector<T>& v)
:_start(nullptr)
, _finsh(nullptr)
, _end_of_stroage(nullptr)
{
reserve(v.capacity());
for (auto e : v)
{
push_back(e);
}
}
size_t size() const
{
return _finsh - _start;
}
size_t capacity() const
{
return _end_of_stroage - _start;
}
//尾插
void push_back(const T& val)
{
//判断扩容
/*if (_finsh == _end_of_stroage)
{
size_t Capacity = capacity();
reserve(Capacity == 0 ? 4 :
2 * Capacity);
}
*_finsh = val;
++_finsh;*/
insert(end(), val);
}
//insert
iterator insert(iterator pos, const T & val)
{
//判断插入位置是否合法
assert(pos >= _start);
assert(pos <= _finsh);
//判断扩容
if (_finsh == _end_of_stroage)
{
//计算pos的相对位置
size_t len = pos - _start;
size_t Capacity = capacity();
reserve(Capacity == 0 ? 4 :
2 * Capacity);
//在新空间上pos的位置
pos = _start + len;
}
iterator end = _finsh - 1;
while (end >= pos)
{
*(end + 1) = *(end);
--end;
}
*pos = val;
_finsh++;
return pos;
}
//erase
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos <= _finsh);
//从后向前依次挪动数据
iterator it = pos + 1;
while (it != end())
{
*(it - 1) = *it;
it++;
}
--_finsh;
return pos;
}
//重载[ ]
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
void Swap(Vector<T>& tmp)
{
swap(_start, tmp._start);//交换_start
swap(_finsh, tmp._finsh);//交换_finsh
swap(_end_of_stroage, tmp._end_of_stroage);//交换_end_of_stroage
}
//重载=
Vector<T>& operator=(Vector<T>& tmp)
{
Swap(tmp);
return *this;
}
//resize
void resize(size_t n, const T& val = T())
{
//如果小于等于有效数据个数
if (n <= size())
{
_finsh = _finsh + n;
}
else //如果大于有效数据个数
{
reserve(n); //扩容
while (_finsh < _end_of_stroage)
{
*(_finsh) = val;
++_finsh;
}
}
}
//扩容
void reserve(size_t n)
{
if (n > capacity())
{
//异地扩容
T* tmp = new T[n];
size_t sz = size();
if (_start)//搬动数据
{
//深拷贝
for (size_t i = 0; i < sz; i++)
{
tmp[i] = _start[i];
}
//删除原来的空间
delete[] _start;
}
//修改tmp的方向
_start = tmp;
//修改原来的_finsh
_finsh = _start + sz;
//修改原来的_end_of_stroage
_end_of_stroage = _start + n;
}
}
~Vector()
{
delete[] _start;
_start = _finsh = _end_of_stroage = nullptr;
}
private:
iterator _start;
iterator _finsh;
iterator _end_of_stroage;
};
void test1()
{
Vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
v.push_back(6);
v.push_back(7);
v.push_back(8);
v.insert(v.begin(), 99);
auto it = v.begin();
while (it != v.end())
{
cout << *it <<" ";
it++;
}
cout << endl;
v.erase(v.begin() + 2);
for (size_t i = 0; i < v.size(); i++)
{
cout << v[i] << " ";
}
cout << endl;
}
void test2()
{
Vector<int> v;
v.push_back(2);
v.push_back(2);
v.push_back(8);
v.push_back(4);
v.push_back(5);
v.push_back(6);
v.push_back(7);
v.push_back(8);
for (size_t i = 0; i < v.size(); i++)
{
cout << v[i] << " ";
}
cout << endl;
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
it = v.erase(it);
//删除之后it待在原地，因为下一个位置会前移到it位置
}
else
{
it++;
}
}
for (size_t i = 0; i < v.size(); i++)
{
cout << v[i] << " ";
}
cout << endl;
}
void test3()
{
Vector<int> v(10);
v.push_back(2);
v.push_back(2);
v.push_back(8);
v.push_back(4);
v.push_back(5);
v.push_back(6);
v.push_back(7);
v.push_back(8);
//const Vector<int> v1(v); //拷贝构造
Vector<int> v1;
v1 = v;
auto it = v1.begin();
while (it != v1.end())
{
cout << *it << " ";
it++;
}
}
void test4()
{
Vector<int> v;
v.push_back(1);
v.push_back(1);
v.push_back(1);
v.push_back(1);
v.push_back(1);
v.push_back(1);
v.resize(20, 999);
auto it = v.begin();
while (it != v.end())
{
cout << *it << " ";
it++;
}
}
void test5()
{
const string s("hello world");
Vector<char> S(s.begin(), s.end());
auto it = S.begin();
while (it != S.end())
{
cout << *it << " ";
it++;
}
}
void test6()
{
Vector<int> v(10, 90);
auto it = v.begin();
while (it != v.end())
{
cout << *it << " ";
it++;
}
}
}
1612
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
