From f6a5251a24dc2f426597d7cef9806134700a971d Mon Sep 17 00:00:00 2001 From: Kimberley McDowell <8973856+Kimberleyieshaa@users.noreply.github.com> Date: Tue, 9 Dec 2025 08:11:26 -0500 Subject: [PATCH 1/2] added syntax, example & codebyte for erase() function --- .../unordered-set/terms/erase/erase.md | 106 ++++++++++++++++++ 1 file changed, 106 insertions(+) create mode 100644 content/cpp/concepts/unordered-set/terms/erase/erase.md diff --git a/content/cpp/concepts/unordered-set/terms/erase/erase.md b/content/cpp/concepts/unordered-set/terms/erase/erase.md new file mode 100644 index 00000000000..fc18bbdde24 --- /dev/null +++ b/content/cpp/concepts/unordered-set/terms/erase/erase.md @@ -0,0 +1,106 @@ +--- +Title: 'erase()' +Description: 'removes elements from an unordered set' +Subjects: + - 'Computer Science' +Tags: + - 'Methods' + - 'unordered-sets' +CatalogContent: + - 'learn-C++' + - 'paths/computer-science' +--- + +# 'C++ Unordered-sets: erase()' + +The 'erase()' function removes elements from an unordered set. +It can erase a single element by key, a single element by iterator, or a range of elements using two iterators. +Only iterators pointing to erased elements are invalidated; all others remain valid. + +## Syntax + +Erase by Key +``` +size_t erase(const Key& key); +``` + +Erase by Iterator +``` +iterator erase(const_iterator pos); +``` + +Erase a Range of Iterators +``` +iterator erase(const_iterator first, const_iterator last); +``` + +Erase by Key: Removes all elements matching `key` (in an `unordered_set`, that's at most one). Returns the number of elements removed. + +Erase by Iterator: Removes the element at `pos`. Returns an iterator to the element that followed the erased one. + +Erase a Range of Iterators: Removes all elements in the half-open range `[first, last]`. Returns an iterator to the element that followed the last removed one. + +## Example + +```cpp +#include +#include + +int main() { + std::unordered_set numbers = {1, 2, 3, 4, 5}; + + // Erase by key + numbers.erase(3); + + // Erase by iterator + auto it = numbers.find(4); + if (it != numbers.end()) { + numbers.erase(it); + } + + // Erase using a range + auto first = numbers.begin(); + auto last = numbers.find(5); + numbers.erase(first, last); + + for (int n : numbers) { + std::cout << n << " "; // expected output: 5 + } +} +``` +## Codebyte + +The following example creates an `unordered_set`, then demonstrates all three `erase()` overloads: +* Erasing by key +* Erasing by iterators +* Erasing by iterator range + +```codebyte/cpp +#include +#include + +int main() { + std::unordered_set s = {1, 2, 3, 4, 5}; + + // 1. Erase by key + s.erase(3); + // set is now {1, 2, 4, 5} + + // 2. Erase by iterator + auto it = s.find(4); + if (it != s.end()) { + s.erase(it); + } + // set is now {1, 2, 5} + + // 3. Erase by iterator range + auto first = s.begin(); + auto last = s.end(); + // this removes everything in the set + s.erase(first, last); + + // set is now empty + + return 0; +} +``` From 814fa327dbcd2bd52a6f1b615a3c7dc7ed150726 Mon Sep 17 00:00:00 2001 From: Mamta Wardhani Date: Wed, 10 Dec 2025 13:35:00 +0530 Subject: [PATCH 2/2] Revise erase() documentation for clarity and detail Updated the erase() documentation to clarify its functionality and added details about parameters and return values. --- .../unordered-set/terms/erase/erase.md | 151 ++++++++++-------- 1 file changed, 81 insertions(+), 70 deletions(-) diff --git a/content/cpp/concepts/unordered-set/terms/erase/erase.md b/content/cpp/concepts/unordered-set/terms/erase/erase.md index fc18bbdde24..dc00a4a8584 100644 --- a/content/cpp/concepts/unordered-set/terms/erase/erase.md +++ b/content/cpp/concepts/unordered-set/terms/erase/erase.md @@ -1,106 +1,117 @@ --- Title: 'erase()' -Description: 'removes elements from an unordered set' -Subjects: - - 'Computer Science' -Tags: - - 'Methods' - - 'unordered-sets' +Description: 'Removes one or more specified elements from the unordered_set.' +Subjects: + - 'Computer Science' + - 'Game Development' +Tags: + - 'Methods' + - 'Sets' CatalogContent: - - 'learn-C++' - - 'paths/computer-science' + - 'learn-c-plus-plus' + - 'paths/computer-science' --- -# 'C++ Unordered-sets: erase()' - -The 'erase()' function removes elements from an unordered set. -It can erase a single element by key, a single element by iterator, or a range of elements using two iterators. -Only iterators pointing to erased elements are invalidated; all others remain valid. +The **`erase()`** function removes elements from an `unordered_set`. It can erase a single element by key, a single element by iterator, or a range of elements using two iterators, and only iterators pointing to erased elements are invalidated while the rest remain valid. ## Syntax -Erase by Key -``` -size_t erase(const Key& key); -``` +The `erase()` function removes elements from an `unordered_set` in three ways: by key, by iterator, or by a range of iterators: -Erase by Iterator -``` -iterator erase(const_iterator pos); +```pseudo +set.erase(key); // erase by key +set.erase(iterator); // erase by iterator +set.erase(first, last); // erase by range ``` -Erase a Range of Iterators -``` -iterator erase(const_iterator first, const_iterator last); -``` +**Parameters:** + +- `key`: A value of the set’s key type. All elements matching this key are removed (at most one since `unordered_set` stores unique keys). +- `iterator`: An iterator pointing to the element to remove. +- `first`, `last`: A pair of iterators defining the range to erase. Removes all elements in `[first, last)`. -Erase by Key: Removes all elements matching `key` (in an `unordered_set`, that's at most one). Returns the number of elements removed. +**Return value:** -Erase by Iterator: Removes the element at `pos`. Returns an iterator to the element that followed the erased one. +- When erasing by key: returns the number of elements removed, as a `size_type`. +- When erasing by iterator: returns an iterator pointing to the element that follows the erased one. +- When erasing by range: returns an iterator pointing to the element that follows the last erased element. -Erase a Range of Iterators: Removes all elements in the half-open range `[first, last]`. Returns an iterator to the element that followed the last removed one. +## Example 1: Erasing by key, iterator, and range -## Example +In this example the program removes elements using all three `erase()` overloads and prints the remaining contents of the `unordered_set`: ```cpp #include #include int main() { - std::unordered_set numbers = {1, 2, 3, 4, 5}; + std::unordered_set numbers = {1, 2, 3, 4, 5}; - // Erase by key - numbers.erase(3); + // Erase by key + numbers.erase(3); - // Erase by iterator - auto it = numbers.find(4); - if (it != numbers.end()) { - numbers.erase(it); - } + // Erase by iterator + auto it = numbers.find(4); + if (it != numbers.end()) { + numbers.erase(it); + } - // Erase using a range - auto first = numbers.begin(); - auto last = numbers.find(5); - numbers.erase(first, last); + // Erase using a range + auto first = numbers.begin(); + auto last = numbers.find(5); + numbers.erase(first, last); - for (int n : numbers) { - std::cout << n << " "; // expected output: 5 - } + for (int n : numbers) { + std::cout << n << " "; + } + + return 0; } ``` -## Codebyte - -The following example creates an `unordered_set`, then demonstrates all three `erase()` overloads: -* Erasing by key -* Erasing by iterators -* Erasing by iterator range -```codebyte/cpp -#include -#include +The output of this code is: -int main() { - std::unordered_set s = {1, 2, 3, 4, 5}; +```shell +5 2 1 +``` - // 1. Erase by key - s.erase(3); - // set is now {1, 2, 4, 5} +> **Note:** The order and even the elements removed by a range erase depend on the internal bucket ordering of the `unordered_set`, which is not guaranteed. The final printed sequence may vary across systems. - // 2. Erase by iterator - auto it = s.find(4); - if (it != s.end()) { - s.erase(it); - } - // set is now {1, 2, 5} +## Codebyte Example - // 3. Erase by iterator range - auto first = s.begin(); - auto last = s.end(); - // this removes everything in the set - s.erase(first, last); +In this example the program demonstrates each `erase()` form and prints the set contents after every removal step: - // set is now empty +```codebyte/cpp +#include +#include - return 0; +int main() { + std::unordered_set s = {1, 2, 3, 4, 5}; + + // 1. Erase by key + s.erase(3); + std::cout << "After erasing 3: "; + for (int v : s) std::cout << v << " "; + std::cout << "\n"; + + // 2. Erase by iterator + auto it = s.find(4); + if (it != s.end()) { + s.erase(it); + } + std::cout << "After erasing iterator to 4: "; + for (int v : s) std::cout << v << " "; + std::cout << "\n"; + + // 3. Erase by iterator range + auto first = s.begin(); + auto last = s.end(); + s.erase(first, last); + + std::cout << "After erasing full range: "; + for (int v : s) std::cout << v << " "; + std::cout << "(empty)\n"; + + return 0; } ```