C++ STL - vector/list讲解及迭代器失效

vector 使用

vector 是一个动态数组.

构造/拷贝构造/赋值重载函数

int main()
{
  // 是一个模板, 在实例化的时候, 需要指明类型
  std::vector<int> first; // 一个空的数组
  std::vector<int> second (4,100); // 设置初始空间大小为 4 个int, 全部初始化为 100
  std::vector<int> third (second.begin(),second.end()); // 通过迭代器构造
  std::vector<int> fourth (third); // 直接复制 third, 拷贝构造 
  std::vector<int> fifth;
  fifth = fourth;  // 复制重载
  return 0;
}

空间函数

1. size/capacity

size: 返回 vector 当前存储的元素数量

capacity: 返回 vector 最大存储元素数量

size_type size() const noexcept;
size_type capacity() const noexcept;

int main()
{
    vector<int> v1(10, 1);
    cout << v1.size() << " " << v1.capacity() << endl;
    return 0;
}

2. resize/reserve

resize: 修改 vector 对象的 size

reserve: 修改 vector 的容量 capacity

void resize (size_type n);
void resize (size_type n, const value_type& val);

void reserve (size_type n);

int main()
{
    vector<int> v1;
    v1.resize(10, 0);
    // n < size 则数据丢失, n > capacity 则发生扩容, 用 val 填充扩容的空间
    v1.reserve(20);
    // 如果当前容量小于 n，vector 会重新分配内存以增加容量。
    // 如果当前容量已经大于或等于 n，则 reserve() 不会改变容量。
    return 0;
}

reserve修改的只是capacity, 而不是size, 这是由区别的.

int main()
{
    vector<int> v1;
    v1.reserve(10);
    v1[1] = 10; // 这是错误的, reserve(10) 只是开辟了 10 个空间, 这 10 个空间还没有给我们使用
    v1.resize(10);
    v1[1] = 10; // 设置size = 10, 让v1分配了 10 个空间使用权给我们
}

3. empty

empty: 检查 vector 是否为空, 为空返回 true, 否者返回 false

bool empty() const noexcept;

int main()
{
    vector<int> v1;
    if(v1.empty)
    {
        cout << "数组为空" << endl;
    }
    else
    {
        cout << "数组不为空" << endl;
    }
}

访问

1. operator[] / at

这两个函数都是用于访问 vector 中指定索引的元素

int main()
{
    vector<int> v1(10);
    for(int i = 0; i < 10; i++)
    {
        v1[i] = i;
    }
    v1.at(5) = 50;
    cout << v1[2] << endl;
    cour << v1.at(5) << endl;
}

区别: operator[] 不会进行边界检查, 如果访问位置超出范围, 行为是未定义的

at 则会进行边界检查, 访问位置超出范围, 则抛出异常

2. front / back

front: 返回数组头部的元素

back: 返回数组末尾的那个元素

int main()
{
    vector<int> v1(10);
    for(int i = 0; i < 10; i++)
    {
        v1[i] = i;
    }
    cout << v1.front() << endl;
    cout << v1.back() << endl;
    return 0;
}

3. data

data: 返回一个指向 vector 内部数组的指针, 允许直接访问底层数组

int main()
{
    vector<int> v1(10);
    for(int i = 0; i < 10; i++)
    {
        v1[i] = i;
    }
    int* arr = v1.data();
    cour << arr[5] << endl;
    return 0;
}

修改

1. push_back / pop_back

push_back: 向 vector 的末尾插入一个元素

pop_back: 删除 vector 末尾的一个元素

int main()
{
    vector<int> v1;
    v1.push_back(2);
    cout << v1
    return 0;
}

2. insert / erase

insert: 向指定的位置 (位置是一个迭代器) 后面插入一个元素, 并返回指向插入元素的迭代器

erase: 删除指定位置的元素, 返回删除位置的后一个元素的迭代器

#include <iostream>
#include <vector>

int main ()
{
    std::vector<int> myvector (3,100);
    std::vector<int>::iterator it;

    it = myvector.begin();
    it = myvector.insert ( it , 200 );
    cout << *it << endl;
	it = myvector.erase(it);
	std::cout << *it << std::endl;
    return 0;
}

3. swap / clear

swap: 交换两个 vector 的值

clear: 清空 vector 中的元素

int main()
{
    vector<int> v1(3, 200);
    vector<int> v2(5, 100);
    v1.swap(v2);
    cout << v1[1] << endl;
    v1.clear();
    if(v1.empty())
    {
        cout << "v1为空" << endl;
    }
    return 0;
}

list 使用

list 底层是一个双向链表, 链表擅长的就是插入删除操作.

构造list

int main()
{
    std::list<int> first;                                // empty list of ints
    std::list<int> second (4,100);                       // four ints with value 100
    std::list<int> third (second.begin(),second.end());  // iterating through second
    std::list<int> fourth (third);
    return 0;
}

容量

empty / size

