STL-vector类
vector介绍及其使用
介绍
向量是序列容器，表示大小可以变化的数组 见 chttps://cplusplus.com/reference/vector/vector/
使用
vector定义
vector() | 无参构造 |
|---|---|
vector(size-type n,const value_type&val = value_type()) | 构造并初始化n个val |
vector(const vector & x) | 拷贝构造 |
vector(inputlterator first,inputlterator last) | 用迭代器初始化构造 |
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> A;
vector<int> B(5,1);
vector<int> C(B);
vector<int> D(C.begin(),C.end());
}vector iterator
begin + end | 获取第一个数据的位置,和最后一个数据的下一个位置 |
|---|---|
rbegin+rend | 获取最后一个数据的位置,和第一个位置的上一个位置 |
int main()
{
vector<int> B(5,1);
for (auto it = B.begin(); it != B.end(); it++)
cout << *it << ' ';
cout << endl;
for (auto rit = B.rbegin(); rit != B.rend(); rit++)
cout << *rit << ' ';
}vector内存管理
size | 数据个数 |
|---|---|
capacity | 容量大小 |
empty | 判断为空 |
resize | 改变size |
reserve | 改变capacity |
注意
reserve只会开辟空间,不会缩小 resize大于reserve会申请空间小于size会减少数据个数
int main()
{
vector<int> A(100, 0);
cout << A.empty()<<' ' << A.size() <<' ' << A.capacity() << endl;
A.resize(200, 1);
cout << A.empty() << ' ' << A.size() << ' ' << A.capacity() << endl;
A.reserve(1000);
A.reserve(100);
cout << A.empty() << ' ' << A.size() << ' ' << A.capacity() << endl;
A.resize(20);
cout << A.empty() << ' ' << A.size() << ' ' << A.capacity() << endl;
}vector内容管理
push_back | 尾插 |
|---|---|
pop_back | 尾删 |
find | 查找 |
insert | 插入 |
erase | 删除 |
swap | 交换两个vector的数据空间 |
operator[] | 访问 |
vector<int> A;
A.push_back(1);
A.push_back(2);
cout << A.back()<<' ';
A.pop_back();
cout << A.back()<<' ';
auto pos = find(A.begin(), A.end(), 1);
cout << *pos << ' ';
A.insert(pos, 0);
cout << A.front()<<' ';
A.erase(find(A.begin(),A.end(),1));
cout << A.back() << ' ';
cout << A[0];
return 0;vector的模拟实现
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <assert.h>
namespace my_vector
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator cbegin() const
{
return _start;
}
const_iterator cend() const
{
return _finish;
}
vector() :_start(new T[0]), _finish(_start), _endOfStorage(_start) {}
vector(int n, const T& value = T())
{
while (n--)
{
this->push_back(value);
}
}
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector(const vector<T>& v)
{
reserve(v.capacity());
iterator it = begin();
const_iterator vit = v.cbegin();
while (vit != v.cend())
{
*it++ = *vit++;
}
_finish = it;
}
vector<T>& operator= (vector<T>& v)
{
vector<T> tmp(v);
swap(*this, tmp);
}
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _endOfStorage = nullptr;
}
}
void push_back(const T& x)
{
insert(end(), x);
}
iterator insert(iterator pos, const T& x)
{
assert(pos>= _start);
if (_finish == _endOfStorage)
{
size_t locate = pos - _start;
reserve(this->capacity() == 0 ? 4 : this->capacity() * 2);
pos = _start + locate;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
_finish++;
*pos = x;
return pos;
}
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _endOfStorage - _start;
}
void reserve(size_t n)
{
if (n > this->capacity())
{
size_t size = this->size();
T* new_start = new T[n];
memcpy(new_start, _start, sizeof(T) * size);
delete[] _start;
_start = new_start;
_finish = _start + size;
_endOfStorage = _start + n;
}
}
void swap(vector<T>& other)
{
std::swap(this->_start, other._start);
std::swap(this->_finish, other._finish);
std::swap(this->_endOfStorage, other._endOfStorage);
}
void resize(size_t n, const T& value = T())
{
if (n > this->size())
{
while (n >= this->size())
{
push_back(value);
}
}
}
iterator erase(iterator pos)
{
iterator end = _finish - 2;
while (end >= pos)
{
*(end) = *(end+1);
--end;
}
--_finish;
return pos;
}
void pop_back()
{
erase(this->end());
}
private:
iterator _start;//开始
iterator _finish;//有效数据的尾
iterator _endOfStorage;//容量的尾
};
}vector的迭代器失效
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T*。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃（即如果继续使用已经失效的迭代器，程序可能会崩溃）。
会引起迭代器失效的操作
改变底层空间的操作,都有可能导致迭代器失效,如resize,reserve,insert,assign,push_back等
改变空间大小后,可能前往了一个新的地方申请空间,而且释放了原有空间,那么指向原有空间的迭代器就属于"野指针",也就失效了
int main()
{
vector<int> A(10, 0);
auto pos = A.begin();
A.reserve(1000);
cout << *pos;
return 0;
}erase清除元素导致
int main()
{
vector<int> A(10, 0);
auto pos = A.begin();
A.erase(pos);
cout << *pos;
return 0;
}本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2024-12-15，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录
腾讯云开发者
