function template

std::count

<algorithm>
template <class InputIterator, class T>
  typename iterator_traits<InputIterator>::difference_type
    count ( ForwardIterator first, ForwardIterator last, const T& value );
Count appearances of value in range
Returns the number of elements in the range [first,last) that compare equal to value.

The behavior of this function template is equivalent to:
1
2
3
4
5
6
7
template <class InputIterator, class T>
  ptrdiff_t count ( InputIterator first, InputIterator last, const T& value )
{
  ptrdiff_t ret=0;
  while (first != last) if (*first++ == value) ++ret;
  return ret;
}


Parameters

first, last
Forward iterators to the initial and final positions of the sequence of elements. 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.
value
Value to compare the elements in the range with.

Return value

The number of elements in the range [first,last) that compare equal to value.
The return type (iterator_traits<InputIterator>::difference_type) is a signed integral type, generally defined as the same type as ptrdiff_t.

Example

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

int main () {
  int mycount;

  // counting elements in array:
  int myints[] = {10,20,30,30,20,10,10,20};   // 8 elements
  mycount = (int) count (myints, myints+8, 10);
  cout << "10 appears " << mycount << " times.\n";

  // counting elements in container:
  vector<int> myvector (myints, myints+8);
  mycount = (int) count (myvector.begin(), myvector.end(), 20);
  cout << "20 appears " << mycount  << " times.\n";

  return 0;
}


Output:
10 appears 3 times.
20 appears 3 times.

Complexity

Linear: Performs as many comparisons as the number of elements between first and last.

See also