Question

我正在寻找一种控制结构来处理潜在的多个代码块或 NONE 块。最基本的情况是只有两个条件， A 和 B ：

+-------+-------+------------+
|   A   |   B   | Blocks Run |
+-------+-------+------------+
| false | false | C          |
| false | true  | B          |
| true  | false | A          |
| true  | true  | A + B      |
+-------+-------+------------+

到目前为止，我所做的最好的事情是：

if( A )
{
    // Run Block A
}

if( B )
{
    //Run Block B
}
else if( !A )
{
    //Run Block C
}

Answer 1

如果只是最大限度地减少使用表格的比较是唯一的方法。

switch ((B << 1) | A)
{
  case 0:
    // C
    break;

  case 0b01: // case 1:
    // A
    break;

  case 0b10: // case 2:
    // B
    break;

  case 0b11: // case 3:
    // A
    // B
    break;

  default:
    // Shouldn't arrive here.
    break;
}

Answer 2

为清楚起见，我将重命名你的条件P和Q（正如propositional logic中的惯例）

if( P || Q)
{
    P && A();
    Q && B();
}
else
{
    C();
}

编辑：

添加更多支票非常简单：

if( P || Q || R || S)
{
    P && A();
    Q && B();
    R && D();
    S && E();
}
else
{
    C();
}

评论后编辑：

那怎么样。

int runC = 1;
P && (runC=0, A());
Q && (runC=0, B());
R && (runC=0, D());
S && (runC=0, E());
runC && C();

Answer 3

如果您只想评估每个条件一次：

if (a) {
  A();
  if (b) {
    B();
  }
} else if (b) {
  B();
} else {
  C()
}

但是，我不认为它比你的代码好多了。虽然它只评估条件一次，但代码块执行现在是重复的。据我所知，你要么必须两次评估一个条件，要么两次写一个代码块。在这种情况下，我更喜欢评估条件并将它们保存到变量中，然后按照您的示例：复制代码块比读取变量两次更糟糕（大多数情况下，拥有可以理解的代码更重要当你没有测量它是一个瓶颈时，维持而不是试图“优化”它。

Answer 4

您希望在条件A时运行块A，在条件B时运行块B，依此类推。有一个例外：当没有满足条件时，执行NONE块。对？然后：

if( !A && !B && !C && ...)
{
  run NONE-BLOCK;
}
else
{
  if( A ) run A-BLOCK;
  if( B ) run B-BLOCK;
  if( C ) run C-BLOCK;
  ...
}

运行A然后运行B或运行C.

4 个答案: