vector
vector概念
Vector是表示可变大小数组的序列容器。Vector也采用的连续存储空间来存储元素。本质讲，Vector使用动态分配数组来存储它的元素。
由于Vector也采用连续的内存空间进行存储，所以它也可以被下标访问内部元素。
Vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。
vector接口
这里主要增加的是模拟实现后的代码，如果想了解如何使用，可以直接去官网看使用方式。链接: https://cplusplus.com/reference/
| 接口名称 | 接口说明 |
|---|---|
| size | 数据个数 |
| capacity | 容器容量 |
| resize(重点) | 改变vector的size |
| reserver(重点) | 改变vector的capacity |
| push_back(重点) | 尾插 |
| pop_back(重点) | 尾删 |
| insert(重点) | 插入 |
| erase(重点) | 删除 |
| swap | 交换 |
| operator[] | 使用 [] 访问 |
附录中有详细的代码设置，以及设置缘由，这里不再赘述。
构造函数
三种构造方式分别是：无参构造，含参构造，一段区间的构造
注释的代码是可以通过给缺省值的方式进行不需要初始化的构造。但是给缺省值这种方式会因为匹配合适度的原因导致匹配的不是很完美。当没有最符合的构造函数时，会优先匹配到第三种方式来进行构造，可能会导致出现bug。
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
vector()
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{}
vector(size_t n, const T& val = T())//匿名对象生命周期只在当前一行，因为之后没人会用//const引用会延长匿名对象生命周期到引用对象域消失
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(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)
, _end_of_storage(nullptr)
{
while (first != last)//为了后面链表不一定是first < last,所以使用不等于
{
push_back(*first);
++first;
}
}
/*
//由于给了缺省值，所以可以不初始化列表
vector()
{}
vector(size_t n, const T& val = T())
{
reserve(n);//提升效率，扩容
for (size_t i = 0; i < n; ++i)
{
push_back(val);
}
}
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}*/
/*vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
reserve(v.capacity());
for (auto ch : v)
{
push_back(ch);
}
}*/
private:
iterator _start;
iterator _finish;
iterator _end_of_storage;
/*
//在c++11之后，由于构造函数都是内置类型。所以也可以通过给缺省值 ，给构造函数 初始化列表 使用
//但是会有一点问题 ----> 由于匹配会优先匹配到最合适的构造函数，如果没有最优先，也会找一个差不多的
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _end_of_storage = nullptr;
*/
};
迭代器失效
需要注意的是：在vector中，对内存进行增删的操作，一般都会引起迭代器失效的问题。
解决的办法就是：在使用前，对迭代器重新赋值即可
修改内存导致的迭代器失效的接口函数：reserve、resize(复用了reserve)、push_back、pop_back、insert、erase。这些都有可能导致迭代器失效的问题。
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size();//记录旧的距离
T* tmp = new T[n];
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * size());//如果是string类型会崩溃，因为memcpy是浅拷贝
for (size_t i = 0; i < sz; ++i)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;//原来的距离是_finish - _start ,现在的距离是，新的_start + 旧的_finish - 旧的_start
_end_of_storage = _start + n;
}
}
void resize(size_t n, T val = T())
{
if (n < size())
{
_finish = _start + n;//相当于删除对象
}
else
{
if (n > capacity())
{
reserve(n);
}
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}
void push_back(const T& n)
{
if (_finish == _end_of_storage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = n;
++_finish;
}
void pop_back()
{
assert(!empty());
--_finish;
}
iterator insert(iterator pos,const T& val)//返回值返回pos 是迭代器新插入的值所在的位置
{
assert(pos >= _start);
assert(pos <= _finish);
//一旦更新位置，说明开辟出新的空间了，而pos位置则不变，所以pos相对于新空间的位置失效了，需要提前记录更新pos保证他仍然有效
if (_finish == _end_of_storage)
{
size_t len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
//更新pos -- 解决pos失效问题
pos = _start + len;
}
//通常认为 insert之后，pos失效了
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = val;
++_finish;
return pos;
}
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
//erase之后，pos也会失效，不要访问，因为行为结果未定义(不同编译器下不同)
//--- 如果将最后一个元素删除，此时pos指向最后一个元素，但是_finish位置改变，此时的pos位置访问是越界的
iterator start = pos + 1;
while (start != _finish)
{
*(start - 1) = *start;
++start;
}
--_finish;
return pos;
}
附录完整代码
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;
namespace lby
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
vector()
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{}
vector(size_t n, const T& val = T())//匿名对象生命周期只在当前一行，因为之后没人会用//const引用会延长匿名对象生命周期到引用对象域消失
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(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)
, _end_of_storage(nullptr)
{
while (first != last)//为了后面链表不一定是first < last,所以使用不等于
{
push_back(*first);
++first;
}
}
/*
//由于给了缺省值，所以可以不初始化列表
vector()
{}
vector(size_t n, const T& val = T())
{
reserve(n);//提升效率，扩容
for (size_t i = 0; i < n; ++i)
{
push_back(val);
}
}
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}*/
/*vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
reserve(v.capacity());
for (auto ch : v)
{
push_back(ch);
}
}*/
//vector(const vector<T>& v)
//{
// /*reserve(v.capacity());//不太原始，所以下面用一个原始一点的
// for (auto e : v)
// {
// push_back(e);
// }*/
// //reserve(v.capacity());//也不原始
// //memcpy(tmp, _start, sizeof(T) * size());
// //_finish = _start+v.size()//因为reserve中处理的_finish是原来的vector的_finish大小，而不是我们需要的_finish所以要单独处理一下_finish
// _start = new T[v.capacity()];
// //memcpy(tmp, _start, sizeof(T) * size());//memcpy只是将vector中的内容进行拷贝，而内部如果是vector，他们指向的内容并没有拷贝，而是重复指向所以析构函数会报错
// for (size_t i = 0; i < v.size(); ++i)
// {
// _start[i] = v._start[i];//逐个赋值，如果内部是vector相当于每一次调用一次 就构造一个vector
// }
// _finish = _start + v.size();
// _end_of_storage = _start + v.capacity();
//}
vector(const vector<T>& v)//现代写法
{
vector<T> tmp(v.begin(), v.end());//先调用模板类型的拷贝构造来构造出一个v，然后将v的begin和end交给tmp，之后将tmp与this交换
swap(tmp);
}
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<T>& operator=(vector<T> v)//赋值重载，先拷贝构造v，然后再将需要的进行交换
{
swap(v);
return *this;
}
~vector()
{
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size();//记录旧的距离
T* tmp = new T[n];
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * size());//如果是string类型会崩溃，因为memcpy是浅拷贝
for (size_t i = 0; i < sz; ++i)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;//原来的距离是_finish - _start ,现在的距离是，新的_start + 旧的_finish - 旧的_start
_end_of_storage = _start + n;
}
}
void resize(size_t n, T val = T())
{
if (n < size())
{
_finish = _start + n;//相当于删除对象
}
else
{
if (n > capacity())
{
reserve(n);
}
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}
void push_back(const T& n)
{
if (_finish == _end_of_storage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = n;
++_finish;
}
void pop_back()
{
assert(!empty());
--_finish;
}
iterator insert(iterator pos,const T& val)//返回值返回pos 是迭代器新插入的值所在的位置
{
assert(pos >= _start);
assert(pos <= _finish);
//一旦更新位置，说明开辟出新的空间了，而pos位置则不变，所以pos相对于新空间的位置失效了，需要提前记录更新pos保证他仍然有效
if (_finish == _end_of_storage)
{
size_t len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
//更新pos -- 解决pos失效问题
pos = _start + len;
}
//通常认为 insert之后，pos失效了
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = val;
++_finish;
return pos;
}
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
//erase之后，pos也会失效，不要访问，因为行为结果未定义(不同编译器下不同)
//--- 如果将最后一个元素删除，此时pos指向最后一个元素，但是_finish位置改变，此时的pos位置访问是越界的
iterator start = pos + 1;
while (start != _finish)
{
*(start - 1) = *start;
++start;
}
--_finish;
return pos;
}
iterator begin()//传值传参传递的值具有常性
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
bool empty()
{
return _finish == _start;
}
size_t capacity() const
{
return _end_of_storage - _start;
}
size_t size() const
{
return _finish - _start;
}
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
private:
iterator _start;
iterator _finish;
iterator _end_of_storage;
/*
//在c++11之后，由于构造函数都是内置类型。所以也可以通过给缺省值 ，给构造函数 初始化列表 使用
//但是会有一点问题 ----> 由于匹配会优先匹配到最合适的构造函数，如果没有最优先，也会找一个差不多的
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _end_of_storage = nullptr;
*/
};
void funct(const vector<int>& v)
{
for (size_t i = 0; i < v.size(); ++i)
{
cout << v[i] << " ";
}
cout << endl << endl;
}
void test_vector1()
{
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
for (size_t i = 0; i < v1.size(); ++i)
{
cout << v1[i] << " ";
}
cout << endl;
vector<int>::iterator it = v1.begin();
while (it != v1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.pop_back();
v1.pop_back();
v1.pop_back();
v1.pop_back();
v1.pop_back();
}
void test_vector2()
{
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
cout << v1.size() << endl;
cout << v1.capacity() << endl;
for (size_t i = 0; i < v1.size(); ++i)
{
cout << v1[i] << " ";
}
cout << endl;
v1.resize(10);
cout << v1.size() << endl;
cout << v1.capacity() << endl;
for (size_t i = 0; i < v1.size(); ++i)
{
cout << v1[i] << " ";
}
cout << endl;
v1.resize(3);
cout << v1.size() << endl;
cout << v1.capacity() << endl;
for (size_t i = 0; i < v1.size(); ++i)
{
cout << v1[i] << " ";
}
cout << endl;
}
void test_vector3()
{
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
//v1.push_back(5);
funct(v1);
v1.insert(v1.begin(), 0);
funct(v1);
auto pos = find(v1.begin(), v1.end(), 3);
v1.insert(pos, 10);
funct(v1);
}
void test_vector4()
{
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
funct(v1);
v1.insert(v1.begin(), 0);
funct(v1);
auto pos = find(v1.begin(), v1.end(), 3);
v1.erase(pos);
funct(v1);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
