C++STL容器erase-remove惯用法解析

P粉602998670

发布时间：2025-09-17 11:27:01

1036人浏览过

来源于php中文网

原创

erase-remove惯用法通过std::remove（或std::remove_if）将不满足条件的元素前移并返回新逻辑末尾迭代器，再调用容器的erase成员函数删除末尾无效元素，从而高效安全地移除序列容器中符合条件的元素。该方法适用于std::vector、std::deque和std::string等序列容器，因其连续或分块存储特性而效率较高；但不适用于关联容器，且在std::list上应优先使用其专用的remove_if成员函数以避免低效操作。

c++stl容器erase-remove惯用法解析

C++ STL中的

erase-remove

惯用法，简单来说，就是一种安全且相对高效地从序列容器中移除满足特定条件的元素的方法。它之所以成为一个“惯用法”，是因为标准库提供的

std::remove

（或

std::remove_if

）算法本身并不真正改变容器的大小，它只是将不满足条件的元素前移，然后返回一个指向新逻辑末尾的迭代器。真正的删除操作，也就是改变容器大小，需要容器自身的

erase

成员函数来完成。

解决方案

要从C++ STL的序列容器（如

std::vector

或

std::deque

）中删除所有满足特定条件的元素，你需要结合使用

std::remove

（或

std::remove_if

）算法和容器的

erase

成员函数。这个过程通常分为两步：

逻辑移除： 使用
```
std::remove
```
或
```
std::remove_if
```
算法。这两个算法会遍历指定范围内的元素，将所有不满足移除条件的元素“移动”到范围的前部，并保持它们的相对顺序。所有满足移除条件的元素会被移到范围的后部（它们的值是不确定的，但不会被使用）。
```
std::remove
```
会返回一个迭代器，指向新的逻辑末尾，即第一个被“移除”元素的位置。
物理移除： 使用容器的
```
erase
```
成员函数。将
```
std::remove
```
返回的迭代器作为起始，容器的
```
end()
```
迭代器作为结束，调用
```
erase
```
来真正地从容器中删除这些元素，从而改变容器的大小。

下面是一个简单的代码示例，演示如何移除

std::vector

中所有值为

的元素，以及如何移除所有偶数：

#include 
#include  // 包含 std::remove 和 std::remove_if
#include   // 用于输出

int main() {
    // 示例1: 移除所有值为3的元素
    std::vector numbers = {1, 2, 3, 4, 5, 3, 6, 7, 3, 8};
    std::cout << "原始容器 (移除3): ";
    for (int n : numbers) { std::cout << n << " "; }
    std::cout << std::endl;

    // 第一步: 逻辑移除。std::remove 将所有非3的元素前移。
    // 它返回一个迭代器，指向第一个被“移除”的元素（即第一个3所在的新位置）。
    auto new_end_iter = std::remove(numbers.begin(), numbers.end(), 3);

    // 此时容器内部可能看起来像 {1, 2, 4, 5, 6, 7, 8, ?, ?, ?}
    // new_end_iter 指向第一个问号的位置。
    // 注意：容器的大小在这一步并没有改变。

    // 第二步: 物理移除。使用 erase 成员函数删除从 new_end_iter 到 end() 的所有元素。
    numbers.erase(new_end_iter, numbers.end());

    std::cout << "移除3后: ";
    for (int n : numbers) { std::cout << n << " "; }
    std::cout << std::endl;
    std::cout << "容器大小: " << numbers.size() << std::endl;

    std::cout << "-----------------------------------" << std::endl;

    // 示例2: 移除所有偶数 (使用 std::remove_if)
    std::vector another_numbers = {10, 21, 30, 41, 50, 61, 70, 81};
    std::cout << "原始容器 (移除偶数): ";
    for (int n : another_numbers) { std::cout << n << " "; }
    std::cout << std::endl;

    // 使用 lambda 表达式作为谓词，判断是否为偶数
    auto new_end_iter_if = std::remove_if(another_numbers.begin(), another_numbers.end(),
                                          [](int n){ return n % 2 == 0; });

    another_numbers.erase(new_end_iter_if, another_numbers.end());

    std::cout << "移除偶数后: ";
    for (int n : another_numbers) { std::cout << n << " "; }
    std::cout << std::endl;
    std::cout << "容器大小: " << another_numbers.size() << std::endl;

    return 0;
}

