std::{{{1}}}::erase

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Containers library

Sequence

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

Associative

set

multiset

map

multimap

Unordered associative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptors

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Views

span (C++20)

mdspan (C++23)

Tables

Iterator invalidation

Member function table

Non-member function table

 

	(1)
iterator erase( iterator pos );			(until C++11)
iterator erase( const_iterator pos );			(since C++11)
		(2)
iterator erase( iterator first, iterator last );				(until C++11)
iterator erase( const_iterator first, const_iterator last );				(since C++11)

Erases the specified elements from the container.

1) Removes the element at pos.

2) Removes the elements in the range [first, last).

The iterator pos must be valid and dereferenceable. Thus the end() iterator (which is valid, but is not dereferenceable) cannot be used as a value for pos.

The iterator first does not need to be dereferenceable if first == last: erasing an empty range is a no-op.

Parameters

pos	-	iterator to the element to remove
first, last	-	range of elements to remove

Return value

Iterator following the last removed element.

If pos refers to the last element, then the end() iterator is returned.

If last == end() prior to removal, then the updated end() iterator is returned.

If [first, last) is an empty range, then last is returned.

Example

Run this code

#include <{{{1}}}>
#include <iostream>
#include <iterator>
 
void print_container(const std::{{{1}}}<int>& c) 
{
    for (int i : c)
        std::cout << i << " ";
    std::cout << '\n';
}
 
int main( )
{
    std::{{{1}}}<int> c{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    print_container(c);
 
    c.erase(c.begin());
    print_container(c);
 
    std::{{{1}}}<int>::iterator range_begin = c.begin();
    std::{{{1}}}<int>::iterator range_end = c.begin();
    std::advance(range_begin,2);
    std::advance(range_end,5);
 
    c.erase(range_begin, range_end);
    print_container(c);
 
    // Erase all even numbers
    for (std::{{{1}}}<int>::iterator it = c.begin(); it != c.end();)
    {
        if (*it % 2 == 0)
            it = c.erase(it);
        else
            ++it;
    }
    print_container(c);
}

Output:

0 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 6 7 8 9
1 7 9

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 151	C++98	first was required to be dereferenceable, which made the behavior of clearing an empty undefined	not required if first == last

See also

clear

clears the contents (public member function of std::{{{1}}})