目录
③以下代码的功能是删除vector中所有的偶数，请问那个代码是正确的，为什么？
1.vector的介绍
①vector是表示可变大小数组的序列容器。
②vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。
③vector与普通数组不同的是，vector的大小是可以动态改变的，会被容器自动处理。
④当vector需要重新分配大小时，其做法是，开辟一个新的数组，然后将全部元素移到这个数组当中，并释放原来的空间。
⑤vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因此存储空间比实际需要的存储空间一般更大。不同的库采用不同的策略权衡空间的使用和重新分配，以至于在末尾插入一个元素的时候是在常数的时间复杂度完成的。
⑥由于vector采用连续的空间来存储元素，与其他动态序列容器相比，vector在访问元素的时候更加高效，在其末尾添加和删除元素相对高效，而对于不在其末尾进行的删除和插入操作效率则相对较低。
2.接口总览
namespace XM
{
//模拟实现vector
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
//默认成员函数
vector(); //构造函数
vector(size_t n, const T& val); //构造函数
template<class InputIterator>
vector(InputIterator first, InputIterator last); //构造函数
vector(const vector<T>& v); //拷贝构造函数
vector<T>& operator=(const vector<T>& v); //赋值运算符重载函数
~vector(); //析构函数
//迭代器相关函数
iterator begin();
iterator end();
const_iterator begin()const;
const_iterator end()const;
//容量和大小相关函数
size_t size()const;
size_t capacity()const;
void reserve(size_t n);
void resize(size_t n, const T& val = T());
bool empty()const;
//容器内容修改相关函数
void push_back(const T& x);
void pop_back();
void insert(iterator pos, const T& x);
iterator erase(iterator pos);
void swap(vector<T>& v);
//访问容器相关函数
T& operator[](size_t i);
const T& operator[](size_t i)const;
private:
iterator _start; //指向容器的头
iterator _finish; //指向有效数据的尾
iterator _endofstorage; //指向容器的尾
};
}
注：我们的类名字和库里面的冲突，所以放在自己的命名空间中。
vector私有成员变量理解:
3.提前使用到的函数
①size() 返回vector中有效数据个数
size_t size()const
{
return _finish - _start; //返回容器当中有效数据的个数
}
②capicity 返回vector中的最大容量
size_t capacity()const
{
return _endofstorage - _start; //返回当前容器的最大容量
}
③swap 交换两个对象的数据
//交换两个容器的数据
void swap(vector<T>& v)
{
//交换容器当中的各个成员变量
::swap(_start, v._start); //::调用全局的swap
::swap(_finish, v._finish);
::swap(_endofstorage, v._endofstorage);
}
注意： 在此处调用库当中的swap需要在swap之前加上“::”（作用域限定符），告诉编译器这里优先在全局范围寻找swap函数，否则编译器会认为你调用的就是你正在实现的swap函数（就近原则）。
4.默认成员函数
①构造函数1 : 无参构造
vector()
: _start(nullptr)
, _finish(nullptr)
,_endofstorage(nullptr)
{}
②构造函数2: 构造含有N个值为val的数据。
//构造函数2
vector(size_t n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n); //提前开辟好空间，调用reserve函数将容器容量设置为
while(n--) //尾插n个值为val的数据到vector当中
push_back(val);
}
注意:
(1）该构造函数知道其需要用于存储n个数据的空间，所以最好用reserve函数一次性开辟好空间，避免调用push_back函数时需要增容多次，导致效率降低。
(2）该构造函数还需要实现两个重载函数
vector(long n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n);
while(n--)
push_back(val);
}
vector(int n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n);
while(n--)
push_back(val);
}
可以看到，这两个重载函数与之不同的就是其参数n的类型不同，但这是必要的，否则当我们使用以下代码时，编译器会优先与构造函数3相匹配。并且因为构造函数3当中对参数first和last进行了解引用（而int类型不能进行解引用操作）而报错。
③构造函数3:使用一段迭代器区间进行对象的构造。
因为该迭代器区间可以是其他容器的迭代器区间，因此函数接收到的迭代器的类型是不确定的，所以我们这里需要将该构造函数设计为一个函数模板，在函数体内将该迭代器区间的数据一个个尾插到容器当中。
template<class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
//将迭代器区间在[first,last)的数据一个个尾插到容器当中
while (first != last)
{
push_back(*first);
first++;
}
}
④拷贝构造(深浅拷贝)
(1)传统写法
//传统写法
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++) //将容器v当中的数据一个个拷贝过来
{
_start[i] = v[i];
}
_finish = _start + v.size(); //容器有效数据的tail
_endofstorage = _start + v.capacity(); //整个容器空间的tail
}
图片解析来自:2021dragon
总结:T是内置类型(int)或浅拷贝自定义类型(Date)，他们增容或者拷贝构造中，我们用memcpy是没有问题的但是T是深拷贝的自定类型(string),他们增容或者拷贝构造中，我们用memcpy是有问题的。
(2)现代写法
//现代写法
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(v.capacity()); //调用reserve函数将容器容量设置为与v相同
for (auto& e : v) //引用减少拷贝
{
push_back(e);
}
}
⑤赋值构造
(1)传统写法
vector<T>& operator=(const vector<T>& v)
{
if (this != &v) //防止自己给自己赋值
{
delete[] _start; //释放原来的空间
_start = new T[v.capacity()]; //开辟一块和容器v大小相同的空间
for (size_t i = 0; i < v.size(); i++) //将容器v当中的数据一个个拷贝过来
{
_start[i] = v[i];
}
_finish = _start + v.size(); //容器有效数据的tail
_endofstorage = _start + v.capacity(); //整个容器的tail
}
return *this; //支持连续赋值
}
(2)现代写法
这种现代写法非常妙，首先在传参时并没有使用引用传参，因为这样可以间接调用vector的拷贝构造函数生成一份临时的对象，然后将这个拷贝构造出来的对象v与本对象的数据进行交换，此时就相当于完成了赋值操作，函数执行完之后，而对象v自动析构。
vector<T>& operator=(vector<T> v) //一份临时对象
{
swap(v); //交换这两个对象
return *this; //支持连续赋值
}
⑥析构函数
~vector()
{
if (_start) //避免对空指针进行释放
{
delete[] _start; //释放动态开辟的空间
_start = nullptr;
_finish = nullptr;
_endofstorage = nullptr;
}
}
5.迭代器相关函数
typedef T* iterator;
typedef const T* const_iterator;
①begin 和 end
// 能读能写
iterator begin()
{
return _start; //返回容器的首地址
}
iterator end()
{
return _finish; //返回容器当中有效数据的下一个数据的地址
}
//只能读
const_iterator begin()const
{
return _start;
}
const_iterator end()const
{
return _finish;
}
②迭代器的使用(遍历)
//1.正常遍历
vector<string> v(5, "mi");
vector<string>::iterator it = v.begin();
while (it != v.end())
{
cout << *it << " ";
it++;
}
cout << endl;
//2.范围for最终被替换为迭代器
vector<int> v(5, "mi");
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
注意:
6.vector容量和大小相关函数
①reserve
reserve规则：
1、当n大于对象当前的capacity时，将capacity扩大到n或大于n。
2、当n小于对象当前的capacity时，什么也不做。
void reserve(size_t n)
{
if (n > capacity()) //空间大小是否满足
{
size_t sz = size(); //记录当前容器当中有效数据的个数
T* tmp = new T[n]; //开辟一块可以容纳n个数据的空间
if (_start) //vector是否为空
{
for (size_t i = 0; i < sz; i++) //将vector当中的数据一个个拷贝到tmp当中
{
tmp[i] = _start[i];
}
delete[] _start; //将vector本身存储数据的空间释放
}
_start = tmp; //将tmp所维护的数据交给_start进行维护
_finish = _start + sz; //更新
_endofstorage = _start + n; //更新
}
}
在reserve函数的实现当中需要注意：
(1）在进行操作之前需要提前记录当前容器当中有效数据的个数。
因为我们最后需要更新_finish指针的指向，_finish = _start + sz，当_start改变后我们再调用size函数通过_finish - _start计算出的数值就是一个随机值了。
(2)拷贝vector当中的数据时，不能使用memcpy函数进行拷贝。
可能你会想，当vector当中存储的是string的时候，虽然使用memcpy函数reserve出来的容器与原容器当中每个对应的string成员都指向同一个字符串空间，但是原容器存储数据的空间不是已经被释放了，相当于现在只有一个容器维护这这些字符串空间，这还有什么影响。但是不要忘了，当你释放原vector空间的时候，原容器当中存储的每个string在释放时会调用string的析构函数，将其指向的字符串也进行释放，所以使用memcpy函数reserve出来的容器当中的每一个string所指向的字符串实际上是一块已经被释放的空间，访问该容器时就是对内存空间进行非法访问。
②resize
resize规则：
1、当n大于当前的size时，将size扩大到n，扩大的数据为val，若val未给出，则默认为容器所存储类型的默认构造函数所构造出来的值。
2、当n小于当前的size时，将size缩小到n。
void resize(size_t n, const T& val = T()) //T类型的缺省值，调用自己的构造函数
{
if (n < size()) //当n小于当前的size时
{
_finish = _start + n; //将size缩小到n
}
else //当n大于当前的size时
{
if (n > capacity()) //判断是否需要增容
{
reserve(n);
}
while (_finish < _start + n) //将size扩大到n
{
*_finish = val;
_finish++;
}
}
}
③empty
bool empty() const
{
return _start == _finish;
}
7.vector内容修改函数
①push_back (尾插)
void push_back(const T& x)
{
if (_finish == _endofstorage) //判断是否需要增容
{
size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity(); //将容量扩大为原来的两倍
reserve(newcapacity); //增容
}
*_finish = x; //尾插数据
_finish++; //_finish指针后移
}
- capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。 这个问题经常会考察，不要固化的认为，顺序表增容都是2倍，具体增长多少是根据具体的需求定义 的。vs是PJ版本STL，g++是SGI版本STL。(增长的倍数大了可能造成空间的浪费，倍数增长小了可能会进行多次增容，效率低)
②pop_back (尾删)
void pop_back()
{
assert(!empty()); //vector为空则报错
_finish--; //_finish指针前移
}
③insert（任意位置插入，不建议使用，效率低）
//在pos位置插入数据
void insert(iterator pos, const T& x)
{
if (_finish == _endofstorage) //判断是否需要增容
{
size_t len = pos - _start; //记录pos与_start之间的间隔，相差元素个数
size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity(); //将容量扩大为原来的两倍
reserve(newcapacity); //增容
pos = _start + len; //更新pos位置，通过len找到pos在增容后的容器当中的位置
}
//将pos位置及其之后的数据统一向后挪动一位，以留出pos位置进行插入
iterator end = _finish;
while (end > pos + 1)
{
*end = *(end - 1);
end--;
}
*pos = x; //将数据插入到pos位置
_finish++; //数据个数增加一个，_finish后移
}
注意： 若需要增容，_start指向新的空间，pos和_start 的相对位置发生了改变，需要在增容前记录pos与_start之间的间隔，更新pos的位置，然后通过该间隔确定在增容后的容器当中pos的指向，否则pos还指向原来被释放的空间。
④erase(任意位置删除，不建议使用)
//删除pos位置的数据
iterator erase(iterator pos)
{
assert(!empty()); //vector为空则报错
//将pos位置之后的数据统一向前挪动一位，以覆盖pos位置的数据
iterator it = pos;
while (it < (_finish-1))
{
*it = *(it+1);
it++;
}
_finish--; //数据个数减少一个，_finish前移
return pos;
}
8.vector的访问
重载operator[] ：支持下标访问
T& operator[](size_t i)
{
assert(i < size()); //检测下标的合法性
return _start[i]; //返回对应数据
}
const T& operator[](size_t i)const
{
assert(i < size()); //检测下标的合法性
return _start[i]; //返回对应数据
}
9.迭代器失效问题
①概念
②对于vector可能会导致其迭代器失效的操作有:
#include <iostream>
using namespace std;
#include <vector>
int main()
{
vector<int> v{1,2,3,4,5,6};
auto it = v.begin();
// 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
// v.resize(100, 8);
// reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
// v.reserve(100);
// 插入元素期间，可能会引起扩容，而导致原空间被释放
// v.insert(v.begin(), 0);
// v.push_back(8);
while(it != v.end())
{
cout<< *it << " " ;
++it;
}
cout<<endl;
return 0;
}出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉， 而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的 空间，而引起代码运行时崩溃。解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新赋值即可。
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
vector<int> v;
v.push_back(5);
v.push_back(6);
v.push_back(7);
v.push_back(8);
v.push_back(9);
v.push_back(10);
//v: 5 6 7 8 9 10
vector<int>::iterator pos = find(v.begin(), v.end(), 7); //获取值为7的元素的迭代器
v.insert(pos, 77); //在值为7的元素的位置插入77
//v: 5 6 77 7 8 9 10
pos = find(v.begin(), v.end(), 7); //重新获取值为7的元素的迭代器
v.erase(pos); //删除元素7
//v: 5 6 77 8 9 10
return 0;
}
(2)指定位置元素的删除操作--erase
#include <iostream>
using namespace std;
#include <vector>
int main()
{
int a[] = { 1, 2, 3, 4 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
// 使用find查找3所在位置的iterator
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
// 删除pos位置的数据，导致pos迭代器失效。
v.erase(pos);
cout << *pos << endl; // 此处会导致非法访问
return 0;
}// pos的意义变了，两次指向不同的值，虽然是同—块空间，但是意义可能不—样
erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是 没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效 了。
③以下代码的功能是删除vector中所有的偶数，请问那个代码是正确的，为什么？
#include <iostream>
using namespace std;
#include <vector>
int main()
{
vector<int> v{ 1, 2, 3, 4 };
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
v.erase(it);
++it;
}
return 0;
}
int main()
{
vector<int> v{ 1, 2, 3, 4 };
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
it = v.erase(it);
else
++it;
}
return 0;
}
④总结
迭代器失效解决办法:在使用前，对迭代器重新赋值即可。
8087
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
