Most efficient way to compare a variable to multiple values?

Question

A few times in my program, I've had to check if a variable was one of many options. For example

if (num = (<1 or 2 or 3>)) { DO STUFF } 

I've messed around with 'OR's, but nothing seems to be right. I've tried

if (num == (1 || 2 || 3)) 

but it does nothing.

I'd like to conveniently distinguish between several groups. For example

if (num = (1,2,3))  else if (num = (4,5,6))  else if (num = (7,8,9)) 

Answer 1

Here's a way in C++11, using std::initializer_list:

#include <algorithm> #include <initializer_list>  template <typename T> bool is_in(const T& v, std::initializer_list<T> lst) {     return std::find(std::begin(lst), std::end(lst), v) != std::end(lst); } 

with that, you can do:

if (is_in(num, {1, 2, 3})) { DO STUFF } 

It is not very efficient though when not used with built-in types. int will work fine, but if you compare std::string variables for example, the produced code is just awful.

In C++17 however, you can instead use a much more efficient solution that works well with any type:

template<typename First, typename ... T> bool is_in(First &&first, T && ... t) {     return ((first == t) || ...); }  // ...  // s1, s2, s3, s4 are strings. if (is_in(s1, s2, s3, s4)) // ... 

The C++11 version would be very inefficient here, while this version should produce the same code as hand-written comparisons.

Answer 2

If the values you want to check are sufficiently small, you could create a bit mask of the values that you seek and then check for that bit to be set.

Suppose, you care about a couple of groups.

static const unsigned values_group_1 = (1 << 1) | (1 << 2) | (1 << 3); static const unsigned values_group_2 = (1 << 4) | (1 << 5) | (1 << 6); static const unsigned values_group_3 = (1 << 7) | (1 << 8) | (1 << 9);     if ((1 << value_to_check) & values_group_1) {   // You found a match for group 1 } if ((1 << value_to_check) & values_group_2) {   // You found a match for group 2 } if ((1 << value_to_check) & values_group_3) {   // You found a match for group 3 } 

This approach works best for values that don't exceed the natural size your CPU likes to work with. This would typically be 64 in modern times, but may vary depending upon the specifics of your environment.