How to use std::any_of for a beginner? - c++

Question

I want to compare one value against several others and check if it matches at least one of those values, I assumed it would be something like
if (x = any_of(1, 2 ,3)
// do something
But the examples of it I've seen online have been
bool any_of(InputIt first, InputIt last, UnaryPredicate)
What does that mean?
New to c++ so apologies if this is a stupid question.

Answer 1

There is plenty of literature and video tutorials on the subject of "iterators in C++", you should do some research in that direction because it's a fundamental concept in C++.
A quick summary on the matter: an iterator is something that points to an element in a collection (or range) of values. A few examples of such collections:
std::vector is the most common one. It's basically a resizable array.
std::list is a linked list.
std::array is a fixed size array with some nice helpers around C style arrays
int myInt[12] is a C style array of integers. This one shouldn't be used anymore.
Algorithms from the C++ standard library that operate on a collection of values (such as std::any_of) take the collection by two iterators. The first iterator InputIt first points to the beginning of said collection, while InputIt last points to the end of the collection (actually one past the end).
A UnaryPredicate is a function that takes 1 argument (unary) and returns a bool (predicate).
In order to make std::any_of do what you want, you have to put your values in a collection and x in the UnaryPredicate:
int x = 3;
std::vector values = {1, 2, 3};
if (std::any_of(values.begin(), values.end(), [x](int y) { return x == y; }))
// ...
The UnaryPredicate in this case is a lambda function.
As you can see this is quite verbose code given your example. But once you have a dynamic amound of values that you want to compare, or you want to check for more complex things than just equality, this algorithm becomes way more beneficial.
Fun little experiment
Just for fun, I made a little code snippet that implements an any_of like you wanted to have it. It's quite a lot of code and pretty complicated aswell (definitely not beginner level!) but it is very flexible and actually nice to use. The full code can be found here.
Here is how you would use it:
int main()
{
int x = 7;
std::vector dynamic_int_range = {1, 2, 3, 4, 5, 6, 7, 8};
if (x == any_of(1, 2, 3, 4, 5))
{
std::cout << "x is in the compile time collection!\n";
}
else if (x == any_of(dynamic_int_range))
{
std::cout << "x is in the run time collection!\n";
}
else
{
std::cout << "x is not in the collection :(\n";
}
std::string s = "abc";
std::vector<std::string> dynamic_string_range = {"xyz", "uvw", "rst", "opq"};
if (s == any_of("abc", "def", "ghi"))
{
std::cout << "s is in the compile time collection!\n";
}
else if (s == any_of(dynamic_string_range))
{
std::cout << "s is in the run time collection!\n";
}
else
{
std::cout << "s is not in the collection :(\n";
}
}
And here how it's implemented:
namespace detail
{
template <typename ...Args>
struct ct_any_of_helper
{
std::tuple<Args...> values;
constexpr ct_any_of_helper(Args... values) : values(std::move(values)...) { }
template <typename T>
[[nodiscard]] friend constexpr bool operator==(T lhs, ct_any_of_helper const& rhs) noexcept
{
return std::apply([&](auto... vals) { return ((lhs == vals) || ...); }, rhs.values);
}
};
template <typename Container>
struct rt_any_of_helper
{
Container const& values;
constexpr rt_any_of_helper(Container const& values) : values(values) { }
template <typename T>
[[nodiscard]] friend constexpr bool operator==(T&& lhs, rt_any_of_helper&& rhs) noexcept
{
return std::any_of(cbegin(rhs.values), cend(rhs.values), [&](auto val)
{
return lhs == val;
});
}
};
template <typename T>
auto is_container(int) -> decltype(cbegin(std::declval<T>()) == cend(std::declval<T>()), std::true_type{});
template <typename T>
std::false_type is_container(...);
template <typename T>
constexpr bool is_container_v = decltype(is_container<T>(0))::value;
}
template <typename ...Args>
[[nodiscard]] constexpr auto any_of(Args&&... values)
{
using namespace detail;
if constexpr (sizeof...(Args) == 1 && is_container_v<std::tuple_element_t<0, std::tuple<Args...>>>)
return rt_any_of_helper(std::forward<Args>(values)...);
else
return ct_any_of_helper(std::forward<Args>(values)...);
}
In case an expert sees this code and wants to complain about the dangling reference: come on, who would write someting like this:
auto a = any_of(std::array {1, 2, 3, 4});
if (x == std::move(a)) // ...

Answer 2

That's not what this function is for.
Your values must already exist somewhere else, it is very likely that it will be a vector.
std::any_of operates on iterators.
Iterators in C++ are ranges, two values that tell you where is the beginning, and where is the end of the range.
Most C++ Standard Template Library collections, including std::vector, support iterator API, and so you can use std::any_of on them.
For the sake of a full example, lets check if a vector contains 42 in over the top way, just to use std::any_of.
Since we only want to check if value in vector exists without changing anything (std::any_of doesn't modify the collection), we use .cbegin() and .cend() that return constant beginning and end of the vector, those are important to std::any_of, as it has to iterate over the entire vector to check if there's at least one value matching the given predicate.
The last parameter must be unary predicate, that means that it is a function, that accepts a single argument, and returns whether given argument fits some criteria.
To put it simply, std::any_of is used to check whether there's at least one value in a collection, that has some property that you care about.
Code:
#include <algorithm>
#include <iostream>
#include <vector>
bool is_42(int value) {
return value == 42;
}
int main() {
std::vector<int> vec{
1, 2, 3,
// 42 // uncomment this
};
if(std::any_of(vec.cbegin(), vec.cend(), is_42)) {
std::cout << "42 is in vec" << std::endl;
} else {
std::cout << "42 isn't in vec" << std::endl;
}
}

Answer 3

As stated by user #a.abuzaid, you can create your own method for this. The method they provided, however, lacks in a number of areas stated in the comments of the answer. I can't really get my head around std::any_of as of right now and just decided to create this template:
template <typename Iterable, typename type>
bool any_of(Iterable iterable, type value) {
for (type comparison : iterable) {
if (comparison == value) {
return true;
}
}
return false;
}
An example use here would be if (any_of(myVectorOfStrings, std::string("Find me!"))) { do stuff }, in which the iterable is a vector of strings and the value is the string "Find me!".

Answer 4

You can just create a function where you are comparing x to two other numbers to check if they are the same for instance
bool anyof(int x, int y, int z) {
if ((x == y) || (x == z))
return true;
}
and then within your main you can call the function like this:
if (anyof(x, 1, 2))
cout << "Matches a number";