如何在C++中从vector中删除一个元素_C++ vector元素删除操作详解-C++-PHP中文网

C++中删除vector元素需注意迭代器失效，推荐使用erase配合remove或remove_if实现高效删除，避免直接遍历删除导致未定义行为。

如何在c++中从vector中删除一个元素_c++ vector元素删除操作详解

在C++中，从

std::vector

登录后复制

中删除元素并非简单地按个键就能完成，它涉及几种不同的策略，核心在于理解迭代器失效和容器底层机制。最常见且推荐的方法是利用

vector::erase

登录后复制

函数，通常会配合

std::remove

登录后复制

或

std::remove_if

登录后复制

来高效地移除特定值，或者直接通过迭代器移除特定位置的元素。这其中，对迭代器生命周期的把握是关键，否则很容易掉进各种“坑”里。

解决方案

从

std::vector

登录后复制

中删除元素，我们通常会用到以下几种主要方法：

通过迭代器或位置删除单个或一段元素：

vector

登录后复制

的

erase

登录后复制

方法是直接删除元素的利器。它可以接受一个迭代器来删除单个元素，或者接受一对迭代器来删除一个范围内的元素。当

erase(iterator)

登录后复制

被调用时，它会删除

iterator

登录后复制

指向的元素，并将该元素之后的所有元素向前移动一位，然后返回一个指向被删除元素之后的新位置的迭代器。所有指向被删除元素之后位置的迭代器都会失效。而

erase(first, last)

登录后复制

则会删除从

first

登录后复制

到

last

登录后复制

（不包含

last

登录后复制

）范围内的所有元素，同样会返回一个指向新范围末尾之后位置的迭代器，并使后续迭代器失效。

#include <vector>
#include <iostream>
#include <algorithm> // for std::find

void print_vector(const std::vector<int>& vec, const std::string& msg = "") {
    std::cout << msg;
    for (int x : vec) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> nums = {10, 20, 30, 40, 50};
    print_vector(nums, "原始vector: "); // 10 20 30 40 50

    // 删除特定位置的元素 (例如，删除第三个元素 30)
    // 注意：vector的索引从0开始，所以第三个元素是索引2
    auto it_to_erase = nums.begin() + 2; // 指向30
    nums.erase(it_to_erase);
    print_vector(nums, "删除索引2元素后: "); // 10 20 40 50

    // 删除一段范围的元素 (例如，删除 20 和 40)
    // 找到20的位置
    auto it_start = std::find(nums.begin(), nums.end(), 20);
    // 找到40的位置 (如果40存在且在20之后)
    auto it_end = std::find(nums.begin(), nums.end(), 40);
    if (it_start != nums.end() && it_end != nums.end()) {
        nums.erase(it_start, it_end); // 删除从20到40（不含40）
    }
    print_vector(nums, "删除20到40（不含40）后: "); // 10 40 50 (如果之前是10 20 40 50，这里会删除20)
                                                // 实际上，由于40是下一个元素，它会删除20
                                                // 让我们重新演示一个更清晰的范围删除
    nums = {10, 20, 30, 40, 50, 60};
    print_vector(nums, "重新初始化vector: "); // 10 20 30 40 50 60
    // 删除从索引1 (20) 到索引4 (50) 之间的元素，不包含索引4 (即删除 20, 30, 40)
    nums.erase(nums.begin() + 1, nums.begin() + 4);
    print_vector(nums, "删除索引1到4（不含4）后: "); // 10 50 60
}

登录后复制

