C++ 嵌套ifs与串行逻辑块

我试图从代码中删除重复的行。目前看起来是这样的：

if (FALSE == DoFoo(strFile1, strData1))
{
    return (FALSE);
}
if (FALSE == DoFoo(strFile2, strData1))
{
    return (FALSE);
}
if (FALSE == DoFoo(strFile3, strData1))
{
    return (FALSE);
}
if (FALSE == DoBar(strData1))
{
    return (FALSE);
}
if (FALSE == DoFoo(strFile4, strData2))
{
    return (FALSE);
}
if (FALSE == DoFoo(strFile5, strData2))
{
    return (FALSE);
}
if (FALSE == DoFoo(strData1, strData2))
{
    return (FALSE);
}
if (FALSE == DoBar(strData2))
{
    return (FALSE);
}
return (TRUE);

if (DoFoo(strFile1, strData1))
{
    if (DoFoo(strFile2, strData1))
    {
        if (DoFoo(strFile3, strData1))
        {
            if (DoBar(strData1))
            {
                if (DoFoo(strFile4, strData2))
                {
                    if (DoFoo(strFile5, strData2))
                    {
                        if (DoFoo(strData1, strData2))
                        {
                            if (DoBar(strData2))
                            {
                                return (TRUE);
                            }
                        }
                    }
                }
            }
        }
    }
}
return (FALSE);

我把它改成这样：

if (FALSE == DoFoo(strFile1, strData1))
{
    return (FALSE);
}
if (FALSE == DoFoo(strFile2, strData1))
{
    return (FALSE);
}
if (FALSE == DoFoo(strFile3, strData1))
{
    return (FALSE);
}
if (FALSE == DoBar(strData1))
{
    return (FALSE);
}
if (FALSE == DoFoo(strFile4, strData2))
{
    return (FALSE);
}
if (FALSE == DoFoo(strFile5, strData2))
{
    return (FALSE);
}
if (FALSE == DoFoo(strData1, strData2))
{
    return (FALSE);
}
if (FALSE == DoBar(strData2))
{
    return (FALSE);
}
return (TRUE);

if (DoFoo(strFile1, strData1))
{
    if (DoFoo(strFile2, strData1))
    {
        if (DoFoo(strFile3, strData1))
        {
            if (DoBar(strData1))
            {
                if (DoFoo(strFile4, strData2))
                {
                    if (DoFoo(strFile5, strData2))
                    {
                        if (DoFoo(strData1, strData2))
                        {
                            if (DoBar(strData2))
                            {
                                return (TRUE);
                            }
                        }
                    }
                }
            }
        }
    }
}
return (FALSE);

是否有嵌套ifs的标准？是否有一个普遍同意的限制？通常情况下，它可能会与如此多的嵌套代码混淆，但由于没有发生复杂的事情，也没有额外的代码行，所以看起来仍然很清楚。哪条路更好？或者有没有比这两种方法更整洁和/或更短的方法呢？

有更好的方法：