为什么直接使用

std::remove

无法从容器中彻底删除元素？

这其实是C++标准库设计哲学的一个体现，尤其是在算法和容器的分离上。

std::remove

（以及

std::remove_if

）是一个通用的算法，它被设计成可以作用于任何迭代器范围，而不仅仅是特定的STL容器。这意味着它不能、也不应该知道底层数据结构（比如

std::vector

或

std::list

）的具体实现细节，更不能直接调用容器的成员函数来改变其大小或管理内存。

立即学习“C++免费学习笔记（深入）”；

std::remove

的工作方式更像是“整理”或“压缩”一个序列。它会遍历你给定的迭代器范围，然后将那些你不想移除的元素，通过移动赋值（move assignment）的方式，依次放到范围的前面。那些被“移除”的元素，实际上只是被移到了范围的末尾，它们原来的位置被其他元素覆盖了，但它们本身仍然存在于内存中，并且占据着容器的一部分空间。

std::remove

返回的迭代器，指向的就是这个“新逻辑末尾”的开始位置，也就是第一个被“移除”元素的当前位置。

所以，如果你只调用

std::remove

，容器的物理大小（

capacity()

和

size()

）是不会改变的。你只是在逻辑上将需要保留的元素“前置”了。为了真正释放这些元素占据的内存，并更新容器的实际大小，你必须调用容器自身的

erase

成员函数，用

std::remove

返回的迭代器作为起点，容器的

end()

迭代器作为终点，来完成物理上的删除。这是因为只有容器自己才知道如何正确地释放其管理的内存，并调整其内部状态。

在哪些STL容器上使用

erase-remove

惯用法最为有效？

erase-remove

惯用法在序列容器，尤其是

std::vector

和

std::deque

上表现得最为有效。

std::vector
: 这是
```
erase-remove
```
的经典应用场景。
```
std::vector
```
的元素是连续存储的，
```
std::remove
```
在移动元素时效率很高（通常是
```
memmove
```
或等效操作）。随后的
```
vector::erase
```
操作会删除范围内的元素，并调整容器大小，由于是删除一个连续的子范围，效率也相对较高。对于
```
std::vector
```
来说，它避免了在循环中逐个删除元素可能导致的多次内存重分配和大量元素移动，从而显著提升性能。
std::deque
:
```
std::deque
```
的元素虽然不是完全连续存储，但它内部由多个块组成，
```
std::remove
```
在
```
std::deque
```
上同样能有效地移动元素。
```
deque::erase
```
也能够高效地处理范围删除。因此，
```
erase-remove
```
惯用法在
```
std::deque
```
上也是一个非常好的选择。
std::string
:
```
std::string
```
在很多方面行为类似于
```
std::vector
```
，因此
```
erase-remove
```
惯用法同样适用于
```
std::string
```
，用来移除特定的字符。
std::list
: 虽然技术上你也可以在
```
std::list
```
上使用
```
erase-remove
```
，但这不是一个推荐的做法，效率也比较低。
```
std::list
```
是一个双向链表，它的元素不连续存储。
```
std::remove
```
在链表上移动元素时，实际上是进行一系列的节点指针操作，效率尚可。但关键在于，
```
std::list::erase
```
删除一个范围内的元素，对于链表来说，删除每个节点都需要单独的指针操作。更重要的是，
```
std::list
```
本身提供了成员函数
list::remove
和
list::remove_if
，这些成员函数是专门为链表优化的，它们能够以O(N)的复杂度直接删除所有满足条件的节点，而不需要先“移动”再“擦除”。所以，对于
```
std::list
```
，直接使用其成员函数是更优、更自然的方案。

对于关联容器（如

std::map

std::set

std::unordered_map

std::unordered_set

），

erase-remove

惯用法是完全不适用的。这些容器的元素是根据键值有序或哈希存储的，

std::remove

算法（它依赖于元素的移动）根本无法应用于它们。关联容器通常有自己的

