In our previous lesson, we explored the C++ standard library's removal algorithms and the remove-erase idiom. This pattern is a common technique for purging elements from a container.

As a quick refresher, the remove-erase idiom is a two-step process:

Use an algorithm like std::ranges::remove() or std::ranges::remove_if() to shift all the elements you want to keep to the beginning of the container. These algorithms return a subrange representing the "excess" elements at the end of the container that now need to be erased.
Use this return value alongside container-specific algorithms (such as the erase() member function on a std::vector) to erase the unwanted elements.

Here's what it looks like in practice with std::ranges::remove() and a std::vector:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5void PrintVector(const std::vector<int>&){/*...*/}
13
14int main() {
15  std::vector Numbers{1, 2, 3, 2, 4, 2, 5};
16
17  // Step 1: "Remove" all 2s
18  auto Removed{std::ranges::remove(Numbers, 2)};
19
20  std::cout << "After remove: ";
21  PrintVector(Numbers);
22
23  // Step 2: Actually erase them
24  Numbers.erase(Removed.begin(), Removed.end());
25
26  std::cout << "After erase:  ";
27  PrintVector(Numbers);
28}

1After remove: 1 3 4 5 4 2 5 
2After erase:  1 3 4 5

This is quite clunky. It's verbose, requiring two separate statements to do one conceptual thing. Even worse, it's easy to forget the second step, leaving your container in a valid but potentially confusing state with zombie data lingering at the end.

C++20 has ridden to the rescue with a much simpler, safer, and more expressive solution: std::erase() and std::erase_if().

These functions wrap up the remove-erase idiom into a single, clean function call.

Erasing with `std::erase()`

The std::erase() function is the simplest way to remove all occurrences of a specific value from a container. It takes two arguments:

A reference to the container you want to modify.
The value to remove.

Let's refactor our previous example to use this modern C++20 approach.

main.cpp (After)

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5void PrintVector(const std::vector<int>&){/*...*/}
12
13int main() {
14  std::vector Numbers{1, 2, 3, 2, 4, 2, 5};
15
16  auto Removed{std::ranges::remove(Numbers, 2)};
17  Numbers.erase(Removed.begin(), Removed.end());
18  std::erase(Numbers, 2);
19
20  std::cout << "After erase:  ";
21  PrintVector(Numbers);
22}

The end result for both versions is identical:

1After erase:  1 3 4 5

Where are `std::erase()` and `std::erase_if()` Defined?

Unlike most algorithms that live in the <algorithm> header, these new removal functions are defined in the header for the container they operate on.

To use std::erase() on a vector you need to #include <vector>.
To use std::erase() on a string you need to #include <string>.
To use std::erase() on a list you need to #include <list>.

And so on. This might seem a bit unusual, but it's because these functions are tightly coupled to the specific design of the container that implements it. For example, the algorithm to remove elements from an array like a std::vector is quite different to what would be needed for a linked list like std::list.

The new std::erase_if() overloaded functions are also defined in their respective headers (<vector>, <list>, etc.), which we'll cover later in this lesson.

Return Value of `std::erase()`

The std::erase() function returns the number of elements that were removed. This is a size_type of the container (usually an unsigned integer type like size_t). This can be handy for logging, validation, or further logic.

Let's see an example using a different sequential container - a std::string:

1#include <iostream>
2#include <string>
3
4int main() {
5  std::string Text{
6    "Hello, world! It's a wonderful world!"
7  };
8  std::cout << "Original: " << Text;
9
10  size_t RemovedCount = std::erase(Text, 'w');  
11
12  std::cout << "\nModified: " << Text;
13  std::cout << "\nRemoved " << RemovedCount
14    << " 'w' characters.\n";
15}

1Original: Hello, world! It's a wonderful world!
2Modified: Hello, orld! It's a onderful orld!
3Removed 3 'w' characters.

Erasing with `std::erase_if()`

Just as std::erase() simplifies remove-erase, std::erase_if() simplifies remove_if-erase. It allows us to remove elements from a container based on a condition, or predicate.

It takes two arguments:

A reference to the container.
A predicate that takes an element from the container and returns true if it should be removed. This predicate is usually provided using a .

Let's say we want to remove all even numbers from a vector. Here's the old way vs. the new way:

Files

main.cpp (Before)

main.cpp (After)

Select a file to view its content

The result is the same, but the std::erase_if() approach is far more elegant.

1Final vector: 1 3 5 7

Like std::erase(), std::erase_if() also returns the number of elements it removed. Let's see it in a more complex example, where we're managing a list of players and want to remove those who are inactive.

