std::ranges::count, std::ranges::count_if

Defined in header `<algorithm>`
Call signature
template< std::input_iterator I, std::sentinel_for<I> S, class T, class Proj = std::identity > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T*> constexpr std::iter_difference_t<I> count( I first, S last, const T& value, Proj proj = {} );	(1)	(since C++20) (until C++26)
template< std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity, class T = std::projected_value_t<I, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T*> constexpr std::iter_difference_t<I> count( I first, S last, const T& value, Proj proj = {} );	(1)		(since C++26)
template< ranges::input_range R, class T, class Proj = std::identity > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> constexpr ranges::range_difference_t<R> count( R&& r, const T& value, Proj proj = {} );	(2)	(since C++20) (until C++26)
template< ranges::input_range R, class Proj = std::identity, class T = std::projected_value_t<ranges::iterator_t<R>, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> constexpr ranges::range_difference_t<R> count( R&& r, const T& value, Proj proj = {} );	(2)		(since C++26)
template< std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > constexpr std::iter_difference_t<I> count_if( I first, S last, Pred pred, Proj proj = {} );	(3)	(since C++20)
template< ranges::input_range R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred > constexpr ranges::range_difference_t<R> count_if( R&& r, Pred pred, Proj proj = {} );	(4)	(since C++20)
template< /execution-policy/ Ep, std::random_access_iterator I, std::sized_sentinel_for<I> S, class Proj = std::identity, class T = std::projected_value_t<I, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T*> std::iter_difference_t<I> count( Ep&& policy, I first, S last, const T& value, Proj proj = {} );	(5)	(since C++26)
template< /execution-policy/ Ep, /sized-random-access-range/ R, class Proj = std::identity, class T = std::projected_value_t<ranges::iterator_t<R>, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> ranges::range_difference_t<R> count( Ep&& policy, R&& r, const T& value, Proj proj = {} );	(6)	(since C++26)
template< /execution-policy/ Ep, std::random_access_iterator I, std::sized_sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > std::iter_difference_t<I> count_if( Ep&& policy, I first, S last, Pred pred, Proj proj = {} );	(7)	(since C++26)
template< /execution-policy/ Ep, /sized-random-access-range/ R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred > ranges::range_difference_t<R> count_if( Ep&& policy, R&& r, Pred pred, Proj proj = {} );	(8)	(since C++26)

For the definition of /*execution-policy*/, see this page; for the definition of /*sized-random-access-range*/, see this page.

Returns the number of elements (projected by proj) in the source range satisfying specific criteria.

1,2) Counts the elements that are equal to value.

1) The source range is [first, last).

2) The source range is r.

3,4) Counts elements for which predicate p returns true.

3) The source range is [first, last).

4) The source range is r.

5-8) Same as (1-4), but executed according to policy.

The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:

Explicit template argument lists cannot be specified when calling any of them.
None of them are visible to argument-dependent lookup.
When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.

Parameters

first, last	-	the iterator-sentinel pair defining the source range
r	-	the source range
value	-	the value to search for
pred	-	the predicate to be applied to the (projected) elements
proj	-	the projection to be applied to the elements
policy	-	the execution policy to use

Return value

The number of iterators iter in the source range satisfying the following condition:

1,2,5,6) std::invoke(proj, *iter) == value is true.

3,4,7,8) bool(std::invoke(pred, std::invoke(proj, *iter))) is true.

Complexity

Given \(\scriptsize N\)N as ranges::distance(first, last) or ranges::distance(r):

1,2) Exactly \(\scriptsize N\)N comparisons with value using operator==, and the same number of applications of proj.

3,4) Exactly \(\scriptsize N\)N applications of pred and proj.

5,6) \(\scriptsize \mathcal{O}(N)\)𝓞(N) comparisons with value using operator==, and the same number of applications of proj.

7,8) \(\scriptsize \mathcal{O}(N)\)𝓞(N) applications of pred and proj.

Exceptions

5-8) During the execution process:

If the temporary memory resources required for parallelization are not available, std::bad_alloc is thrown.
If an uncaught exception is thrown while accessing objects via an algorithm argument, the behavior is determined by the execution policy (for standard policies, std::terminate is invoked).

Notes

For the number of elements in the range without any additional criteria, see ranges::distance.

Feature-test macro	Value	Std	Feature
`__cpp_lib_algorithm_default_value_type`	`202403`	(C++26)	List-initialization for algorithms (1,2)

Possible implementation

count
struct count_fn { template<std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity, class T = std::projected_value_t<I, Proj>> requires std::indirect_binary_predicate<ranges::equal_to, std::projected<I, Proj>, const T> constexpr std::iter_difference_t<I> operator()(I first, S last, const T& value, Proj proj = {}) const { std::iter_difference_t<I> counter = 0; for (; first != last; ++first) if (std::invoke(proj, first) == value) ++counter; return counter; } template<ranges::input_range R, class Proj = std::identity class T = std::projected_value_t<ranges::iterator_t<R>, Proj>> requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T> constexpr ranges::range_difference_t<R> operator()(R&& r, const T& value, Proj proj = {}) const { return (this)(ranges::begin(r), ranges::end(r), value, std::ref(proj)); } template<ranges::forward_range R, class Proj = std::identity class T = std::projected_value_t<ranges::iterator_t<R>, Proj>> requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T> constexpr ranges::range_difference_t<R> operator()(R&& r, const T& value, Proj proj = {}) const { return (this)(ranges::begin(r), ranges::next(ranges::begin(r), ranges::end(r)), value, std::ref(proj)); } }; inline constexpr count_fn count;
count_if
struct count_if_fn { template<std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred> constexpr std::iter_difference_t<I> operator()(I first, S last, Pred pred, Proj proj = {}) const { std::iter_difference_t<I> counter = 0; for (; first != last; ++first) if (std::invoke(pred, std::invoke(proj, first))) ++counter; return counter; } template<ranges::input_range R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred> constexpr ranges::range_difference_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const { return (this)(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj)); } template<ranges::forward_range R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred> constexpr ranges::range_difference_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const { return (*this)(ranges::begin(r), ranges::next(ranges::begin(r), ranges::end(r)), std::ref(pred), std::ref(proj)); } }; inline constexpr count_if_fn count_if;