和上面 vector 中的函数作用相同

STL 容器中的函数名称非常相似, 功能也相似, 熟悉完 vector 之后, list 使用也很简单

empty: 判断 list 是否为空

size: 返回链表的长度.

int main()
{
    list<int> l1(3, 10);
    cout << "l1 的长度为: " << l1.size() << endl;
    if(l1.empty())
    {
        cout << "l1 为空" << endl;
    }
    return 0;
}

修改

list 提供了非常多的插入删除操作, 因为相比于 vector, 双向链表插入删除效率更高

push_back / push_front / pop_back / pop_front

push_back: 在 list 尾部插入一个元素

push_front: 在 list 头部插入一个元素

pop_back: 在 list 尾部删除一个元素

pop_front: 在 list 头部删除一个元素

int main()
{
    list<int> l1(2, 10);
    l1.push_back(20);
    l1.push_frong(5);
    // 在 string 中说过, 迭代器的使用方法和指针差不多
    std::list<int>::iterator it = l1.begin(); // 获取 l1 首元素的迭代器
    while(it != l2.end())
    {
        cout << *it << " ";
    }
    l1.pop_back();
    l1.pop_front();
    while(it != l2.end())
    {
        cout << *it << " ";
    }
    return 0;
}

insert / erase

insert: 向指定的位置 (位置是一个迭代器) 的前面插入一个元素, 并返回指向插入元素的迭代器

erase: 删除指定位置的元素, 返回删除位置的后一个元素的迭代器

int main ()
{
    std::list<int> mylist;
    std::list<int>::iterator it;

    // set some initial values:
    for (int i=1; i<=5; ++i) mylist.push_back(i); // 1 2 3 4 5

    it = mylist.begin();
    ++it;       // it points now to number 2           ^

    mylist.insert (it,10);                        // 1 10 2 3 4 5

    // "it" still points to number 2                      ^
    mylist.insert (it,2,20);                      // 1 10 20 20 2 3 4 5


    mylist.erase(it);

    it = mylist.begin();
    while(it != mylist.end())
    {
        cout << *it << " ";
    }
}

迭代器失效问题

迭代器失效: 指的是由于容器（如std::vector、std::list等）的某些操作导致之前获取的迭代器不再指向容器中的有效元素，或者不再指向任何元素，从而不能被安全使用的现象。

可以理解为迭代器就是指针, 那么指针什么时候会失效: 所指向的空间是错误的, 那么哪些操作会导致指针指向的空间发生变化.

vector 迭代器失效情况

在 vector 中, 有以下情况会导致迭代器失效

1. 插入操作 ：当使用 push_back 或 insert 插入元素时，如果 vector 的容量不足以容纳新元素，它可能会重新分配内存，这会导致所有迭代器失效。即使不重新分配内存，insert 操作也会使插入点之后的迭代器失效。

2. 删除操作 ：使用 erase 或 pop_back 删除元素时，指向被删除元素的迭代器会失效，同时，指向被删除元素之后的所有迭代器也会失效。

3. 容量调整 ：调用 resize 或 reserve 调整容量时，如果新容量大于当前容量，可能会导致重新分配内存，从而使所有迭代器失效

再看这段代码

int main()
{
    vector<int> v1 = {2, 3, 4, 4, 5};
    std::vector<int>::iterator it = v1.begin();
    while(it != v1.end())
    {
        if(*it % 2 == 0)
        {
            v1.erase(it);
        }
        ++it;
    }
    
    return 0;
}

看似每次检查完当前元素之后, it 向后走一步, 检查下一个.

实际上, 因为进行了删除操作, 数据进行了挪动,

导致后面的元素顺序发生变化, it 所指向的内容就变成了未定义行为.

解决方法

int main()
{
    vector<int> v1 = {2, 3, 4, 4, 5};
    std::vector<int>::iterator it = v1.begin();
    while(it != v1.end())
    {
        if(*it % 2 == 0)
        {
            it = v1.erase(it);
        }
    }
    
    return 0;
}

上面介绍 erase 和 insert 的时候说了: 这两个函数会返回一个迭代器.

此时返回的迭代器是有效的. 我们使用返回的迭代器代替已经失效的迭代器.

list 迭代器失效

list 迭代器失效:

删除操作 ：使用 erase 删除元素时，只有指向被删除元素的迭代器会失效。其他迭代器，包括指向被删除元素之前和之后的元素的迭代器，仍然有效。

int main()
{
    std::list<int> lst = {1, 2, 3, 4, 5};
    std::list<int>::iterator it = lst.begin(); // it 指向第一个元素
    lst.erase(it); // 仅 it 失效，lst.begin() 之后的迭代器仍然有效
    ++it; // 未定义行为，it 已经失效
    // it = lst.erase(it);  应该将 it 进行更新
}

所以当指向了可能导致迭代器失效的操作后, 就不要再使用那个旧的迭代器了.

需要更新当前的迭代器.