用于检查值是否为其任何参数的帮助程序函数

Question

我需要使用辅助函数检查 T 类型的值是否是它的任何参数。

例如，使用类似于以下代码的内容

enum class my_enum{k1, k2, k3, k4, k5};
auto v{my_enum::k1};
if (is_any_of(v, my_enum::k1, my_enum::k4, my_enum::k5)) {
}

而不是使用if (v == my_enum::k1 || v == my_enum::k4 || v== my_enum::k5) {}或使用switch-case.

如何实现 C++11 中bool is_any_of()的可变参数函数？

使用 C++17 折表达式实现将如何变得更简单？

Answer 1

这将在 C++11 中工作，并且只要所有类型都可以相互比较，就可以做你想要的。

template<typename T, typename R>
bool is_any_of(T t, R r)
{
return t == r;
}
template<typename T, typename R, typename... ARGS>
bool is_any_of(T t, R r, ARGS... args)
{
if (t == r)
{
return true;
}
else
{
return is_any_of(t, args...);
}
}

这更加紧凑，可以在C++17中工作

template<typename T, typename... ARGS>
bool is_any_of(T t, ARGS... args)
{
return ((t == args) || ...);
}

Answer 2

对于非递归 C++11 替代方案：

template <typename T, typename... Ts>
bool is_any_of (T t, Ts&&... ts) {
std::initializer_list<bool> eq { (t == ts)... };
return std::any_of(eq.begin(), eq.end(), [](bool i){ return i; });
}

https://godbolt.org/z/K7xtia

但正如已经回答的那样，折叠表达式return ((t == ts) || ...);更紧凑、更具表现力和可优化性。

Answer 3

_{您已经收到了很好的基于模板的解决方案。我自己写了一个，但它重复了另一个答案。所以，这个答案是不同的，但它也不使用模板。相反，它使用可变参数宏。}

如果您需要真正的短路行为，则需要扩展完整的表达式。否则，如果参数有副作用，将它们传递给函数将触发所有这些副作用。举个人为的例子，

template <typename T>
const T & x(const T &v) {
std::cout << __func__ << ": " << v << 'n';
return v;
}
//...
if (is_any_of(2, x(1), x(2), x(3))) {
//...
}

短路实现将避免在x(2)上检测到匹配时调用x(3)。但是，这需要is_any_if(...)扩展到：

if ((2 == x(1)) || (2 == x(2)) || (2 == x(3))) {
//...

可以使用宏来完成此扩展。下面是一种可能的实现，最多可能需要 9 个参数进行测试。

#define is_any_of(...) 
(V_(V_(is_any_of_X(__VA_ARGS__,A,9,8,7,6,5,4,3,2,_))(__VA_ARGS__)))
#define is_any_of_X(_A,_9,_8,_7,_6,_5,_4,_3,_2,_1,X,...) is_any_of_##X
#define is_any_of_A(V, X, ...) ((X) == (V)) || is_any_of_9(V, __VA_ARGS__)
#define is_any_of_9(V, X, ...) ((X) == (V)) || is_any_of_8(V, __VA_ARGS__)
#define is_any_of_8(V, X, ...) ((X) == (V)) || is_any_of_7(V, __VA_ARGS__)
#define is_any_of_7(V, X, ...) ((X) == (V)) || is_any_of_6(V, __VA_ARGS__)
#define is_any_of_6(V, X, ...) ((X) == (V)) || is_any_of_5(V, __VA_ARGS__)
#define is_any_of_5(V, X, ...) ((X) == (V)) || is_any_of_4(V, __VA_ARGS__)
#define is_any_of_4(V, X, ...) ((X) == (V)) || is_any_of_3(V, __VA_ARGS__)
#define is_any_of_3(V, X, ...) ((X) == (V)) || is_any_of_2(V, __VA_ARGS__)
#define is_any_of_2(V, X)      ((X) == (V))
#define is_any_of_1(...)       false
#define is_any_of_0(...)       true
#define is_any_of_Y(_1,Y,...) is_any_of_##Y
#define is_any_of__(...) I_(is_any_of_Y, E_ __VA_ARGS__ () 0, 1)(__VA_ARGS__)
#define V_(...) __VA_ARGS__
#define I_(M,...) V_(M(__VA_ARGS__))
#define E_() _,

此处介绍了该技术。简而言之，它应用了宏参数计数技巧，以及一种可移植方法来检测单个参数大小写是否实际上是空参数大小写。(如果您使用的是 GCC，则可以简化检测。