Algorithm
Count the number of elements in a container that satisfy a given condition.
None
#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);
The count algorithm compares value to elements in the sequence defined by iterators first and last. The first version of count returns the number of matches. The second version 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.
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 following condition holds:
pred(*i) == true.
Both count and count_if perform exactly last-first applications of the corresponding predicate.
//
// 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
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 parameters, then you always need to supply the Allocator template argument. For instance, you have to write:
vector <int, allocator<int> >
instead of:
vector <int>
If your compiler does not support namespaces, then you do not need the using declaration for std.