通过值删除（“remove-erase”惯用法）： 如果你想删除所有值为特定
```
X
```
登录后复制
的元素，直接遍历并用
```
erase
```
登录后复制
删除效率不高，而且容易出错。C++标准库提供了一个更优雅、高效的惯用法：
```
std::remove
```
登录后复制
配合
```
vector::erase
```
登录后复制
。
```
std::remove
```
登录后复制
并不会真正删除元素，它会将所有不等于目标值的元素“移动”到
```
vector
```
登录后复制
的前部，并返回一个迭代器，指向新的逻辑“末尾”。这个新的逻辑末尾之后的所有元素都是“待删除”的冗余元素。
```
vector::erase
```
登录后复制
接着被用来删除从这个新的逻辑末尾到
```
vector
```
登录后复制
实际末尾之间的所有元素。
```
#include <vector>
#include <iostream>
#include <algorithm> // for std::remove

int main() {
    std::vector<int> nums = {10, 20, 30, 20, 40, 50, 20};
    print_vector(nums, "原始vector: "); // 10 20 30 20 40 50 20

    // 删除所有值为20的元素
    // std::remove 将所有非20的元素移到前面，并返回新逻辑末尾的迭代器
    auto new_end = std::remove(nums.begin(), nums.end(), 20);
    // erase 删除从 new_end 到 nums.end() 之间的元素
    nums.erase(new_end, nums.end());
    print_vector(nums, "删除所有20后: "); // 10 30 40 50
}
```
登录后复制

条件删除（

std::remove_if

登录后复制

配合
vector::erase
登录后复制
）：如果你想根据某个条件来删除元素，

std::remove_if

登录后复制

是

std::remove

登录后复制

的泛化版本。它接受一个谓词（一个返回

bool

登录后复制

的函数或lambda表达式），删除所有使谓词返回

true

登录后复制

的元素。

#include <vector>
#include <iostream>
#include <algorithm> // for std::remove_if

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    print_vector(nums, "原始vector: "); // 1 2 3 4 5 6 7 8 9 10

    // 删除所有偶数
    auto new_end = std::remove_if(nums.begin(), nums.end(), [](int n){
        return n % 2 == 0; // 谓词：如果是偶数则返回true
    });
    nums.erase(new_end, nums.end());
    print_vector(nums, "删除所有偶数后: "); // 1 3 5 7 9
}

登录后复制

当顺序不重要时，更高效的删除单个元素： 如果你只需要删除一个特定元素，并且

vector

登录后复制

中元素的相对顺序不重要，那么可以采用一个非常高效的技巧：将要删除的元素与

vector

登录后复制

的最后一个元素交换，然后

pop_back

登录后复制

删除最后一个元素。这种方法的时间复杂度是O(1)，而

erase

登录后复制

通常是O(N)。

#include <vector>
#include <iostream>
#include <algorithm> // for std::find

int main() {
    std::vector<int> nums = {10, 20, 30, 40, 50};
    print_vector(nums, "原始vector: "); // 10 20 30 40 50

    // 假设要删除元素30，但顺序不重要
    auto it = std::find(nums.begin(), nums.end(), 30);
    if (it != nums.end()) {
        *it = nums.back(); // 将最后一个元素的值赋给要删除的元素
        nums.pop_back();   // 删除最后一个元素
    }
    print_vector(nums, "删除30（顺序不重要）后: "); // 10 20 50 40 (或 10 20 40 50，取决于具体实现，但30肯定没了)
                                                // 实际输出会是 10 20 50 40
}

登录后复制

为什么直接遍历并删除元素会导致问题？

这几乎是所有C++新手在处理

vector

登录后复制

删除时会踩的第一个“坑”。当我刚开始学习C++时，也曾天真地以为，像其他语言那样，一个简单的循环加上删除操作就能搞定。然而，

std::vector

登录后复制

的底层机制决定了这种做法是危险且错误的。

核心问题在于迭代器失效。当

vector::erase()

登录后复制

被调用时，它会删除指定位置的元素，并将其后的所有元素向前移动以填补空缺。这意味着：

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

被删除元素之后的所有迭代器都会失效。 它们不再指向原来的元素，甚至可能指向无效的内存地址。
```
erase()
```
登录后复制
函数会返回一个指向被删除元素之后的新位置的迭代器。这是关键！

如果你在一个

for

登录后复制

循环中，例如

for (auto it = vec.begin(); it != vec.end(); ++it)

登录后复制

，然后在这个循环体内部调用

vec.erase(it)

登录后复制

，那么

it

登录后复制

在

erase

登录后复制

操作后就失效了。接着，

++it

登录后复制

尝试递增一个失效的迭代器，这会导致未定义行为（Undefined Behavior）。程序可能会崩溃，或者在某些情况下看似正常运行，但结果是错误的，这比直接崩溃更难调试。

