Cpp Libs List Remove
π
2026-06-23 | π C++
# C++
remove() Function
The `std::list::remove` function is a built-in member function of the `std::list` container in C++. It is used to **remove all elements from the list that are equal to a specified value**.
Unlike general-purpose algorithms, `std::list::remove` is a member function specifically optimized for doubly-linked lists. It efficiently rearranges node pointers to remove elements without shifting subsequent elements in memory, maintaining the stability of iterators pointing to non-removed elements.
---
## Syntax and Parameters
### Syntax
```cpp
void remove(const T& value);
```
### Parameters
* **`value`**: The value of the elements to be removed from the list. The type `T` must match the element type of the `std::list`.
### Return Value
* **`void`**: The function does not return any value.
### Complexity
* **Time Complexity**: $\mathcal{O}(N)$, where $N$ is the size of the list. It performs exactly $N$ comparisons.
* **Space Complexity**: $\mathcal{O}(1)$ auxiliary space, as the removal is performed in-place by updating node pointers.
---
## Code Examples
### Example 1: Removing Integer Elements
This example demonstrates how to remove all occurrences of a specific integer from a list.
```cpp
#include
#include
int main() {
// Initialize a list with duplicate values
std::list numbers = {1, 2, 3, 2, 4, 2, 5};
std::cout << "Original list: ";
for(int n : numbers) {
std::cout << n << " ";
}
std::cout << std::endl;
// Remove all elements equal to 2
numbers.remove(2);
std::cout << "After remove(2): ";
for(int n : numbers) {
std::cout << n << " ";
}
std::cout << std::endl;
return 0;
}
```
**Expected Output:**
```text
Original list: 1 2 3 2 4 2 5
After remove(2): 1 3 4 5
```
---
### Example 2: Removing String Elements
This example demonstrates how `remove` works with standard library types like `std::string`.
```cpp
#include
#include
#include
int main() {
// Initialize a list of strings
std::list words = {"apple", "banana", "apple", "cherry", "apple"};
std::cout << "Original list: ";
for(const auto& w : words) {
std::cout << w << " ";
}
std::cout << std::endl;
// Remove all occurrences of "apple"
words.remove("apple");
std::cout << "After remove(\"apple\"): ";
for(const auto& w : words) {
std::cout << w << " ";
}
std::cout << std::endl;
return 0;
}
```
**Expected Output:**
```text
Original list: apple banana apple cherry apple
After remove("apple"): banana cherry
```
---
## Key Considerations
1. **Comparison Operator**: The `remove` function compares elements using `operator==`. If you are using `std::list` with a custom struct or class, you must overload the `==` operator for that type.
2. **Iterator Validity**: Only iterators, pointers, and references to the **removed** elements are invalidated. All other iterators remain completely valid.
3. **Member Function vs. Generic Algorithm**:
* Always prefer the member function `std::list::remove` over the generic algorithm `std::remove` (from ``).
* The generic `std::remove` algorithm cannot alter the size of the container; it only shifts elements and requires a subsequent call to `erase` (the Erase-Remove idiom).
* The member function `std::list::remove` directly deallocates the nodes and updates the list size in a single, highly efficient step.