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

我的问题是：

if (/* condition A */)
{
    if(/* condition B */)
      {
         /* do action C */
      }
    else
      /* ... */
}
else
{
   /* do action C */
}

是否可以只编写一次而不是编写两次动作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
}

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

您有两种选择：

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

2. 重新排列逻辑，以使您没有那么多的嵌套if语句。问自己，什么情况导致“动作C”发生。在我看来，它发生在“条件B”为真或“条件A”为假时。我们可以将其写为“ NOT A OR B”。将其转换为C代码，我们得到

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

要了解有关此类表达式的更多信息，建议使用谷歌搜索“布尔代数”，“谓词逻辑”和“谓词演算”。这些是深刻的数学主题。您不需要学习所有内容，而只是基础知识。

您还应该了解“短路评估”。因此，表达式的顺序对于精确复制原始逻辑很重要。尽管B || !A在逻辑上是等效的，但使用Btrue 作为条件将与条件无关地执行“动作C” A。

您可以像这样简化语句：

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
}

在具有模式匹配的语言中，您可以以更直接地反映QuestionC答案中的真值表的方式来表达解决方案。

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

如果您不熟悉语法，则每个模式都由|表示。后跟与（a，b）匹配的值，下划线用作通配符，表示“其他任何值”。因为除了动作c之外，我们唯一想做其他事情的情况是a为true而b为false时，我们将这些值明确声明为第一个模式（true，false），然后在这种情况下应做的事情。在所有其他情况下，我们陷入“通配符”模式并执行操作c。

问题陈述：

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

描述含义：A暗含B，这是一个等同于逻辑命题的逻辑命题!A || B（如其他答案所述）：

bool implies(bool p, bool q) { return !p || q; }

if (implies(/* condition A */,
            /* condition B */))
{
    /* do action C */
}

gh，这也让我感到震惊，但是正如Code-Apprentice所指出的，我们保证需要do action C或运行nested- elseblock，因此可以将代码简化为：

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

这是我们处理3种情况的方式：

1. 嵌套do action C在你的问题的逻辑要求condition A，并condition B为true-在这样的逻辑，如果我们达到2 ^次的术语if语句来那么我们就知道condition A是true这样，所有我们需要评估的是，condition B是true
2. 嵌套else在你的问题的逻辑-阻塞要求condition A是true和condition B是false-我们能够达到的唯一方法else在这种逻辑-阻塞是，如果condition A是true和condition B人false
3. else您问题逻辑中的外层块必须condition A为false-在此逻辑中，如果condition A为假，我们也do action C

向代码学徒提出的建议，请他们在这里整理我。我建议接受他的答案，因为他正确地给出了答案而无需编辑：/

在逻辑概念中，可以按以下方式解决此问题：

f = ab +！a
f =？

作为一个已证明的问题，这导致f = !a + b。有一些方法可以证明问题，例如真值表，卡诺地图等。

因此，在基于C的语言中，您可以按以下方式使用：

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

PS：卡诺地图也可用于更复杂的一系列条件。这是一种简化布尔代数表达式的方法。

即使已经有了好的答案，我认为对于刚接触布尔代数然后评估真值表的人来说，这种方法可能更加直观。

你想要做的第一件事是看，在什么条件下要执行C.这是时的情况(a & b)。也当!a。所以你有(a & b) | !a。

如果要最小化，可以继续。就像在“常规”算术中一样，您可以相乘。

(a & b) | !a = (a | !a) & (b | !a)。一个| ！a始终是正确的，因此您可以将其删除，从而使结果最小化b | !a。如果顺序有所不同，因为仅当！a为真时才想检查b（例如，当！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.
}

这样，您还可以使用更多操作数来最小化术语，而事实表会很快使它们变得丑陋。另一个好的方法是卡诺地图。但是我现在不会更深入地介绍这一点。

为了使代码看起来更像文本，请使用布尔标志。如果逻辑特别不清楚，请添加注释。

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 ) || !A)
{
  //do C
}
else if(!B)
{
  //...
}

我将C提取到方法中，然后在所有情况下尽快退出函数。else如果可能的话，结尾处只有一个东西的子句应该几乎总是被反转。这是一个分步示例：

提取物C：

if (A) {
   if (B)
      C();
   else
      D();
} else
   C();

首先反转if以摆脱第一else：

if (!A) {
   C();
   return;
}

if (B)
   C();
else
   D();

摆脱第二else：

if (!A) {
   C();
   return;
}

if (B) {
   C();
   return;
} 

D();

然后您会注意到这两种情况具有相同的主体并且可以组合：

if (!A || B) {
   C();
   return;
}

D();

可选的改进方法是：

• 取决于上下文，但是如果!A || B令人困惑，请将其提取到一个或多个变量中以解释意图

• 非例外情况中的哪一个C()或哪个D()应最后处理，因此，如果D()是例外情况，则if最后一次反转

使用标志也可以解决此问题

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