Raccourcir la condition pour vérifier que x n'est pas l'un des quatre nombres

Question

Y a-t-il un moyen de raccourcir la condition de cette déclaration if ?

int x;
if (x != 3 && x != 8 && x != 87 && x != 9){
  SomeStuff();
}

Je pense à quelque chose du genre :

if (x != 3, 8, 87, 9) {}

Mais j'ai essayé et ça ne marche pas. Dois-je simplement l'écrire de la manière longue ?

Answer 1

Si vous voulez savoir si un entier se trouve dans un ensemble donné d'entiers, utilisez std::set:

std::set accept { 1, 4, 6, 8, 255, 42 };
int x = 1;

if (!accept.count(x))
{
    // ...
}

Answer 2

Juste pour être exhaustif, je vais proposer d'utiliser un switch :

switch (x) {
    case 1:
    case 2:
    case 37:
    case 42:
        break;
    default:
        SomeStuff();
        break;
}

Bien que ce soit assez verbeux, cela ne évalue x qu'une seule fois (s'il s'agit d'une expression) et génère probablement le code le plus efficace parmi toutes les solutions.

Answer 3

Voici ma solution en utilisant un modèle varadic. Les performances d'exécution sont aussi efficaces que d'écrire manuellement x != 3 && x != 8 && x != 87 && x != 9.

template 
bool not_equal(const T& t, const U& u) {
  return t != u;
}

template 
bool not_equal(const T& t, const U& u, const Vs&... vs) {
  return t != u && not_equal(t, vs...);
}

int main() {
  std::cout << not_equal( 3, 3, 8, 87, 9) << std::endl;
  std::cout << not_equal( 8, 3, 8, 87, 9) << std::endl;
  std::cout << not_equal(87, 3, 8, 87, 9) << std::endl;
  std::cout << not_equal( 9, 3, 8, 87, 9) << std::endl;
  std::cout << not_equal(10, 3, 8, 87, 9) << std::endl;
}

Depuis C++17, l'implémentation peut être simplifiée en utilisant des expressions fold:

template 
bool not_equal(const T& t, const Vs&... vs) {
  return ((t != vs) && ...);
}

Answer 4

Que diriez-vous de ceci:

#include <iostream>
#include <initializer_list>
#include <algorithm>

template <typename T>
bool in(const T t, const std::initializer_list<T> & l) {
    return std::find(l.begin(), l.end(), t) != l.end();
}

int main() {
  std::cout << !in(3, {3, 8, 87, 9}) << std::endl;
  std::cout << !in(87, {3, 8, 87, 9}) << std::endl;
  std::cout << !in(10, {3, 8, 87, 9}) << std::endl;
}

ou en surchargeant operator!=:

template<typename T>
bool operator!=(const T t, const std::vector<T> & l) {
    return std::find(l.begin(), l.end(), t) == l.end();
}

int main() {
  std::cout << ( 3!=std::vector<int>{ 3, 8, 87, 9}) << std::endl;
  std::cout << ( 8!=std::vector<int>{ 3, 8, 87, 9}) << std::endl;
  std::cout << (10!=std::vector<int>{ 3, 8, 87, 9}) << std::endl;
}

Malheureusement pour le moment, les analyseurs n'aiment pas avoir initializer_list en argument des opérateurs, il n'est donc pas possible de se débarrasser de std::vector dans la deuxième solution.

Answer 5

Si vous ne voulez pas répéter cette condition encore et encore, utilisez une macro.

#include 

#define isTRUE(x, a, b, c, d)  ( x != a && x != b && x != c && x != d ) 

int main() 
{
    int x(2);
    std::cout << isTRUE(x,3,8,87,9) << std::endl;

    if ( isTRUE(x,3,8,87,9) ){
        // SomeStuff();
    }
    return 0;
}