C++ 关于if区块案例的排他性

我有一个关于良好编码实践的问题。我理解执行一个

if else if

和多个

if

s之间的区别（即，当

if else if

中满足一个条件时，将跳过其余检查）。我发现了一段代码，大致如下：

if (A == 5) {
    do_something();
} else if (B == 7) {
    do_something_else();
}

我知道如果A==5，这段代码不会检查B==7。代码是有效的，这意味着B只有7，如果A不是5，但我认为这只是等待代码更改时中断。我要做的是：

if (A == 5) {
    do_something();
    return or continue or break;
}
if (B == 7) {
    do_something_else();
    return or continue or break;
}

---

我的问题是，当我有多个依赖于不同的互斥变量的互斥情况时，处理流控制的最佳方法是什么？我的印象是，第一个代码（使用else-ifs）在很大程度上依赖于其他代码的工作，其他领域的更改可能会破坏它。第二个似乎有点笨重。开关可能是第三种选择，但我需要创建另一个结构来保存案例和分配其值的逻辑，我认为这会有点笨重和违反直觉。

正如我想你知道的，这两段代码并不等价。（如果它们都包含“返回或继续或中断”，则它们等价于，这使问题更有趣，但这是一个不同的答案。）

通常，您选择哪一个（或如何选择重写它）必须完全取决于您希望程序执行的操作

当你写作时

if (A == 5) {
    do_something();
} else if (B == 7) {
    do_something_else();
}

另外，您还说，只有当

A

不等于5时，您才想

做其他事情。这可能正是您想要的，也可能是一个bug。如果您希望在没有
else
的情况下实现相同的效果，则必须如下所示：

if (A == 5) {
    do_something();
}

if (A != 5 && B == 7) {
    do_something_else();
}

另一方面，您在问题中编写的第二段代码可能同时执行
do\u something
和
do\u something\u other

一般来说，如果if/else链测试中的所有条件都在相同条件下变化，而不是一些不寻常的混合，例如，
A
和
B
，则最好（最清晰、最容易混淆）

当备选方案是真正故意排他性的，并且想要强调这一事实时，您可以使用if/else块。当备选方案不是独占的，或者它们只是巧合或意外地独占时，您可以选择使用单独的
if
块（不与
else
链接）。例如，我特意编写了如下代码

if(A == 5) {
    do_something();
}

if(A != 5) {
    do_some_unrelated_thing();
}

当这两件事互不相关时，我可能会这样做，这意味着在未来对程序逻辑的某些修订中，它们可能毕竟不是排他性的。或者，如果
dou\u something
不是一个单一的类，而是一个长而复杂的块，那么我可能会这样做，在最后，我担心读者可能不记得我们为什么要做或没有做某事，而另一方面，我们可能想做其他事情。出于类似的原因，我偶尔也会写信

if(A == 5) {
    do_something();
}

if(A == 5) {
    do_some_unrelated_thing();
}

在这种情况下，要做的两件事又一次与对方无关，而且做它们的原因可能会有分歧。
正如我想你知道的，这两段代码是不等价的。（如果它们都包含“返回或继续或中断”，则它们等价于，这使问题更有趣，但这是一个不同的答案。）

通常，您选择哪一个（或如何选择重写它）必须完全取决于您希望程序执行的操作

当你写作时

if (A == 5) {
    do_something();
} else if (B == 7) {
    do_something_else();
}

另外，您还说，只有当
A
不等于5时，您才想
做其他事情。这可能正是您想要的，也可能是一个bug。如果您希望在没有
else
的情况下实现相同的效果，则必须如下所示：

if (A == 5) {
    do_something();
}

if (A != 5 && B == 7) {
    do_something_else();
}

另一方面，您在问题中编写的第二段代码可能同时执行
do\u something
和
do\u something\u other

一般来说，如果if/else链测试中的所有条件都在相同条件下变化，而不是一些不寻常的混合，例如，
A
和
B
，则最好（最清晰、最容易混淆）

当备选方案是真正故意排他性的，并且想要强调这一事实时，您可以使用if/else块。当备选方案不是独占的，或者它们只是巧合或意外地独占时，您可以选择使用单独的
if
块（不与
else
链接）。例如，我特意编写了如下代码

if(A == 5) {
    do_something();
}

if(A != 5) {
    do_some_unrelated_thing();
}

当这两件事互不相关时，我可能会这样做，这意味着在未来对程序逻辑的某些修订中，它们可能毕竟不是排他性的。或者，如果
dou\u something
不是一个单一的类，而是一个长而复杂的块，那么我可能会这样做，在最后，我担心读者可能不记得我们为什么要做或没有做某事，而另一方面，我们可能想做其他事情。出于类似的原因，我偶尔也会写信

if(A == 5) {
    do_something();
}

if(A == 5) {
    do_some_unrelated_thing();
}

在这种情况下，要做的两件事又一次互不相关，而且做这两件事的原因可能会有分歧。
最可靠的编程方法，

在避免“<代码> A=＝5 < /代码>或<代码> B=＝7 < /代码>的前提下，考虑所有四种情况：

if ((A == 5) && (B == 7))
{
    do_somethingAB();
    /* or */
    do_somethingA();
    do_somethingB();
} else if (A == 5)
{
    do_somethingA();
} else if (B == 7)
{
    do_somethingB();
} else
{
    do_somethingNeither();
    /* or
       do nothing */
}

if(A == 5) {
    if(B == 7) {
        /* case 1 */
    } else {
        /* case 2 */
    }
} else {
    if(B == 7) {
        /* case 3 */
    } else {
        /* case 4 */
    }
}

最健壮的编程方式，

在避免“<代码> A=＝5 < /代码>或<代码> B=＝7 < /代码>的前提下，考虑所有四种情况：

if ((A == 5) && (B == 7))
{
    do_somethingAB();
    /* or */
    do_somethingA();
    do_somethingB();
} else if (A == 5)
{
    do_somethingA();
} else if (B == 7)
{
    do_somethingB();
} else
{
    do_somethingNeither();
    /* or
       do nothing */
}

if(A == 5) {
    if(B == 7) {
        /* case 1 */
    } else {
        /* case 2 */
    }
} else {
    if(B == 7) {
        /* case 3 */
    } else {
        /* case 4 */
    }
}

您询问了“独占”案例，但条件
A==5
和
B==7
的问题在于它们不是独占的；他们是独立的

为了获得全面的通用性，您可能需要测试和处理所有四种情况：

if ((A == 5) && (B == 7))
{
    do_somethingAB();
    /* or */
    do_somethingA();
    do_somethingB();
} else if (A == 5)
{
    do_somethingA();
} else if (B == 7)
{
    do_somethingB();
} else
{
    do_somethingNeither();
    /* or
       do nothing */
}

if(A == 5) {
    if(B == 7) {
        /* case 1 */
    } else {
        /* case 2 */
    }
} else {
    if(B == 7) {
        /* case 3 */
    } else {
        /* case 4 */
    }
}

这就是臭名昭著的“浓密”if/else块。这是臭名昭著的，因为它可以
do {
    if (A == 5) {
        do_something();
        break;
    }

    if (B == 7) {
        do_something_else();
        break;
    }

    if (C == 9) {
        do_something_else_again();
        break;
    }

    if (D == 3) {
        do_something_for_D();
        break;
    }
} while (0);

#define ABORTME(msg_) \
    do { \
        printf(stderr,"ABORT: %s (at line %d)\n",msg_,__LINE__); \
        dump_some_state_data(); \
        exit(1); \
    } while (0)

if (some_error_condition)
    ABORTME("some_error_condition");