基于两个布尔变量的分支

Question

假设我有两个布尔变量，并且我想根据它们的值做完全不同的事情。实现这一目标的最干净的方法是什么？

变体 1：

if (a && b)
{
    // ...
}
else if (a && !b)
{
    // ...
}
else if (!a && b)
{
    // ...
}
else
{
    // ...
}

变体 2：

if (a)
{
    if (b)
    {
        // ...
    }
    else
    {
        // ...
    }
}
else
{
    if (b)
    {
        // ...
    }
    else
    {
        // ...
    }
}

变体 3：

switch (a << 1 | b)
{
case 0:
    // ...
    break;

case 1:
    // ...
    break;

case 2:
    // ...
    break;

case 3:
    // ...
    break;
}

变体 4：

lut[a][b]();

void (*lut[2][2])() = {false_false, false_true, true_false, true_true};

void false_false()
{
    // ...
}

void false_true()
{
    // ...
}

void true_false()
{
    // ...
}

void true_true()
{
    // ...
}

变体 3 和 4 是否过于棘手/复杂普通程序员？我错过了任何其他变体吗？

Answer 1

第一个变体是最清晰、最易读的，但可以调整：

if (a && b) {
    // ...
} else if (a) { // no need to test !b here - b==true would be the first case
    // ...
} else if (b) { //no need to test !a here - that would be the first case
    // ...
} else { // !a&&!b - the last remaining
    // ...
}

Answer 2

您忘记了：

if (a) a_true(b);
else a_false(b);

当适用且您确实需要 4 种不同的行为时，这可能是最佳选择。

如果你有超过 2 个布尔值，如果我有 2^n 种不同的行为，而这些行为不能像上面那样很好地分解，我会将其视为代码味道。然后我可能会考虑这样做：

enum { case1, case2, ... }

int dispatch_cases(bool a, bool b, bool c, ..., bool z);

switch (dispatch_cases(a, b, ..., z))
{
case case1:
    ...
};

但是没有上下文，很难判断这样的复杂性是否有必要。

Answer 3

恕我直言，我会选择变体3。因为就我个人而言，当我检查相等性时，我不喜欢 if/else。它明确指出只有4种可能性。

一个小的修改是：

inline int STATES(int X, int Y) { return (X<<1) | Y; }
// ...
switch (STATES(a,b))

为了使其更奇特，您也可以将 0,1,2,3 替换为 enum 。

enum States {
  NONE,
  ONLY_B.
  ONLY_A,
  BOTH
}; 

Answer 4

对于只有两个布尔值的情况，其中任何一个都是好的且合理的。大家可以根据自己的口味来选择。

但是，如果有两个以上的布尔值，例如四个布尔值，那么我个人会使用查找表，并且我会这样做：

typedef void (*functype)();

//16 functions to handle 16 cases!
void f0() {}
void f1() {}
//...so on
void f15() {}

//setup lookup table
functype lut[] = 
{
    f0,   //0000 - means all bool are false
    f1,   //0001
    f2,   //0010
    f3,   //0011
    f4,   //0100
    f5,   //0101
    f6,   //0110
    f7,   //0111
    f8,   //1000
    f9,   //1001
    f10,  //1010
    f11,  //1011
    f12,  //1100
    f13,  //1101
    f14,  //1110
    f15   //1111 - means all bool are true
};

lut[MakeInt(b1,b2,b3,b4)](); //call

MakeInt() 很容易写：

int MakeInt(bool b1, bool b2, bool b3, bool b4)
{
   return b1 | (b2<<1) | (b3 <<2) | (b4<<3);
}