# Man Page count.3

```
Standard C++ Library
Copyright 1998, Rogue Wave Software, Inc.

```

## NAME

```     count, count_if

- Count the number of elements in a container that  satisfy
a given condition.

```

## SYNOPSIS

```     #include <algorithm>
template<class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type
count(InputIterator first, InputIterator last,
const T& value);
template <class InputIterator, class T, class Size>
void count(InputIterator first, InputIterator last,
const T& value, Size& n);
template<class InputIterator, class Predicate>
typename iterator_traits<InputIterator>::difference_type
count_if(InputIterator first, InputIterator last,
Predicate pred);
template <class InputIterator, class Predicate, class Size>
void count_if(InputIterator first, InputIterator last,
Predicate pred, Size& n);

```

## DESCRIPTION

```     The count  algorithm  compares  value  to  elements  in  the
sequence defined by iterators first and last. The first ver-
sion of count returns the number of matches. The second ver-
sion  increments  a  counting  value  n each time it finds a
match. In other words, count returns  (or  adds  to  n)  the
number  of  iterators i in the range [first, last) for which
the following condition holds:

*i == value

Type T must be EqualityComparable.

```

## COMPLEXITY

```     The count_if algorithm lets you  specify  a  predicate,  and
returns  the  number  of  times  an  element in the sequence
satisfies the predicate (or  increments  n  that  number  of
times).  That is, count_if returns (or adds to n) the number
of iterators i in the range [first, last) for which the fol-
lowing condition holds:

pred(*i) == true.

Both count and count_if perform exactly last-first  applica-
tions of the corresponding predicate.

```

## EXAMPLE

```     //
// count.cpp
//
// Does not demonstrate the partial specialization versions
// of count and count_if
//
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;

int main()
{
int sequence[10] = {1,2,3,4,5,5,7,8,9,10};
int i=0,j=0,k=0;
//
// Set up a vector
//
vector<int> v(sequence,sequence + 10);

count(v.begin(),v.end(),5,i);  // Count fives
count(v.begin(),v.end(),6,j);  // Count sixes
//
// Count all less than 8
// I=2, j=0
//
count_if(v.begin(),v.end(),bind2nd(less<int>(),8),k);
// k = 7

cout << i << " " << j << " " << k << endl;
return 0;
}

Program Output

2 0 7

```

## WARNINGS

```     If your compiler does not  support  partial  specialization,
then  the  first version of both count and count_if (the one
that returns the count) is not available.

If your compiler does not support default  template  parame-
ters,  then you always need to supply the Allocator template
argument. For instance, you have to write:

vector <int, allocator<int> >

vector <int>

If your compiler does not support namespaces,  then  you  do
not need the using declaration for std.

```