Can't Pass Enum Value to Recursive Template (C++) - c++

Question

Suppose I want to write a recursive template function that compares an individual value to every single element in an n-dimensional vector, returning true if there is at least one match and false if there are none.
I wrote some code to do this, although it's probably far from optimal:
template <typename T, typename Checker>
void check_for_each(const T& v, const Checker condition)
{
condition(v);
}
template <typename T, typename Checker>
void check_for_each(const std::vector<T>& v, const Checker condition)
{
for(unsigned int i = 0; i < v.size(); i++)
{
check_for_each(v[i], condition);
}
}
template <typename T, typename U>
bool is_equal_any(const T& VALUE, const std::vector<typename U> VECTOR)
{
bool is_equal = false;
check_for_each(VECTOR, [&is_equal, &VALUE](const T& val)
{
if(!is_equal && VALUE == val)
{
is_equal = true;
}
});
return is_equal;
}
While this seems to work, I've encountered an unusual issue and I can't quite understand it. For example, the following code works:
enum PIECE_NAME {EMPTY, PAWN, ROOK, KNIGHT, BISHOP, QUEEN, KING};
std::vector<std::vector<int>> board {{ROOK, BISHOP}, {KNIGHT, QUEEN}};
std::cout << is_equal_any(2, board); // outputs 1 (there is a rook on the board)
Yet the following, slight change does not:
std::cout << is_equal_any(ROOK, board); // compile error C2664
Apparently my function cannot figure out how to convert the enum value to an integer. Of course, I can just use static_cast<int>(ROOK), and the code compiles and runs as expected, but that's obviously not ideal. Furthermore, I know that I can change my board's declaration to std::vector<std::vector<PIECE_NAME>> board, (which also runs as expected) but I'd prefer to leave it at int. So is it possible to rewrite these recursive template functions so that is_equal_any can take enum values directly? I'm still very new to C++, so I would really appreciate as much detail in your answer as possible. Thank you.

Answer 1

The problem arises from the type T here:
check_for_each(VECTOR, [&is_equal, &VALUE](const T& val)
^
By calling
is_equal_any(ROOK, board)
T is a PIECE_NAME, but what you are finally passing as parameter to this lambda are the elements of your vector of type int. But an int can't be implicitly converted to an enum.
You can't either use directly U as it could be a std::vector<int> or std::vector< std::vector<int> > or...
If you were using C++14, you could use a generic lambda with auto:
check_for_each(VECTOR, [&is_equal, &VALUE](const auto& val)
But as you tagged your question C++11, you can use a trait:
template <typename T>
struct leaf_type {
using type = T;
};
template <typename T>
struct leaf_type<std::vector<T>> {
using type = typename leaf_type<T>::type;
};
template <typename T>
using leaf_type_t = typename leaf_type<T>::type;
usage:
check_for_each(VECTOR, [&is_equal, &VALUE](const leaf_type_t<U> & val)
DEMO
Btw you should avoid nested std::vectors and linearize it into a single one like:
std::vector<int> board {ROOK, BISHOP, KNIGHT, QUEEN};
Then you can easily use std::find.

Answer 2

This is kind of an XY problem, as there are better approaches:
Use a scoped enum
don't mix integers and enums
delegate your work to std::any_of
For example:
namespace multi_dim{
template< class InputIt, class UnaryPredicate >
bool any_of(InputIt first, InputIt last, UnaryPredicate p)
{
using std::any_of;
for(;first != last; ++first)
{
bool next = any_of(first->cbegin(), first->cend(), p);
if (next)
return true;
}
return false;
}
}
Demo
A test:
std::vector<std::vector<PIECE>> board {{PIECE::ROOK, PIECE::BISHOP}, {PIECE::KNIGHT, PIECE::QUEEN}};
std::cout << std::boolalpha << multi_dim::any_of(board.cbegin(), board.cend(), [](PIECE p){return p == PIECE::ROOK;}) << std::endl;
std::cout << std::boolalpha << multi_dim::any_of(board.cbegin(), board.cend(), [](PIECE p){return p == PIECE::EMPTY;}) << std::endl;
Output:
true
false

Answer 3

Wild guess: Try a difference template parameter for VALUE and for the element type of VECTOR.
I don't use MSVC so I'm not sure exactly what error you're getting.
... regardless of all that, I just have to repeat my comment: Please don't write this kind of code.

Answer 4

Although the solution using std::any_of is the best one, I give my answer that show somewhat less drastic improvement to original code.
template <typename T, typename Checker>
bool check_for_each(const T& v, const Checker condition)
{
return condition(v);
}
template <typename T, typename Checker>
bool check_for_each(const std::vector<T>& v, const Checker condition)
{
return std::find_if(begin(v), end(v), [condition](const T &t) { return check_for_each(t, condition); }) != v.end();
}
template <typename T, typename U>
bool is_equal_any(const T& value, const U &container)
{
return check_for_each(container, [&value](const T& val){ return value == val; });
}
enum class PIECE_NAME { EMPTY, PAWN, ROOK, KNIGHT, BISHOP, QUEEN, KING };
void test()
{
std::vector<std::vector<PIECE_NAME>> board
{
{ PIECE_NAME::ROOK, PIECE_NAME::BISHOP },
{ PIECE_NAME::KNIGHT, PIECE_NAME::QUEEN }
};
std::cout << is_equal_any(PIECE_NAME::ROOK, board);
}
This solution is still hard-coded for nested vectors but the code has been simplified a bit and also optimized as it will stop searching once an item is found.
As already suggested in other comments, you should really use enum (or better yet enum class). It does not make much sense to store integers in the vector as you loose type information.