Algorithms in the STL (C++)

all_of

template <class InItor, class UnaryPredicate>
bool all_of (InItor first, InItor last, UnaryPredicate pred);

Returns true if pred returns true for all the elements in the range [first,last) or if the range is empty, and false otherwise.

An example:

// all_of example
#include <iostream>     // std::cout
#include <algorithm>    // std::all_of
#include <array>        // std::array

int main () {
  std::array<int,8> foo = {3,5,7,11,13,17,19,23};

  if ( std::all_of(foo.begin(), foo.end(), [](int i){return i%2;}) )
    std::cout << "All the elements are odd numbers.\n";

  return 0;
}

Output:

All the elements are odd numbers.

for_each

template <class InItor, class Function>
Function for_each (InItor first, InItor last, Function fn);

Applies function fn to each of the elements in the range [first,last), where fn is a unary function that accepts an element in the range as argument. This can either be a function pointer or a move constructible function object. Its return value, if any, is ignored.

An example:

#include <iostream>     // std::cout
#include <algorithm>    // std::for_each
#include <vector>       // std::vector

void myfunction (int i) {  // function:
  std::cout << ' ' << i;
}

struct myclass {           // function object type:
  void operator() (int i) {std::cout << ' ' << i;}
} myobject;

int main () {
  std::vector<int> myvector;
  myvector.push_back(10);
  myvector.push_back(20);
  myvector.push_back(30);

  std::cout << "myvector contains:";
  for_each (myvector.begin(), myvector.end(), myfunction);
  std::cout << '\n';

  // or:
  std::cout << "myvector contains:";
  for_each (myvector.begin(), myvector.end(), myobject);
  std::cout << '\n';

  return 0;
}

Output:

myvector contains: 10 20 30
myvector contains: 10 20 30

find

template <class InItor, class T>
InItor find (InItor first, InItor last, const T& val);

Returns an iterator to the first element in the range [first,last) that compares equal to val. If no such element is found, the function returns last.

The function uses operator== to compare the individual elements to val.

See also search

search

template <class FwdItor1, class FwdItor2>
FwdItor1 search (FwdItor1 first1, FwdItor1 last1, FwdItor2 first2, FwdItor2 last2);
template <class FwdItor1, class FwdItor2, class BinPred>
FwdItor1 search (FwdItor1 first1, FwdItor1 last1, FwdItor2 first2, FwdItor2 last2, BinPred pred);

Searches the range [first1,last1) for the first occurrence of the sequence defined by [first2,last2), and returns an iterator to its first element, or last1 if no occurrences are found.

The elements in both ranges are compared sequentially using operator== (or pred, in the second version: A subsequence of [first1,last1) is considered a match only when this is true for all the elements of [first2,last2).

This function returns the first of such occurrences. For an algorithm that returns the last instead, see find_end.

An example:

// search algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::search
#include <vector>       // std::vector

bool mypredicate (int i, int j) {
  return (i==j);
}

int main () {
  std::vector<int> haystack;

  // set some values:        haystack: 10 20 30 40 50 60 70 80 90
  for (int i=1; i<10; i++) haystack.push_back(i*10);

  // using default comparison:
  int needle1[] = {40,50,60,70};
  std::vector<int>::iterator it;
  it = std::search (haystack.begin(), haystack.end(), needle1, needle1+4);

  if (it!=haystack.end())
    std::cout << "needle1 found at position " << (it-haystack.begin()) << '\n';
  else
    std::cout << "needle1 not found\n";

  // using predicate comparison:
  int needle2[] = {20,30,50};
  it = std::search (haystack.begin(), haystack.end(), needle2, needle2+3, mypredicate);

  if (it!=haystack.end())
    std::cout << "needle2 found at position " << (it-haystack.begin()) << '\n';
  else
    std::cout << "needle2 not found\n";

  return 0;
}

Output:

needle1 found at position 3
needle2 not found

find_end

template <class FwdItor1, class FwdItor2>
FwdItor1 find_end (FwdItor1 first1, FwdItor1 last1, FwdItor2 first2, FwdItor2 last2);
template <class FwdItor1, class FwdItor2, class BinPred>
FwdItor1 find_end (FwdItor1 first1, FwdItor1 last1, FwdItor2 first2, FwdItor2 last2, BinPred pred);

Searches the range [first1,last1) for the last occurrence of the sequence defined by [first2,last2), and returns an iterator to its first element, or last1 if no occurrences are found.

The elements in both ranges are compared sequentially using operator== (or pred, in the second version): A subsequence of [first1,last1) is considered a match only when this is true for all the elements of [first2,last2).

This function returns the last of such occurrences. For an algorithm that returns the first instead, see search.

find_first_of

template <class InItor, class FwdItor>
InItor find_first_of (InItor first1, InItor last1, FwdItor first2, FwdItor last2);
template <class InItor, class FwdItor, class BinPred>
InItor find_first_of (InItor first1, InItor last1, FwdItor first2, FwdItor last2, BinPred pred);

Returns an iterator to the first element in the range [first1,last1) that matches any of the elements in [first2,last2). If no such element is found, the function returns last1.

The elements in [first1,last1) are sequentially compared to each of the values in [first2,last2) using operator== (or pred, in the second version), until a pair matches.

adjacent_find

template <class FwdItor>
FwdItor adjacent_find (FwdItor first, FwdItor last);
template <class FwdItor, class BinPred>
FwdItor adjacent_find (FwdItor first, FwdItor last, BinPred pred);

Searches the range [first,last) for the first occurrence of two consecutive elements that match, and returns an iterator to the first of these two elements, or last if no such pair is found. Two elements match if they compare equal using operator== (or using pred, in version two)