有没有一种方法可以缩短这种情况？

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
}

为了清楚起见：temp是一个指向以下node结构的指针：

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

Answer 1

当然，您可以只使用一串有效的运算符并进行搜索。

#include <cstring>

// : :

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

如果您担心性能，那么也许进行表查找：

#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

是的，的确可以！

将有效字符存储到一个std::array或什至一个普通数组，然后将标准算法应用于该数组std::any_of以检查条件。

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

const std::array<char, 4> options{ '+', '-', '*', '/' };
const auto tester = [&temp](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
}

可以通过打包到接受node要检查的对象的函数中来对其进行清理。

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

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

可以在 while-loop

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

Answer 3

创建一个子函数，

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

然后：

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

Answer 4

C样式：

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

// Do something如果要声明变量，则可能需要用大括号括起来。

Answer 5

您可以构造一个包含选项的字符串并搜索字符：

#include <string>

// ...

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

的"+-*/"s是一个C ++ 14功能。std::string ops = "+-*/";在C ++ 14之前使用。

Answer 6

编程是寻找冗余并消除冗余的过程。

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

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
}

这里的“重复单元”是什么？好吧，我看到了两个实例

   (something)->oper == '+' || 
   (something)->oper == '-' || 
   (something)->oper == '*' || 
   (something)->oper == '/'

因此，让我们将重复的部分分解为一个函数，这样我们只需要编写一次即可。

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

    bool oper_is_arithmetic() const {
        return this->oper == '+' || 
               this->oper == '-' || 
               this->oper == '*' || 
               this->oper == '/';
    }
};

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

- 缩短！
（原始代码：17行，其中8个为循环条件。修订后的代码：18行，其中2个为循环条件。）