if(DoFoo(strFile1, strData1) && DoFoo(strFile2, strData1) && //etc...
    return true;

或：

---

我将按以下方式实施：

bool func() {
  return DoFoo(strFile1, strData1)
     &&  DoFoo(strFile2, strData1)
     &&  DoFoo(strFile3, strData1)
     &&  DoBar(strData1)
     &&  DoFoo(strFile4, strData2)
     &&  DoFoo(strFile5, strData2)
     &&  DoFoo(strData1, strData2)
     &&  DoBar(strData2);
 }

---

可能类似于下面的内容，这是一种不同的可能性，可以去掉嵌套的if语句

有一个丑陋的C类型转换可以使表正确显示，我们假设有额外的、未使用的参数不会是问题

当在调试器中运行时，它将编译Microsoft Visual Studio 2005，并将其作为Windows控制台应用程序使用。当然，

DoFoo（）

和

DoBar（）

函数在本例中都是存根，假定的字符指针只指向结构

bool DoFoo (char *s1, char *s2)
{
    return true;
}
bool DoBar (char *s1)
{
    return true;
}

char *strData1;
char *strData2;
char *strFile1;
char *strFile2;
char *strFile3;
char *strFile4;
char *strFile5;

typedef bool (*xFunc)(char *s1, char *s2);

typedef struct {
    xFunc  pF;
    char  *s1;
    char  *s2;
} TableItem;

bool myFunc(void)
{
TableItem fArray[] = {
    { DoFoo, strFile1, strData1},
    { DoFoo, strFile2, strData1},
    { DoFoo, strFile3, strData1},
    { (xFunc)DoBar, strData1, NULL},
    { DoFoo, strFile4, strData2},
    { DoFoo, strFile5, strData2},
    { DoFoo, strData1, strData2},
    { (xFunc)DoBar, strData2, NULL}
};

bool bRet = true;
int i = 0;
for (i = 0; bRet && i < sizeof(fArray)/sizeof(fArray[0]); i++) {
  bRet = fArray[i].pF(fArray[i].s1, fArray[i].s2) && bRet;
}

return bRet;
}

int _tmain(int argc, _TCHAR* argv[])
{
    myFunc();
    return 0;
}

booldooo（char*s1，char*s2）
{
返回true；
}
布尔多巴（字符*s1）
{
返回true；
}
char*strData1；
char*strData2；
char*strFile1；
char*strFile2；
char*strFile3；
char*strFile4；
char*strFile5；
typedef bool（*xFunc）（字符*s1，字符*s2）；
类型定义结构{
xFunc-pF；
char*s1；
char*s2；
}表项；
布尔myFunc（无效）
{
TableItem fArray[]={
{DoFoo，strFile1，strData1}，
{DoFoo，strFile2，strData1}，
{DoFoo，strFile3，strData1}，
{（xFunc）DoBar，strData1，NULL}，
{DoFoo，strFile4，strData2}，
{DoFoo，strFile5，strData2}，
{DoFoo，strData1，strData2}，
{（xFunc）DoBar，strData2，NULL}
};
布尔-布雷特=真；
int i=0；
对于（i=0；bRet&i

编辑-另一种可能性

另一种方法如下。这不需要C样式转换

bool DoFoo (char *s1, char *s2)
{
    return true;
}
bool DoBar (char *s1)
{
    return true;
}

char *strData1;
char *strData2;
char *strFile1;
char *strFile2;
char *strFile3;
char *strFile4;
char *strFile5;

typedef enum {funcType1 = 1, funcType2} funcType;

typedef struct {
    funcType fType;
    char     *s1;
    char     *s2;
} TableItem;

bool myFunc(void)
{
TableItem fArray[] = {
    { funcType1, strFile1, strData1},
    { funcType1, strFile2, strData1},
    { funcType1, strFile3, strData1},
    { funcType2, strData1, NULL},
    { funcType1, strFile4, strData2},
    { funcType1, strFile5, strData2},
    { funcType1, strData1, strData2},
    { funcType2, strData2, NULL}
};

bool bRet = true;
int i = 0;
for (i = 0; bRet && i < sizeof(fArray)/sizeof(fArray[0]); i++) {
    switch (fArray[i].fType) {
        case funcType1:
            bRet = DoFoo (fArray[i].s1, fArray[i].s2);
            break;
        case funcType2:
            bRet = DoBar (fArray[i].s1);
            break;
        default:
            break;
    }
}

return bRet;
}

int _tmain(int argc, _TCHAR* argv[])
{
    myFunc();
    return 0;
}

booldooo（char*s1，char*s2）
{
返回true；
}
布尔多巴（字符*s1）
{
返回true；
}
char*strData1；
char*strData2；
char*strFile1；
char*strFile2；
char*strFile3；
char*strFile4；
char*strFile5；
typedef枚举{funcType1=1，funcType2}funcType；
类型定义结构{
funcType-fType；
char*s1；
char*s2；
}表项；
布尔myFunc（无效）
{
TableItem fArray[]={
{funcType1，strFile1，strData1}，
{funcType1，strFile2，strData1}，
{funcType1，strFile3，strData1}，
{funcType2，strData1，NULL}，
{funcType1，strFile4，strData2}，
{funcType1，strFile5，strData2}，
{funcType1，strData1，strData2}，
{funcType2，strData2，NULL}
};
布尔-布雷特=真；
int i=0；
对于（i=0；bRet&i

编辑-还有一种可能性

另一种方法如下。这是非常直接的C++。p>

    bool DoFoo (char *s1, char *s2)
    {
        return true;
    }
    bool DoBar (char *s1)
    {
        return true;
    }

    char *strData1;
    char *strData2;
    char *strFile1;
    char *strFile2;
    char *strFile3;
    char *strFile4;
    char *strFile5;

class funcObj {
public:
    funcObj (bool (*pf) (char *s1, char *s2), char *s1, char *s2);
    funcObj (bool (*pf) (char *s1), char *s1);
    funcObj ();
    ~funcObj() {}
    bool eval ();
private:
    bool (*m_dofoo) (char *s1, char *s2);
    bool (*m_dobar) (char *s1);
    char  *m_s1;
    char  *m_s2;
};

funcObj::funcObj (bool (*pf) (char *s1, char *s2), char *s1, char *s2)
{
    m_dofoo = pf;
    m_dobar = 0;
    m_s1 = s1;
    m_s2 = s2;
}
funcObj::funcObj (bool (*pf) (char *s1), char *s1)
{
    m_dofoo = 0;
    m_dobar = pf;
    m_s1 = s1;
    m_s2 = 0;
}

funcObj::funcObj ()
{
    m_dofoo = 0;
    m_dobar = 0;
    m_s1 = 0;
    m_s2 = 0;
}

bool funcObj::eval ()
{
    bool bRet = false;

    if (m_dofoo)
        bRet = m_dofoo(m_s1, m_s2);
    else if (m_dobar)
        bRet = m_dobar (m_s1);
    return bRet;
}

typedef struct {
    funcObj  fObj;
} TableItem;

bool myFunc(void)
{
    funcObj fArray[] = {
        funcObj(DoFoo, strFile1, strData1),
        funcObj(DoFoo, strFile2, strData1),
        funcObj(DoFoo, strFile3, strData1),
        funcObj(DoBar, strData1),
        funcObj(DoFoo, strFile4, strData2),
        funcObj(DoFoo, strFile5, strData2),
        funcObj(DoFoo, strData1, strData2),
        funcObj(DoBar, strData2)
    };

    bool bRet = true;
    int i = 0;
    for (i = 0; bRet && i < sizeof(fArray)/sizeof(fArray[0]); i++) {
        bRet = fArray[i].eval();
    }

    return bRet;
}
    int _tmain(int argc, _TCHAR* argv[])
    {
        myFunc();
        return 0;
    }

booldooo（char*s1，char*s2）
{
返回true；
}
布尔多巴（字符*s1）
{
返回true；
}
char*strData1；
char*strData2；
char*strFile1；
char*strFile2；
char*strFile3；
char*strFile4；
char*strFile5；
类funcObj{
公众：
funcObj（bool（*pf）（char*s1，char*s2），char*s1，char*s2）；
funcObj（bool（*pf）（char*s1），char*s1）；
funcObj（）；
~funcObj（）{}
bool-eval（）；
私人：
bool（*m_dofoo）（字符*s1，字符*s2）；
布尔（*m_dobar）（字符*s1）；
char*m_s1；
char*m_s2；
};
funcObj:：funcObj（bool（*pf）（char*s1，char*s2），char*s1，char*s2）
{
m_dofoo=pf；
m_dobar=0；
m_s1=s1；
m_s2=s2；
}
funcObj:：funcObj（bool（*pf）（char*s1），char*s1）
{
m_dofoo=0；
m_dobar=pf；
m_s1=s1；
m_s2=0；
}
funcObj:：funcObj（）
{
m_dofoo=0；
m_dobar=0；
m_s1=0；
m_s2=0；
}
bool funcObj:：eval（）
{
布尔-布雷特=假；
如果（m_dofoo）
bRet=m_dofoo（m_s1，m_s2）；
否则如果（m_dobar）
bRet=m_-dobar（m_-s1）；
返回布雷特；
}
类型定义结构{
funcObj fObj；
}表项；
布尔myFunc（无效）
{
funcObj fArray[]={
funcObj（DoFoo、strFile1、strData1），
funcObj（DoFoo、strFile2、strData1），
funcObj（DoFoo、strFile3、strData1），
funcObj（DoBar，strData1），
funcObj（DoFoo、strFile4、strData2），
funcObj（DoFoo、strFile5、strData2），
funcObj（DoFoo、strData1、strData2），
funcObj（多巴，标准数据2）
};
布尔-布雷特=真；
int i=0；
对于（i=0；bRet&i

这方面没有标准。你可以自由地做任何你想做的事情，直到你独自处理代码

但大多数人建议避免使用它（将自己限制在1-2个嵌套级别），因为这样的代码很难阅读。实践表明，在大多数情况下，这是可能的

例如，在您的情况下，可以使用&&运算符：

if ( DoFoo(strFile1, strData1) &&
     DoFoo(strFile2, strData1) &&
     DoFoo(strFile3, strData1) &&
     DoBar(strData1) &&
     DoFoo(strFile4, strData2) &&
     DoFoo(strFile5, strData2) &&
     DoFoo(strData1, strData2) &&
     DoBar(strData2)
   ) {
  return FALSE;
}

看到了吗？这使得代码更加容易

在其他情况下，您可以使用

开关（…）运算符

如果构成：

if (A) {

} else if (B) {

} else if (C) {
...

函数调用：

void CheckCoor( ... ) {
  if ( coor >= ... ) {
     CheckAngle(...);
  else {
     CheckPosibilityToChangeCoor(...);
  }
}

---

通常这4个选项足以避免超过一个嵌套级别。

我不会说&，| |会更好，你会说如果条件1和条件为真，请