std::count

Defined in header <algorithm>

template< class InputIt, class T >
typename iterator_traits<InputIt>::difference_type
    count( InputIt first, InputIt last, const T &value );

(1)

template< class InputIt, class UnaryPredicate >
typename iterator_traits<InputIt>::difference_type
    count_if( InputIt first, InputIt last, UnaryPredicate p );

(2)

Returns the number of elements in the range [first, last) satisfying specific criteria. The first version counts the elements that are equal to value, the second version counts elements for which predicate p returns true.

Parameters

first, last	-	the range of elements to examine
value	-	the value to search for
p	-	unary predicate which returns `true` for the required elements. The signature of the predicate function should be equivalent to the following: `bool pred(const Type &a);` The signature does not need to have `const &`, but the function must not modify the objects passed to it. The type `Type` must be such that an object of type `InputIt` can be dereferenced and then implicitly converted to `Type`.
Type requirements
- `InputIt` must meet the requirements of `InputIterator`.

Return value

number of elements satisfying the condition.

Complexity

exactly last - first comparisons / applications of the predicate.

Notes

For the number of elements in the range [first, last) without any additional criteria, see std::distance.

Possible implementation

First version

template<class InputIt, class T>
typename iterator_traits<InputIt>::difference_type
    count(InputIt first, InputIt last, const T& value)
{
    typename iterator_traits<InputIt>::difference_type ret = 0;
    for (; first != last; ++first) {
        if (*first == value) {
            ret++;
        }
    }
    return ret;
}

Second version

template<class InputIt, class UnaryPredicate>
typename iterator_traits<InputIt>::difference_type
    count_if(InputIt first, InputIt last, UnaryPredicate p)
{
    typename iterator_traits<InputIt>::difference_type ret = 0;
    for (; first != last; ++first) {
        if (p(*first)) {
            ret++;
        }
    }
    return ret;
}

Example

The following code uses count to determine how many integers in a std::vector match a target value.

#include <algorithm>
#include <iostream>
#include <vector>
  
int main()
{
    int data[] = { 1, 2, 3, 4, 4, 3, 7, 8, 9, 10 };
    std::vector<int> v(data, data+10);
  
    int target1 = 3;
    int target2 = 5;
    int num_items1 = std::count(v.begin(), v.end(), target1);
    int num_items2 = std::count(v.begin(), v.end(), target2);
  
    std::cout << "number: " << target1 << " count: " << num_items1 << '\n';
    std::cout << "number: " << target2 << " count: " << num_items2 << '\n';
}

Output:

number: 3 count: 2
number: 5 count: 0

This example uses a lambda expression to count elements divisible by 3.

#include <algorithm>
#include <iostream>
#include <vector>
  
int main()
{
    int data[] = { 1, 2, 3, 4, 4, 3, 7, 8, 9, 10 };
    std::vector<int> v(data, data+10);
  
    int num_items1 = std::count_if(v.begin(), v.end(), [](int i) {return i % 3 == 0;});
  
    std::cout << "number divisible by three: " << num_items1 << '\n';
}