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))

Solution 1

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.

Solution 2

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.

Solution 3

You have to do the comparison with each value. E.g.

if (num == 1 || num == 2 || num == 3) { stuff }

You may also want to consider a switch and intentionally falling through cases (although I don't think it's the best solution for what you're stating).

switch (num) {
    case 1:
    case 2:
    case 3:
        {DO STUFF}
        break;

    default:
        //do nothing.
}

Solution 4

I just had a similar problem and I came to these C++11 solutions:

template <class T> 
struct Is 
{ 
  T d_; 
  bool in(T a) { 
    return a == d_; 
  } 
  template <class Arg, class... Args> 
  bool in(Arg a, Args... args) { 
    return in(a) || in(args...); 
  } 
}; 

template <class T> 
Is<T> is(T d) { 
  return Is<T>{d}; 
}

Or as alternative without the recursion terminating method. Be aware that here the order of comparisons is undefined and that this does not terminate early if the first match is found. But the code is more compact.

template <class T>
struct Is {
  const T d_;
  template <class... Args>
  bool in(Args... args) {
    bool r{ false }; 
    [&r](...){}(( (r = r || d_ == args), 1)...);
    return r;
  }
};

template <class T>
Is<T> is(T d) { 
  return Is<T>{d}; 
}

So for both solutions the code would look like:

if (is(num).in(1,2,3)) {
  // do whatever needs to be done
}

Solution 5

You can define a set of integers, add the desired values to it, and then use the find method to see if the value in question is in the set

std::set<int> values;
// add the desired values to your set...
if (values.find(target) != values.end())
    ...

View more solutions

Comments

[chris]

Is if (num == 1 || num == 2 || num == 3) or if (num >= 1 && num <= 3) too much typing? If it's longer, you can always make some sort of array and use std::find.

[Seth Carnegie]

See stackoverflow.com/q/14368525/726361

[Matt Reynolds]

That's an interesting way of doing things... I'll give it a try, thanks!

[Matt Reynolds]

Yeah, not exactly what I'm looking for. Thanks anyways!

[Matt Reynolds]

Sorry, I'm just getting a ton of errors. How exactly do you use this? Could you give an example?

[Matt Reynolds]

That looks convenient, but I'm not using 11. I'm just in plain ol' C++.

[Matt Reynolds]

Cool. That makes thing easy. If I wanted to see "if 1; else if 2, else if 3;" how would I do that? Would I need a new bit mask, or could I just add in "(2 << n)"?

[Eric Johnson]

If you want to check values 1, 2 and 3, then your bit mask would become this instead values_i_like = (1<<1) | (1<<2) | (1<<3);.

[Matt Reynolds]

no, you misunderstand. I want to be able to differ from (1,2,3) and (4,5,6)

[Eric Johnson]

values_i_like = (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6);

[Matt Reynolds]

but how would you distinguish from (1,2,3) and (4,5,6)?

[Matt Reynolds]

Here, let me add an example into the original question.

[Matt Reynolds]

Okay, so you would have to use multiple sets. Thanks!

[Eric Johnson]

Just to be overly clear, you only need to use multiple sets IFF the logic that is in the "then" side of the test is different across sets. If the logic is the same, then use one set. Also, if you aren't familiar with the bit shift operators, do spend some time learning them. Copying code is fine. Copying what looks like magic is bad.

[Matt Reynolds]

Yes, that's exactly what I'm doing, the logic differs. Also, I kind of skimmed that section when I was learning C++, but I went back now and it's clear. Thanks again!

[Admin]

lol, genius in its simplicity! @TheWalkingCactus just use count instead with a set.

[einpoklum]

Umm, no, you don't have to do that.

[Ruslan]

This won't typically be 64, even in modern times: both MSVS and GCC have sizeof(int)==4 (and CHAR_BIT==8), so 32 is much more likely to have, even on x86_64.

[underscore_d]

+1 for the stupendously good way to do this in C++17. I would +2 if I could because you bothered to come back 5.5 years later and add that!

[underscore_d]

switch can only compare an integral or enumerator type, though, so while it does work - and often neatly - for such objects, it quickly reveals itself to be a one-trick pony, a relic of the assembler jump-table days, and not a general solution (and therefore not suitable for generic code, which is pretty important).

[underscore_d]

You can, but that's an awful lot of dynamic allocation, copying, and immediate destruction for a task so immensely transient and possibly frequent. That's compounded by how 'check if a value is in a set' is such a basic concept that it (A) arguably should be a basic feature of the language and (B) should be free to do. I guess (A) is not really needed when there are easy ways to write a helper function to do it, as others have shown, while also satisfying (B).

[underscore_d]

The specialisation for C strings is a nice touch (as it is hard to think when you would want the default behaviour of comparing pointers to that type), as is the presence of a concise and practical example!

[Berkyjay]

The c++17 feature is called fold expression

[Kai Petzke]

The is_in template inline function is great! I recommend though to declare it with the following signature: bool is_in(const First& first, const T& ... t). If there really is an operator== in any of your classes, that needs to receive at least one of its argument as a writeable rvalue reference, then the signature would be correct, but the arguments in the function body should be forwarded via std::forward<First>(first) and std::forward<T>(t).

[Admin]

@underscore_d unless we realize that globals exist and are perfect for cases like this.

[underscore_d]

@KaiPetzke Right. Perfect forwarding seems unnecessary here, as const& binds just fine to temporaries and extends their lifetime for as long as required.

[underscore_d]

@Sahsahae I disagree. For the case of comparing against a small set of known values as a one-off, a set or any other dynamically allocated container is wasteful, and adding a global variable is irresponsible. For the actual question asked, comparing to a set of known constants, a variadic in() function using fold expressions is far superior.

[Ruslan]

You don't have to copy T into d_: the Is struct could simply hold a reference.

[Adrian Mole]

Note that, from C++20 onwards, there is std::set.contains().