Counting Algorithms

Lets take a look at the some useful algorithms available in the standard library. To access these, we need the <algorithm> header:

1#include <algorithm>
2

In this lesson, we cover the 5 most useful counting algorithms: count, count_if, any_of, none_of and all_of

Let's get started!

std::ranges::count

The std::ranges::count algorithm requires two arguments - the range we want to run the algorithm in, and the element we want to count within that range.

Whether or not an element matches what we’re looking for is determined by an equality check. Therefore, the type of elements in our collection must implement the equality operator, ==

In this example, we count the number of 4s in our vector of integers:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5int main() {
6  std::vector Numbers { 1, 2, 3, 4, 4, 5 };
7  auto Fours { std::ranges::count(Numbers, 4) };
8  std::cout << Fours;
9}
10

12
2

The return type of these algorithms can be somewhat cryptic. For count, the return type is a templated type:

1std::ranges::range_difference_t
2

.Given we’re counting elements in a std::vector<int> in this case, the type returned from count would be even more verbose:

1std::ranges::range_difference_t<std::vector<int>> Fours
2{
3  std::ranges::count(Numbers, 4)
4};
5

It’s common to just use auto in this scenario, as we did in the original example. Alternatively, it’s reasonable to implicitly cast the return value to something simpler, like a 64 bit integer:

1int64_t Fours { std::ranges::count(Numbers, 4) };
2

As we covered in the introduction to range-based algorithms, std::ranges::count and all the other algorithms we cover in this lesson have a variant that accepts starting and ending iterators instead. These are available by omitting the ranges namespace. For example, the iterator variant of std::ranges::count is available as std::count:

1auto Fours {
2  std::count(Numbers.begin(), Numbers.end(), 4)
3};
4

std::ranges::count_if

The std::ranges::count_if algorithm works slightly differently to count. Rather than passing an element to look for by equality, we pass a function that returns true or false. A function that returns a boolean is also known as a predicate.

Our predicate is going to be called for every element in our range and will pass that element as an argument.

If our predicate returns true, the element is included in the count. If it returns false, the element is not included.

Below, we have a predicate that returns true if a number is even. We pass this predicate to std::ranges::count_if to count the number of elements in our range that are even:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5int main() {
6  std::vector Numbers { 1, 2, 3, 4, 4, 5 };
7  auto isEven{[](int x) { return x % 2 == 0; }};
8  auto EvenCount {
9    std::ranges::count_if(Numbers, isEven)
10  };
11  std::cout << EvenCount;
12}
13

13
2

std::ranges::any_of

The std::ranges::any_of algorithm also accepts a predicate function. The algorithm will return true if our predicate returns true for any element in the range.

In the following example, we return true if any number in our collection is even:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5int main() {
6  std::vector Numbers { 1, 2, 3, 4, 4, 5 };
7  auto isEven{[](int x) { return x % 2 == 0; } };
8  bool IncludesEven {
9    std::ranges::any_of(Numbers, isEven)
10  };
11
12  std::cout << "An even number "
13            << (IncludesEven ? "is" : "is not")
14            << " included";
15}
16

1An even number is included
2

1bool IncludesEven {
2  std::ranges::count_if(Numbers, isEven) > 0
3};
4

std::ranges::none_of

The std::ranges::none_of algorithm will run a predicate on everything in our collection, and return true if every predicate returns false.

If our predicate returns true for any element in the collection, the algorithm will stop evaluating further elements, and return false.

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5int main() {
6  std::vector Numbers { 1, 2, 3, 4, 4, 5 };
7  auto isEven{ [](int x) { return x % 2 == 0; } };
8  bool NoEvenNumbers {
9    std::ranges::none_of(Numbers, isEven)
10  };
11
12  std::cout << "The range "
13            << (NoEvenNumbers ? "contains no" : "contains")
14            << " even numbers";
15}
16

1The range contains even numbers
2

This algorithm will return true if the range has no elements:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5int main() {
6  std::vector<int> Numbers { };
7  auto isEven { [](int x) { return x % 2 == 0; } };
8  bool Result {
9    std::ranges::none_of(Numbers, isEven)
10  };
11
12  std::cout << Result ? "true" : "false";
13}
14

1true
2

std::ranges::all_of

The std::ranges::all_of algorithm will run a predicate on everything in our collection, and return true if every predicate returns true.

If our predicate returns false for any element in the collection, the algorithm will stop evaluating further elements, and return false.

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5int main() {
6  std::vector Numbers { 1, 2, 3, 4, 4, 5 };
7  auto isEven{[](int x) { return x % 2 == 0; }};
8  bool AllEvenNumbers {
9    std::ranges::all_of(Numbers, isEven)
10  };
11
12  std::cout << "The range is "
13            << (AllEvenNumbers ? "all" : "not all")
14            << " even numbers";
15}
16

1The range is not all even numbers
2

Note, this algorithm will return true if the range has no elements:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5int main() {
6  std::vector<int> Numbers { };
7  auto isEven { [](int x) { return x % 2 == 0; } };
8  bool Result { std::ranges::all_of(Numbers, isEven) };
9
10  std::cout << Result ? "true" : "false";
11}
12

1true
2

Counting Algorithms With Classes

Typically when using these algorithms, the predicates we need will be class methods of the objects contained within our range. When that is the case, we generally don’t need to provide our own predicate function. We can just pass a reference to the class method:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5class Character {
6 public:
7  Character(std::string Name, int Health) :
8    Name(std::move(Name)), Health(Health){};
9
10  bool isAlive() const { return Health > 0; }
11  string GetName() const { return Name; }
12
13 private:
14  std::string Name;
15  int Health;
16};
17
18int main() {
19  std::vector Party {
20    Character { "Legolas", 100 },
21    Character { "Gandalf", 200 },
22    Character { "Gimli", 500 }
23  };
24
25  auto EveryoneAlive {
26    std::ranges::all_of(Party, &Character::isAlive)
27  };
28
29  std::cout << "Everyone "
30            << (EveryoneAlive ? "is" : "is not")
31            << " alive";
32}
33

1Everyone is alive
2

Counting Algorithms with Projection

All the algorithms in this lesson accept an additional optional argument, which can be a projection function. We cover projection in detail here:

Projections and Algorithms

Learn how to use projections with standard library algorithms in C++

In this example, we project our Character objects to a std::string before passing them to the count algorithm:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5class Character {
6 public:
7  Character(std::string Name, int Health) :
8    Name(std::move(Name)), Health(Health){};
9
10  bool isAlive() const { return Health > 0; }
11  string GetName() const { return Name; }
12
13 private:
14  std::string Name;
15  int Health;
16};
17
18int main() {
19  std::vector Party {
20    Character { "Legolas", 100 },
21    Character { "Gandalf", 200 },
22    Character { "Gimli", 500 }
23  };
24
25  auto GimliCount {
26    std::ranges::count(
27      Party, "Gimli", &Character::GetName
28    )
29  };
30
31  std::cout << "Gimlis: " << GimliCount ;
32}
33

1Gimlis: 1
2