Existe-t-il un moyen de raccourcir cette condition ?

Question

while (temp->left->oper == '+' || 
       temp->left->oper == '-' || 
       temp->left->oper == '*' || 
       temp->left->oper == '/' || 
       temp->right->oper == '+' || 
       temp->right->oper == '-' || 
       temp->right->oper == '*' || 
       temp->right->oper == '/')
{
    // do something
}

Pour plus de clarté : temp est un pointeur qui pointe vers le suivant node structure :

struct node
{
    int num;
    char oper;
    node* left;
    node* right;
};

Answer 1

Bien sûr, vous pourriez simplement utiliser une chaîne d'opérateurs valides et la rechercher.

#include <cstring>

// : :

const char* ops = "+-*/";
while(strchr(ops, temp->left->oper) || strchr(ops, temp->right->oper))
{
     // do something
}

Si vous êtes préoccupé par les performances, alors peut-être que les consultations de table :

#include <climits>

// : :

// Start with a table initialized to all zeroes.
char is_op[1 << CHAR_BIT] = {0};

// Build the table any way you please.  This way using a string is handy.
const char* ops = "+-*/";
for (const char* op = ops; *op; op++) is_op[*op] = 1;

// Then tests require no searching
while(is_op[temp->left->oper] || is_op[temp->right->oper])
{
     // do something
}

Answer 2

Oui, en effet, vous le pouvez !

Stocker les caractères valides dans un fichier std::array ou même un tableau simple et appliquer l'algorithme standard std::any_of pour vérifier la condition.

#include <array>     // std::array
#include <algorithm> // std::any_of

static constexpr std::array<char, 4> options{ '+', '-', '*', '/' };
const auto tester = [temp](const char c) { return temp->left->oper == c || temp->right->oper == c; };
const bool isValid = std::any_of(options.cbegin(), options.cend(), tester);

while(isValid) // now the while-loop is simplified to
{
    // do something
}

---

Cela peut être plus propre en l'emballant dans une fonction, qui accepte l'élément node l'objet à vérifier.

#include <array>     // std::array
#include <algorithm> // std::any_of

bool isValid(const node *const temp) /* noexcept */
{
   static constexpr std::array<char, 4> options{ '+', '-', '*', '/' };
   const auto tester = [temp](const char c) { return temp->left->oper == c || temp->right->oper == c; };
   return std::any_of(options.cbegin(), options.cend(), tester);
}

qui peut être appelé dans le while-loop

while (isValid(temp)) // pass the `node*` to be checked
{
    // do something
}

Answer 3

Créez une sous-fonction,

bool is_arithmetic_char(char)
{
// Your implementation or one proposed in another answers.
}

et ensuite :

while (is_arithmetic_char(temp->left->oper)
    || is_arithmetic_char(temp->right->oper))
{
    // do something
}

Answer 4

Le style C :

int cont = 1;
while(cont)
    switch(temp->left->oper) {
    case '+':
    case '-':
    ...
    case '/':
        // Do something
        break;
    default:
        cont = 0;
    }

Vous devrez peut-être joindre // Do something avec des accolades si vous voulez déclarer des variables.

Answer 5

Vous pouvez construire une chaîne qui contient les options et rechercher le caractère :

#include <string>

// ...

for (auto ops = "+-*/"s; ops.find(temp-> left->oper) != std::string::npos ||
                         ops.find(temp->right->oper) != std::string::npos;)
    /* ... */;

El "+-*/"s est une fonctionnalité du C++14. Utilisez std::string ops = "+-*/"; avant C++14.