remove_if


function template
<algorithm>
template < class ForwardIterator, class Predicate >
  ForwardIterator remove_if ( ForwardIterator first, ForwardIterator last,
                              Predicate pred );

Remove elements from range

Removes from the range [first,last) the elements for which pred applied to its value is true, and returns an iterator to the new end of the range, which now includes only the values for which pred was false.

The behavior of this function template is equivalent to:
1
2
3
4
5
6
7
8
9
 
template < class ForwardIterator, class Predicate >
  ForwardIterator remove_if ( ForwardIterator first, ForwardIterator last,
                              Predicate pred )
{
  ForwardIterator result = first;
  for ( ; first != last; ++first)
    if (!pred(*first)) *result++ = *first;
  return result;
}


Notice that this function does not alter the elements past the new end, which keep their old values and are still accessible.

Parameters

first, last
Forward iterators to the initial and final positions in a sequence. The range used is [first,last), which contains all the elements between first and last, including the element pointed by first but not the element pointed by last.
pred
Unary predicate taking an element in the range as argument, and returning a value indicating the falsehood (with false, or a zero value) or truth (true, or non-zero) of some condition applied to it. This can either be a pointer to a function or an object whose class overloads operator().


Return value

A forward iterator pointing to the new end of the sequence, which now includes all the elements for which pred was false.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
// remove_if example
#include <iostream>
#include <algorithm>
using namespace std;

bool IsOdd (int i) { return ((i%2)==1); }

int main () {
  int myints[] = {1,2,3,4,5,6,7,8,9};            // 1 2 3 4 5 6 7 8 9

  // bounds of range:
  int* pbegin = myints;                          // ^
  int* pend = myints+sizeof(myints)/sizeof(int); // ^                 ^

  pend = remove_if (pbegin, pend, IsOdd);        // 2 4 6 8 5 6 7 8 9
                                                 // ^       ^
  cout << "range contains:";
  for (int* p=pbegin; p!=pend; ++p)
    cout << " " << *p;

  cout << endl;
 
  return 0;
}


Output:
range contains: 2 4 6 8


Complexity

Applies pred as many times as the number of elements in the range [first,last).

See also

remove Remove value from range (function template)
remove_copy Copy range removing value (function template)
replace_if Replace values in range (function template)
transform Apply function to range (function template)
find_if Find element in range (function template)