count

struct count_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S,
             class Proj = std::identity, class T = std::projected_value_t<I, Proj>>
        requires std::indirect_binary_predicate<ranges::equal_to,
                                                std::projected<I, Proj>, const T*>
    constexpr std::iter_difference_t<I>
        operator()(I first, S last, const T& value, Proj proj = {}) const
    {
        std::iter_difference_t<I> counter = 0;
        for (; first != last; ++first)
            if (std::invoke(proj, *first) == value)
                ++counter;
        return counter;
    }
    
    template<ranges::input_range R, class Proj = std::identity
             class T = std::projected_value_t<ranges::iterator_t<R>, Proj>>
        requires std::indirect_binary_predicate
                     <ranges::equal_to,
                      std::projected<ranges::iterator_t<R>, Proj>, const T*>
    constexpr ranges::range_difference_t<R>
        operator()(R&& r, const T& value, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), value, std::ref(proj));
    }
    
    template<ranges::forward_range R, class Proj = std::identity
             class T = std::projected_value_t<ranges::iterator_t<R>, Proj>>
        requires std::indirect_binary_predicate
                     <ranges::equal_to,
                      std::projected<ranges::iterator_t<R>, Proj>, const T*>
    constexpr ranges::range_difference_t<R>
        operator()(R&& r, const T& value, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r),
                       ranges::next(ranges::begin(r), ranges::end(r)),
                       value, std::ref(proj));
    }
};

inline constexpr count_fn count;

count_if

struct count_if_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S,
             class Proj = std::identity,
             std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
    constexpr std::iter_difference_t<I>
        operator()(I first, S last, Pred pred, Proj proj = {}) const
    {
        std::iter_difference_t<I> counter = 0;
        for (; first != last; ++first)
            if (std::invoke(pred, std::invoke(proj, *first)))
                ++counter;
        return counter;
    }
    
    template<ranges::input_range R, class Proj = std::identity,
             std::indirect_unary_predicate
                 <std::projected<ranges::iterator_t<R>, Proj>> Pred>
    constexpr ranges::range_difference_t<R>
        operator()(R&& r, Pred pred, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r),
                       std::ref(pred), std::ref(proj));
    }
    
    template<ranges::forward_range R, class Proj = std::identity,
             std::indirect_unary_predicate
                 <std::projected<ranges::iterator_t<R>, Proj>> Pred>
    constexpr ranges::range_difference_t<R>
        operator()(R&& r, Pred pred, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r),
                       ranges::next(ranges::begin(r), ranges::end(r)),
                       std::ref(pred), std::ref(proj));
    }
};

inline constexpr count_if_fn count_if;

Example

#include <algorithm>
#include <cassert>
#include <complex>
#include <iostream>
#include <vector>
 
int main()
{
    std::vector<int> v{1, 2, 3, 4, 4, 3, 7, 8, 9, 10};
    
    namespace ranges = std::ranges;
    
    // determine how many integers in a std::vector match a target value.
    int target1 = 3;
    int target2 = 5;
    int num_items1 = ranges::count(v.begin(), v.end(), target1);
    int num_items2 = ranges::count(v, target2);
    std::cout << "number: " << target1 << " count: " << num_items1 << '\n';
    std::cout << "number: " << target2 << " count: " << num_items2 << '\n';
    
    // use a lambda expression to count elements divisible by 3.
    int num_items3 = ranges::count_if(v.begin(), v.end(), [](int i){ return i % 3 == 0; });
    std::cout << "number divisible by three: " << num_items3 << '\n';
    
    // use a lambda expression to count elements divisible by 11.
    int num_items11 = ranges::count_if(v, [](int i){ return i % 11 == 0; });
    std::cout << "number divisible by eleven: " << num_items11 << '\n';
    
    std::vector<std::complex<double>> nums{{4, 2}, {1, 3}, {4, 2}};
    #ifdef __cpp_lib_algorithm_default_value_type
        auto c = ranges::count(nums, {4, 2});
    #else
        auto c = ranges::count(nums, std::complex<double>{4, 2});
    #endif
    assert(c == 2);
}

Output:

number: 3 count: 2
number: 5 count: 0
number divisible by three: 3
number divisible by eleven: 0

countcount_if	returns the number of elements satisfying specific criteria (function template)
ranges::distance (C++20)	returns the distance between an iterator and a sentinel, or between the beginning and end of a range (algorithm function object)
views::counted (C++20)	creates a subrange from an iterator and a count (customization point object)
ranges::filter_viewviews::filter (C++20)	a `view` that consists of the elements of a `range` that satisfy a predicate (class template) (range adaptor object)