erase

成员函数，可以通过迭代器、键值或范围来删除元素。例如，在

std::map

中，你可以通过遍历并判断条件来删除元素，但需要特别注意迭代器失效问题。

Grokipedia

xAI推出的AI在线百科全书

下载

除了

erase-remove

，处理容器元素删除还有哪些替代方案或注意事项？

除了

erase-remove

惯用法，处理容器元素删除还有几种方式，每种都有其适用场景和需要注意的地方：

容器的成员函数
```
remove
```
/
remove_if
(针对
std::list
和
std::forward_list
)
- 描述： 如前所述，
```
std::list
```
  和
```
std::forward_list
```
  作为链表结构，提供了专门的
```
remove(value)
```
  和
```
remove_if(predicate)
```
  成员函数。这些函数直接操作链表节点，高效地将满足条件的节点从链表中移除，并自动调整容器大小。
- 优点： 效率高，代码简洁，针对链表结构做了优化。
- 缺点： 仅适用于
```
std::list
```
  和
```
std::forward_list
```
  。
- 示例：
```
myList.remove(3);
```
  或
```
myList.remove_if([](int n){ return n % 2 == 0; });
```
关联容器的
```
erase
```
成员函数 (针对
std::map
,
std::set
等)
- 描述： 关联容器（如
```
std::map
```
  ,
```
std::set
```
  ,
```
std::unordered_map
```
  ,
```
std::unordered_set
```
  ）通常提供多种重载的
```
erase
```
  成员函数，可以按键值、迭代器或迭代器范围删除元素。
- 优点： 直接、高效，符合关联容器的特性。
- 注意事项： 在循环中通过迭代器删除元素时，需要特别小心迭代器失效问题。通常的做法是，
```
erase
```
  成员函数会返回一个指向被删除元素之后的新迭代器，你应该使用这个返回的迭代器继续循环。
- 示例：
```
std::map myMap = {{1, "one"}, {2, "two"}, {3, "three"}};
// 按键删除
myMap.erase(2);
// 遍历删除（安全做法）
for (auto it = myMap.begin(); it != myMap.end(); ) {
    if (it->first % 2 != 0) { // 删除奇数键
        it = myMap.erase(it); // erase 返回下一个有效迭代器
    } else {
        ++it;
    }
}
```
```
std::unique
```
与
erase
结合 (用于移除连续重复元素)
- 描述： 如果你的目标是移除容器中连续的重复元素（只保留一个），可以使用
```
std::unique
```
  算法。它会将不重复的元素前移，返回一个指向新逻辑末尾的迭代器，然后你再用
```
erase
```
  来物理删除。
- 注意事项：
```
std::unique
```
  只处理连续重复的元素。如果元素不连续，你需要先对容器进行排序（
```
std::sort
```
  ），然后再使用
```
std::unique
```
  。
- 示例：
```
numbers.erase(std::unique(numbers.begin(), numbers.end()), numbers.end());
```
手动循环删除 (需要注意迭代器失效)
- 描述： 对于某些特殊情况或自定义容器，你可能需要手动循环并逐个删除元素。
- 注意事项： 这是最容易出错的方式，尤其是在
```
std::vector
```
  和
```
std::deque
```
  等容器上。当你在循环中删除一个元素时，该元素之后的迭代器都可能失效。安全的做法是，在删除元素后，使用
```
erase
```
  返回的下一个有效迭代器继续循环，或者在删除后不递增迭代器（因为
```
erase
```
  已经将下一个元素移到了当前位置）。
- 示例 (适用于
  std::vector
  ，但不如
  erase-remove
  惯用法高效)：
```
// 这种方式效率较低，因为每次 erase 都可能导致大量元素移动
for (auto it = numbers.begin(); it != numbers.end(); ) {
    if (*it == 3) {
        it = numbers.erase(it); // erase 返回下一个有效迭代器
    } else {
        ++it;
    }
}
```
  对于
```
std::vector
```
  和
```
std::deque
```
  ，这种逐个删除的方式通常比
```
erase-remove
```
  慢得多，因为它可能导致多次元素移动。