错误示例：

#include <vector>
#include <iostream>

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
    std::cout << "原始vector: ";
    for (int n : nums) std::cout << n << " ";
    std::cout << std::endl;

    // 尝试删除所有偶数（错误的方式）
    for (auto it = nums.begin(); it != nums.end(); ++it) {
        if (*it % 2 == 0) {
            nums.erase(it); // 此时it失效
            // 问题：下一个循环迭代会尝试递增一个失效的it，导致未定义行为
            // 如果不加处理，甚至可能跳过下一个元素
        }
    }
    // 实际运行可能会崩溃，或者输出错误结果
    std::cout << "删除偶数后（错误方式）: ";
    for (int n : nums) std::cout << n << " ";
    std::cout << std::endl; // 结果通常不正确或崩溃
    return 0;
}

登录后复制

正确的处理方式： 始终使用

erase

登录后复制

返回的新迭代器。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6};
    std::cout << "原始vector: ";
    for (int n : nums) std::cout << n << " ";
    std::cout << std::endl;

    // 正确删除所有偶数的方式 (虽然效率不如remove-erase，但可以这样操作)
    for (auto it = nums.begin(); it != nums.end(); ) { // 注意这里没有 ++it
        if (*it % 2 == 0) {
            it = nums.erase(it); // erase返回指向下一个元素的有效迭代器
        } else {
            ++it; // 如果没有删除，则正常前进
        }
    }
    std::cout << "删除偶数后（正确方式）: ";
    for (int n : nums) std::cout << n << " ";
    std::cout << std::endl; // 1 3 5
    return 0;
}

登录后复制

即便如此，这种在循环中频繁调用

erase

登录后复制

的方式，对于删除大量元素而言，效率依然不高，因为它每次删除都会导致后续元素的移动。这正是“remove-erase”惯用法存在的价值。

std::remove

登录后复制

和

vector::erase

登录后复制

组合使用的精髓是什么？

std::remove

登录后复制

和

vector::erase

登录后复制

的组合，也就是我们常说的“remove-erase idiom”，是C++标准库中最优雅、最惯用也通常是最有效率的删除

vector

登录后复制

中特定值（或满足特定条件）元素的策略。它的精髓在于将元素的“逻辑删除”与容器的“物理删除”分离开来，从而优化性能并避免迭代器失效的复杂性。

std::remove

登录后复制

的本质：移动而非删除

知我AI·PC客户端

离线运行 AI 大模型，构建你的私有个人知识库，对话式提取文件知识，保证个人文件数据安全

查看详情

首先要明确，

std::remove

登录后复制

（或

std::remove_if

登录后复制

）本身不会改变容器的大小。它做的事情是：

遍历指定范围内的元素。
将所有“不满足删除条件”的元素（即需要保留的元素）移动到范围的前部。
返回一个迭代器，指向新的逻辑“尾部”。这个迭代器以及它之后的所有元素，都是“待删除”的冗余元素，它们的值是不确定的，但它们占据着原来的内存空间。

想象一下，你有一排书，想把所有红色的书扔掉。

std::remove

登录后复制

不会真的扔掉书，它会把所有非红色的书挪到书架的前面，然后告诉你：“看，这些是你要留下的书，从这里开始，后面都是你要扔的。”那些“要扔的书”还在书架上，只是被推到了后面，而且可能被其他书的内容覆盖了。

vector::erase

登录后复制

的收尾工作：物理删除

std::remove

登录后复制

返回的迭代器，正是

vector::erase

登录后复制

所需要的起点。

vector::erase(new_end, nums.end())

登录后复制

会真正地：

销毁从
```
new_end
```
登录后复制
到
```
nums.end()
```
登录后复制
之间的所有元素对象。
调整
```
vector
```
登录后复制
的实际大小（
```
size()
```
登录后复制
会减小）。
释放这部分元素所占用的内存（如果需要）。

通过这种分工，

std::remove

登录后复制

只需要进行一次遍历和移动操作（线性时间复杂度O(N)），而

vector::erase

登录后复制

则负责一次性地截断容器。相比于在循环中频繁调用

erase

登录后复制