1#include <iostream>
2#include <string>
3#include <vector>
4
5struct Player {
6  std::string Name;
7  bool isActive;
8};
9
10int main() {
11  std::vector<Player> Players{
12    {"Alice", true}, {"Bob", false},
13    {"Charlie", true}, {"David", false},
14    {"Eve", true}
15  };
16
17  size_t RemovedCount{
18    std::erase_if(
19      Players,
20      [](const Player& P){ return !P.isActive; }
21    )
22  };
23
24  std::cout << "Removed " << RemovedCount
25    << " inactive players\n";
26
27  std::cout << "Active players:\n";
28  for (const auto& p : Players) {
29    std::cout << "- " << p.Name << '\n';
30  }
31}

1Removed 2 inactive players
2Active players:
3- Alice
4- Charlie
5- Eve

Using `std::erase_if()` with Sets and Maps

So far, we've focused on sequence containers like std::vector and std::string. What about associative containers like maps and sets?

Erasing from Maps

Before C++20, removing elements from a map (like a std::map or std::unordered_map) based on a condition was a bit tricky. You had to write a manual loop, being very careful with how you handled iterators to avoid invalidating them.

C++20's std::erase_if() overload for maps makes this trivial. Given maps are collections of std::pair objects, the predicate for the map's std::erase_if() implementation also receives a std::pair.

Let's see an example where we remove all entries from a map of high scores if the score is below a certain threshold. This example uses a std::map, but std::erase_if() is also available for std::unordered_map and std::multimap:

1#include <iostream>
2#include <map>
3#include <string>
4
5using Scores = std::map<std::string, int>;
6
7void PrintMap(const Scores&) {/*...*/}
13
14int main() {
15  Scores HighScores{
16    {"Alice", 1500},
17    {"Bob", 99},
18    {"Charlie", 1200},
19    {"David", 75}
20  };
21
22  std::cout << "--- Before ---\n";
23  PrintMap(HighScores);
24
25  // Erase if the score (the pair's second
26  // element) is < 100
27  size_t RemovedCount{
28    std::erase_if(
29      HighScores, [](const auto& item){
30        auto const& [name, score] = item;
31        return score < 100;
32      }
33    )
34  };
35
36  std::cout << "\n--- After ---\n";
37  PrintMap(HighScores);
38  std::cout << "Removed " << RemovedCount
39    << " entries.\n";
40}

1--- Before ---
2Alice: 1500
3Bob: 99
4Charlie: 1200
5David: 75
6
7--- After ---
8Alice: 1500
9Charlie: 1200
10Removed 2 entries.

Erasing from Sets

Standard library sets like std::set and std::unordered_set also benefit from the new std::erase_if() approach. In this case, the predicate for a set simply takes the element type rather than a std::pair.

Below, we have a set of strings, and we remove any that are shorter than 4 characters. We're using a std::map but std::erase_if() overloads are also available for std::unordered_set and std::multiset:

1#include <iostream>
2#include <set>
3#include <string>
4
5int main() {
6  std::set<std::string> Players{
7    "Bob", "Alice", "Kevin", "David"
8  };
9
10  std::cout << "Original players: ";
11  for (const auto& Player : Players) {
12    std::cout << Player << " ";
13  }
14
15  size_t RemovedCount{std::erase_if(
16    Players,
17    [](const std::string& Player){
18      return Player.length() < 4;
19    }
20  )};
21
22  std::cout << "\nRemoved " << RemovedCount
23    << " player\n";
24
25  std::cout << "Updated players: ";
26  for (const auto& Player : Players) {
27    std::cout << Player << " ";
28  }
29}

1Original players: Alice Bob David Kevin
2Removed 1 player
3Updated players: Alice David Kevin

Summary

The addition of std::erase() and std::erase_if() in C++20 is a quality-of-life improvement for developers. It takes a common, slightly cumbersome, and error-prone idiom and transforms it into a simple, expressive, and safe operation.

Whenever you find yourself needing to remove elements from a standard container, your first thought should be to reach for these new tools. They make your code cleaner, your intent clearer, and your programs more robust.

In this lesson, we've covered:

How std::erase() and std::erase_if() simplify the classic remove-erase idiom for sequence containers.
The syntax, usage, and return values for these new functions.
The significant benefits in code conciseness, readability, and safety.
The fact that these new functions offer these benefits with no performance cost.
The new std::erase_if() function overloads added to associative containers for equally simple and safe conditional removal.

Using `std::erase()` and `std::erase_if()`

Erasing with `std::erase()`

main.cpp (After)

Return Value of `std::erase()`

Erasing with `std::erase_if()`

Files

Using `std::erase_if()` with Sets and Maps

Erasing from Maps

Erasing from Sets

Summary

Replacement Algorithms

Professional C++

Using std::erase() and std::erase_if()

Erasing with std::erase()

main.cpp (After)

Return Value of std::erase()

Erasing with std::erase_if()

Files

Using std::erase_if() with Sets and Maps

Erasing from Maps

Erasing from Sets

Summary

Replacement Algorithms

Using `std::erase()` and `std::erase_if()`

Erasing with `std::erase()`

Return Value of `std::erase()`

Erasing with `std::erase_if()`

Using `std::erase_if()` with Sets and Maps