How do I check if a variable is not equal to multiple things in C++?

Question

I'm writing a piece of my code that checks whether what the user has entered is actually one of the valid inputs (1-9 in this case), and will give an error message if it isn't.

This is what I have:

if (input != '1', '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , '0' )
    {
      cout << "Error";
    }

But it doesn't seem to work. I thought I could use commas to separate them, but maybe I'm imagining that.

Is the only option to just do:

input != '1' && input != '2' && input != '3' etc etc

I know that method would work, but it seems a bit long winded. Is there a simpler way?

Answer 1

You can store the values in a container and utilize the std::find_if, std::none_of or std::any_of functions:

#include <iostream>
#include <vector>
#include <algorithm>

int main()
{
    std::vector<char> v = { '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' };
    char input = '1';
    if (std::none_of(v.cbegin(), v.cend(), [&input](char p){ return p == input; })) {
        std::cout << "None of the elements are equal to input.\n";
    } 
    else {
        std::cout << "Some of the elements are equal to input.\n";
    }
 }

Answer 2

How do I check if a variable is not equal to multiple things

Is the only option to just do:

input != '1' && input != '2' && input != '3' etc etc

In the general case, for an arbitrary set of values: No, that is not the only option, but it is the simplest. And simplest is often best, or at least good enough.

If you dislike the redundant repetition of input !=, a variadic template can be used to generate the expression. I've written an example of this in another question: https://stackoverflow.com/a/51497146/2079303

In specific cases, there may be better alternatives. There exists std::isdigit for example for exactly the particular case in your example code.

In order to check if a variable is (not) equal to mutliple things which are not known until runtime, the typical solution is to use a set data structure, such as std::unordered_set.

Answer 3

If you are looking for a more general and human-readable construct, you can create something like this:

template <typename T, int TSize>
struct AnyOfThis {    
    template <typename TFirst, typename... TOthers>
    explicit AnyOfThis(TFirst&& first, TOthers&&... others)
        : values({ std::forward<TFirst>(first), std::forward<TOthers>(others)... }) {}

    std::array<T, TSize> values;
};

template <typename TFirst, typename... TOthers>
auto anyOf(TFirst&& first, TOthers&&... others) {
    constexpr std::size_t size = 1 + sizeof...(others);
    return AnyOfThis<typename std::decay<TFirst>::type, size>(std::forward<TFirst>(first),
                                                              std::forward<TOthers>(others)...);
}

template <typename T, int TSize>
bool operator==(const T value, const AnyOfThis<typename std::decay<T>::type, TSize>& anyOfThis) {
    return std::find(anyOfThis.values.begin(), anyOfThis.values.end(), value) != anyOfThis.values.end();
}

Basically, it creates a static array from a variadic function. Then there is another function which serves as a comparator, which takes the value you want to compare and looks for this value in the array.

The use-case reads fairly well, too:

if (1 == anyOf(1, 2, 3)) {
    // do stuff
}

---

LIVE DEMO AT COLIRU

Answer 4

simple and efficient way would be.

std::unordered_set<char> allowedValues = {'1','2','3','4','5','6','7','8','9','0'};
std::unordered_set<char>::const_iterator index = allowedValues.find(input);
if(index == allowedValues.end())
  std::cout << "Error";
else
  std::cout << "Valid";

by using unordered set you expect O(1) complexity for lookup. It is good when input number is high. If your index is equal to end of set it does not exist in the list, you will get end of set as index which is invalid input for you. otherwise you will count it as a valid input

Answer 5

If you are looking for "if a string is not equal to multiple strings in C" you may use the following (Not everyone would consider it elegant, but if you are fond of good old c-str then you may find it nice. Surely, it is simple and fast):

int GetIdxOfStringInOptionList (const char *Xi_pStr)
{
    char l_P2[205];
    sprintf(l_P2, "<@%s^>", Xi_pStr);  // TODO: if (strlen>=200) return -1. Note that 200 is above length of options string below
    _strlwr(l_P2);                     // iff you want comparison to be case insensitive
    const char *l_pCO = strstr("01<@gps^>02<@gps2^>03<@log^>04<@img^>05<@nogps^>06<@nogps2^>07<@gps3^>08<@pillars0^>09<@pillars1^>10<@pillars2^>11<@pillars3^>", l_P2);
    return l_pCO? atoi(l_pCO-2) : -1;
}