（每次

erase

登录后复制

都可能导致大量元素的移动，最坏情况下是O(N^2)），这种组合方式通常效率更高。

示例再次强调：

#include <vector>
#include <iostream>
#include <algorithm> // for std::remove

int main() {
    std::vector<int> data = {1, 5, 2, 5, 3, 5, 4};
    print_vector(data, "原始数据: "); // 1 5 2 5 3 5 4

    // 假设我们要删除所有值为5的元素
    // 步骤1: std::remove
    // 它会将 {1, 2, 3, 4, ?, ?, ?} 这样的结构，并返回指向第一个?的迭代器
    auto new_end_it = std::remove(data.begin(), data.end(), 5);
    print_vector(data, "std::remove后 (注意大小不变，但内容已重排): "); // 1 2 3 4 3 5 4 (后面的值是未定义的，取决于实现)
                                                                       // 这里只是一个示例，实际值可能是任何东西，但前四个是正确的

    // 步骤2: vector::erase
    // 它会删除从 new_end_it 到 data.end() 的所有元素
    data.erase(new_end_it, data.end());
    print_vector(data, "std::remove + vector::erase 后: "); // 1 2 3 4
}

登录后复制

这种模式不仅清晰，而且对于

vector

登录后复制

这类连续存储的容器来说，其性能优势是显而易见的。它避免了在中间频繁插入或删除元素所带来的昂贵开销。

删除元素后，对vector的性能和内存有什么影响？

删除

vector

登录后复制

中的元素，其对性能和内存的影响是值得深思的，这不仅仅是“删掉就没了”那么简单。理解这些影响，能帮助我们写出更高效、更内存友好的C++代码。

性能影响：元素的移动开销 当你在
```
vector
```
登录后复制
的中间删除一个元素（或一段元素）时，
```
vector
```
登录后复制
需要将所有被删除元素之后的所有元素向前移动，以保持其连续存储的特性。这个移动操作，在底层通常是内存块的拷贝（例如使用
```
memmove
```
登录后复制
）。
- 单个元素删除 (
  erase(iterator)
  登录后复制
  ): 如果
```
vector
```
  登录后复制
  有N个元素，你在索引
```
i
```
  登录后复制
  处删除一个元素，那么
```
N - 1 - i
```
  登录后复制
  个元素需要被移动。最坏情况下（删除第一个元素），需要移动N-1个元素，时间复杂度是O(N)。
- 范围删除 (
  erase(first, last)
  登录后复制
  ): 如果删除了
```
k
```
  登录后复制
  个元素，那么
```
N - k - (first_index)
```
  登录后复制
  个元素需要被移动。同样，时间复杂度是O(N)。
- remove-erase
  登录后复制
  惯用法:
```
std::remove
```
  登录后复制
  会进行一次遍历和元素的移动，时间复杂度是O(N)。
```
vector::erase
```
  登录后复制
  则是一次性截断，时间复杂度也是O(N)。因此，整个操作的复杂度依然是O(N)，但通常比多次调用
```
erase
```
  登录后复制
  的效率更高，因为元素移动的次数更少。
- pop_back
  登录后复制
  或
  swap
  登录后复制
  +
  pop_back
  登录后复制
  : 这是最高效的删除方式，时间复杂度是O(1)，因为它不涉及任何元素的移动（或者只移动一个元素到末尾）。但前提是元素的顺序不重要。
频繁地在
```
vector
```
登录后复制
中间删除元素，会导致大量的元素移动，这会显著降低程序的性能。如果你的应用场景需要频繁地在中间位置进行插入和删除，那么
```
std::vector
```
登录后复制
可能不是最佳选择，
```
std::list
```
登录后复制
或
```
std::deque
```
登录后复制
可能更合适。
内存影响：容量（Capacity）与大小（Size）
```
vector
```
登录后复制
有
```
size()
```
登录后复制
（实际元素数量）和
```
capacity()
```
登录后复制
（底层分配的内存能容纳的元素数量）两个概念。
- erase
  登录后复制
  操作只会减少
  size()
  登录后复制
  ，通常不会减少
  capacity()
  登录后复制
  。这意味着，即使你删除了`