If statement 如果条件A匹配，则需要匹配条件B才能执行操作C

我的问题是:

if（/*条件A*/）
{
如果（/*条件B*/）
{
/*做动作C*/
}
其他的
/* ... */
}
其他的
{
/*做动作C*/
}

是否可以只编写一次而不是两次操作C的代码

---

如何简化它？

您可以这样简化语句：

if ((A && B) || (!A)) // or simplified to (!A || B) as suggested in comments
{
    do C
}

否则，将“C”的代码放在单独的函数中并调用它：

DoActionC()
{
    ....
    // code for Action C
}
if (condition A)
{
    if(condition B)
      {
         DoActionC(); // call the function
      }
    else
      ...
}
else
{
   DoActionC(); // call the function
}

您有两个选择：

编写一个执行“动作C”的函数

重新安排逻辑，这样就不会有那么多嵌套的if语句。问问自己是什么条件导致“行动C”发生的。在我看来，当“条件B”为真或“条件A”为假时，这种情况就会发生。我们可以把它写成“不是A或B”。将其转换为C代码，我们得到

if (!A || B) {
    action C
} else {
    ...
}

为了进一步了解这类表达式，我建议在谷歌上搜索“布尔代数”、“谓词逻辑”和“谓词演算”。这些都是深奥的数学主题。你不需要全部学习，只需要基本知识

---

您还应该了解“短路评估”。因此，表达式的顺序对于精确复制原始逻辑非常重要。而

B | |！A

在逻辑上是等价的，当

B

为真时，无论

A

的值如何，使用此条件将执行“动作C”，这也让我感到困惑，但由于我们保证需要

执行动作C

或运行嵌套的-

else

块，因此代码可以简化为：

if (not condition A or condition B) {
    do action C
} else {
    ...
}

这就是我们处理3个案例的方式：

问题逻辑中嵌套的

do action C

要求

条件A

和

条件B

在此逻辑中为

真

，如果我们在

if

-语句中达到第二项，那么我们知道

条件A

是

真的

，因此我们需要评估的是

条件B

是

真的

问题逻辑中嵌套的

else

-块要求

条件A

为

真

和

条件B

为

假

——如果

条件A

为

真

和

条件B

为假，我们在这个逻辑中达到

else

-块的唯一方法是

false

问题逻辑中的外部

else

-块要求

条件A

为

假

——在该逻辑中，如果

条件A

为假，我们也

执行动作C

---

这是《代码学徒》的道具，让我明白了这一点。我建议接受，因为他在没有编辑的情况下正确地呈现了它：//

在这类问题上，你的第一步总是要做一个逻辑表

A | B | Result
-------------------
T | T | do action C
T | F | ...
F | T | do action C
F | F | do action C

一旦你做了表格，解决方案就很清楚了

if (A && !B) {
  ...
}
else {
  do action C
}

---

请注意，这种逻辑虽然较短，但对于未来的程序员来说可能很难维护。

在使用模式匹配的语言时，您可以用更直接地反映问题C答案中的真值表的方式来表达解决方案

match (a,b) with
| (true,false) -> ...
| _ -> action c

如果您不熟悉语法，每个模式都由a表示，后跟要匹配的值（a，b），下划线用作通配符，表示“任何其他值”。因为我们想要做动作c以外的事情的唯一情况是a为真，b为假，所以我们显式地将这些值声明为第一个模式（真，假），然后在这种情况下做任何应该做的事情。在所有其他情况下，我们采用“通配符”模式并执行操作c。

问题陈述：

如果条件A匹配，则需要匹配条件B才能执行操作C

描述：A意味着B，一个相当于

的逻辑命题！A | | B

（如其他答案所述）：

---

尽管已经有了很好的答案，但我认为这种方法对于刚接触布尔代数的人来说可能比计算真值表更直观

您要做的第一件事是查看，在什么条件下您要执行C。当

（a&b）

时就是这种情况。也当

时！a

。 所以你有

（a&b）|！a

如果你想最小化，你可以继续。就像在“普通”算术中一样，你可以乘出

（a&b）|！a=（a |！a）和（b |！a）

。 a |！a总是真的，所以你可以把它划掉，这样你就得到了最小化的结果：

b |！a

。 如果订单有所不同，因为您只想在以下情况下检查b！a为true（例如，当！a为空指针检查，b为指针上的操作，如@LordFarquaad在其评论中指出的），您可能需要切换这两个选项

另一种情况（/*…*/）是在不执行c时始终执行的，因此我们可以将其放在else情况下

另外值得一提的是，将操作c放入方法中可能是有意义的

这给我们留下了以下代码：

if (!A || B)
{
    doActionC()  // execute method which does action C
}
else
{
   /* ... */ // what ever happens here, you might want to put it into a method, too.
}

---

通过这种方式，您还可以使用更多的操作数最小化项，这在真值表中很快变得难看。另一个好方法是卡诺图。但是我现在不会深入讨论这个问题。

我会将C提取到一个方法中，然后在所有情况下尽快退出该函数

else

如果可能的话，结尾只有一个东西的子句应该几乎总是颠倒过来。下面是一个循序渐进的示例：

摘录C：

if（A）{
如果（B）
C（）；
其他的
D（）；
}否则
C（）；

如果要除去第一个

否则，请反转第一个
：

if（！A）{
C（）；
返回；
}
如果（B）
C（）；
其他的
D（）；

摆脱第二个
否则
：

if（！A）{
C（）；
返回；
}
如果（B）{
C（）；
返回；
} 
D（）；

然后你可以注意到这两个案例有着相同的主体，可以合并：

if（！A | | B）{
C（）
if (!A || B)
{
    doActionC()  // execute method which does action C
}
else
{
   /* ... */ // what ever happens here, you might want to put it into a method, too.
}

bool do_action_C;

// Determine whether we need to do action C or just do the "..." action
// If condition A is matched, condition B needs to be matched in order to do action C
if (/* condition A */)
{
    if(/* condition B */)
      do_action_C = true; // have to do action C because blah
    else
      do_action_C = false; // no need to do action C because blarg
}
else
{
  do_action_C = true; // A is false, so obviously have to do action C
}

if (do_action_C)
  {
     DoActionC(); // call the function
  }
else
  {
  ...
  }

if(!a || b)
{
   // Do action C
}

if((A && B ) || !A)
{
  //do C
}
else if(!B)
{
  //...
}

int flag = 1; 
if ( condition A ) {
    flag = 2;
    if( condition B ) {
        flag = 3;
    }
}
if(flag != 2) { 
    do action C 
}