C++——vector

最新推荐文章于 2024-09-27 17:57:19 发布

微yu

最新推荐文章于 2024-09-27 17:57:19 发布

阅读量206

点赞数

分类专栏： C++ 文章标签： c++ 开发语言 1024程序员节

本文链接：https://blog.csdn.net/m0_64607843/article/details/133799096

版权

C++ 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

vector

vector单词直译是向量的意思，这个容器可以容纳不同的类型数据，并且是一个连续的可自动增长的顺序表。
// 它有两个模板参数，第一个就是vector要存放的类型，需要显示实例化
// 第二个叫做空间配置器，如果不写，默认就是库中的
template <class T, class Alloc = allocator<T>> class vector;

vector常用接口

构造函数

#include <vector> // 需要包含头文件

vector<int> first;                                // 一个空vector，可以存放int
vector<int> second (4,100);                       // 插入4个值为100的数据
vector<int> third (second.begin(),second.end());  // 根据迭代器区间去构造
vector<int> fourth (third);                       // 拷贝构造

operator[]+size()

reference operator[] (size_type n); // 返回值reference是返回的引用
const_reference operator[] (size_type n) const; // 返回const引用

size_type size() const; // 返回vector中的个数

vector<int> v1(4, 100);
for (int i = 0; i < v1.size(); i++) // 对每个值操作都是可以的
{
    cout << v1[i] << " ";
    v1[i]++;
}

迭代器

vector<int>::it = it.begin(); // 返回vector初始位置的指针
while (it != v1.end()) // it不等于vector最后一个位置的下一个指针
{
    (*it)++; // 这里有优先级的问题，一定要先解引用才可以拿到数据，否则迭代器就会先移动
    cout << *it << " ";
    it++;
}

// 还有其他迭代器使用方法是一样的

范围for

vector<int> v1(4, 100);
for (auto e : v1) // 底层也是使用了迭代器
{
    cout << e << " ";
}

capacity()

size_type capacity() const; // 返回容器开辟的空间

resize()

void resize (size_type n, value_type val = value_type()); // 这个value_type就是显示实例化的那个模板参数
vector<int> v1(4, 100); // resize有几种情况
v1.resize(2); // 第一种，n < v1.size()，v1.size()会变成n，原来大于n的位置的数据会直接移除
v1.resize(5, 1); // 第二种，n > v1.size()，v1.size()会变成n，并且没有初始化过的数据初始化为val
v1.resize(10); // 第三种，n > v1.size()，没有给val的值，v1.size()会变成n，没有初始化过的值赋值为0
// 以上三种如果vector空间不够会自动开辟空间，空间很大，size变得很小也会释放空间

reverse()

void reserve (size_type n); // 重新申请大小为n的空间
// 如果n小于现在的capacity不操作，如果n大于capacity就重新申请大小为n的空间

push_back和pop_back

void push_back(const value_type& val); // 尾插
void pop_back(); // 尾删
// 不做过多介绍了

insert

void insert(iterator pos, size_type n, const value_type& val); // 传入一个迭代器，把val的值插入pos的位置
void insert (iterator pos, InputIterator first, InputIterator last); // 在pos位置插入一段迭代器区间
// string中还有find这样的函数还能找到下标，但是vector中并没有这个接口
// 所以在algorithm这个库中就有这个函数
template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val); // 在一段迭代器区间找到val

vector<int> v(4, 1);
vector<int>::iterator pos = find(v.begin, v.end(), 1);

erase()

iterator erase (iterator pos); // 删除pos位置
iterator erase (iterator first, iterator last); // 删除一段区间

vector<int> v(4, 1);
vector<int>::iterator:: pos = find(v.begin(), v.end(), 1);
if (pos != v.end()) // 这里最好还是判断一下，如果没找到就不删，不会报错
{
    erase(pos);
}

algorithm::sort

template <class RandomAccessIterator>
void sort (RandomAccessIterator first, RandomAccessIterator last);
// 这个函数虽然不是vector库中的，但还排序还是很好用的，它的底层是使用的快排
// 这个函数默认排的是升序
vector<int> v;
v.push_back(2);
v.push_back(1);
v.push_back(7);
v.push_back(4);
sort(v.begin(). v.end());

// 要是想要排降序呢
template <class RandomAccessIterator, class Compare>
void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
// 前两个还是迭代器区间，最后一个参数决定是升序还是降序
// 在库中有一个类模板less<T>，把这个传入就是升序，也不需要传
// 升序要再包含一个头文件functional，这样就可以使用greater<T>这个类模板了
sort(v.begin(), v.end(), greater<int>()); // 传入的是一个对象，所以使用匿名对象

注意

// vector不仅可以存放int，它甚至可以存放string
vector<string> strV;
string str("abc");
strV.push_back(str);
strV.push_back(string("abc"));
strV.push_back("abc");

// 遍历
for (auto& str : strV) // 这里注意的是，使用引用传参，如果不加引用就是深拷贝，深拷贝的代价很大
{}

迭代器失效

迭代器也用过了，但是使用的过程中还会出现一些奇怪的问题。

vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
if (pos != v.end())
{
    v.insert(pos, 10);
    
    v.insert(pos, 20);
}

vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
auto it = v.begin();
while (it != v.end())
{
    if (*it % 2 == 0)
        erase(it);
    it++;
}

// 库中有这两个函数的声明，这里的返回值是操作后的下一个数，使用的时候一定要接受返回值
iterator insert (iterator position, const value_type& val);
iterator erase (iterator position);

if (pos != v.end())
{
    pos = v.insert(pos, 10);
    // 插入10，下一个位置就是3，扩容完之后pos的位置也是正确的
    pos = v.insert(pos, 20); // 再插入20就不会出错
}

while (it != v.end())
{
    if (*it % 2 == 0)
        it = erase(it); // 这里不赋值也可以，如果删除了，it不动就是下一个的位置
    else
        it++; // 不删除再++
}

当然不止这两种实例可以证明迭代器失效，但是出的都是这一类问题，所以使用这两个函数的时候，一定要更新pos的位置，直接访问会出问题，这就是迭代器失效。迭代器失效的情况在不同平台下的效果是不一样的。