C++ 使用统一擦除函数从容器中删除项目

使用统一擦除函数从容器中删除项目

在 C++20 之前，erase-remove 惯用法通常用于高效地从 STL 容器中删除元素。这有点繁琐，但并不是很大的负担。通常使用以下函数来执行此任务：

template<typename Tc, typename Tv>
void remove_value(Tc & c, const Tv v) {
    auto remove_it = std::remove(c.begin(), c.end(), v);
    c.erase(remove_it, c.end());
}

std::remove() 函数来自 <algorithms> 头文件。std::remove() 搜索指定的值，并通过从容器末尾向前移动元素来移除它。它不改变容器的大小。它返回一个指向移动范围末尾的迭代器。然后我们调用容器的 erase() 函数来删除剩余的元素。

现在，使用新的统一擦除函数，这个两步过程可以简化为一步：

std::erase(c, 5); // 与上面的 remove_value() 函数相同

这个单一函数调用与我们上面编写的 remove_value() 函数做了相同的事情。

还有一个版本使用谓词函数。例如，要从数值容器中删除所有偶数元素：

std::erase_if(c, [](auto x) { return x % 2 == 0; });

让我们更详细地看看统一擦除函数。

如何做到这一点…

统一擦除函数有两种形式。第一种形式称为 erase()，接受两个参数，一个容器和一个值：

erase(container, value);

容器可以是任何顺序容器（向量、列表、forward_list、deque），除了不能改变大小的数组。

第二种形式称为 erase_if()，接受一个容器和一个谓词函数：

erase_if(container, predicate);

这种形式适用于与 erase() 兼容的任何容器，加上关联容器，集合、映射和它们的多键和无序变体。

erase() 和 erase_if() 函数定义为非成员函数，在相应容器的头文件中定义。不需要包含另一个头文件。

让我们看一些例子：

首先，我们定义一个简单的函数来打印顺序容器的大小和元素：

void printc(auto & r) {
    cout << format("size({}) ", r.size());
    for( auto & e : r ) cout << format("{} ", e);
    cout << "\n";
}

printc() 函数使用 C++20 的 format() 函数为 cout 格式化字符串。

这是一个包含 10 个整数元素的向量，用我们的 printc() 函数打印：

vector v{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
printc(v);

输出：

size: 10: 1 2 3 4 5 6 7 8 9

我们看到向量有 10 个元素。现在我们可以使用 erase() 来删除所有值为 5 的元素：

erase(v, 5);
printc(v);

输出：

size: 9: 1 2 3 4 6 7 8 9

std::erase() 函数的向量版本在 <vector> 头文件中定义。erase() 调用后，值为 5 的元素已被删除，向量有 9 个元素。

这在列表容器上同样有效：

list l{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
printc(l);
erase(l, 5);
printc(l);

输出：

size: 10: 0 1 2 3 4 5 6 7 8 9
size: 9: 0 1 2 3 4 6 7 8 9

std::erase() 函数的列表版本在 <list> 头文件中定义。erase() 调用后，值为 5 的元素已被删除，列表有 9 个元素。

我们可以使用 erase_if() 来删除所有偶数元素，使用一个简单的谓词函数：

vector v{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
printc(v);
erase_if(v, [](auto x) { return x % 2 == 0; });
printc(v);

输出：

size: 10: 0 1 2 3 4 5 6 7 8 9
size: 5: 1 3 5 7 9

erase_if() 函数也适用于关联容器，如映射：

void print_assoc(auto& r) {
    cout << format("size: {}: ", r.size());
    for( auto& [k, v] : r ) cout << format("{}:{} ", k, v);
    cout << "\n";
}

int main() {
    map<int, string> m{ {1, "uno"}, {2, "dos"},
        {3, "tres"}, {4, "quatro"}, {5, "cinco"} };
    print_assoc(m);
    erase_if(m,
        [](auto& p) { auto& [k, v] = p;
            return k % 2 == 0;
        }
    );
    print_assoc(m);
}

输出：

size: 5: 1:uno 2:dos 3:tres 4:quatro 5:cinco
size: 3: 1:uno 3:tres 5:cinco

因为映射的每个元素都作为一对返回，我们需要一个不同的函数来打印它们。print_assoc() 函数在 for 循环中使用结构化绑定解包一对元素。我们还在 erase_if() 的谓词函数中使用结构化绑定来隔离用于过滤偶数元素的键。

它是如何工作的…

erase() 和 erase_if() 函数是简单的包装器，它们执行一步 erase-remove 惯用法。它们执行与以下函数相同的操作：

template<typename Tc, typename Tv>
void remove_value(Tc & c, const Tv v) {
    auto remove_it = std::remove(c.begin(), c.end(), v);
    c.erase(remove_it, c.end());
}

如果我们考虑一个简单的 int 向量，称为 vec，具有以下值：

vector vec{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

我们可以将 vec 可视化为一个 int 值的单行表：

begin() 迭代器指向第一个元素，end() 迭代器指向最后一个元素之后。这是所有 STL 顺序容器的标准配置。

当我们调用 remove(c.begin(), c.end(), 5) 时，算法从 begin() 迭代器开始搜索匹配的元素。对于它找到的每个匹配元素，它将下一个元素移入其位置。它继续搜索和移动，直到到达 end() 迭代器。结果是容器中所有剩余的元素都在开头，没有被删除的元素，并保持其原始顺序。end() 迭代器保持不变，剩余的元素是未定义的。我们可以这样可视化操作：

remove() 函数返回一个迭代器（remove_it），指向第一个被移动的元素之后的元素。end() 迭代器在 remove() 操作之前和之后保持不变。为了进一步说明，如果我们要使用 remove_if() 删除所有偶数元素，我们的结果是：

在这种情况下，剩下的是五个奇数元素，后面是五个未定义值的元素。

然后调用容器的 erase() 函数来擦除剩余的元素：

c.erase(remove_it, c.end());

使用 remove_it 和 end() 迭代器调用容器的 erase() 函数，以删除所有未定义的元素。

erase() 和 erase_if() 函数调用 remove() 函数和容器的 erase() 函数，以一步执行 erase-remove 惯用法。