我正在使用 boost 的正则表达式库，我发现确定是否找到命名匹配然后使用该信息有点烦人。要检测命名匹配项，我想这样做:

typedef boost::match_result<string::const_iterator> matches_t;
typedef matches_t::const_reference match_t;
boost::regex re("(?:(?<type1>aaaa)|(?<type2>bbbb)" /*...*/ "|(?<typeN>abcdefg)");
string str(SOME_STRING);
matches_t what;
boost::match_flag_type flags = boost::match_default;

if(regex_search(str.cbegin(), str.cend(), what, re, flags))
{
  if((match_t type1 = what["type1"]).matched)
  {
     // do stuff with type1
  }
  else if((match_t type2 = what["type2"]).matched)
  {
     // do stuff with type2
  }
  // ...
  else if((match_t typeN = what["typeN"]).matched)
  {
     // do stuff with typeN
  }
}

如果这行得通，那就太好了。作用域将被限制在 if 的主体内，内存可以得到有效使用，而且看起来相当干净。遗憾的是，它不起作用，因为您不能在列表中定义变量。 :(

这可能是一种可能性:

if(regex_search(str.cbegin(), str.cend(), what, re, flags))
{
  match_t found = what["type1"];
  if(found.matched)
  {
     // do stuff with type1
  }
  else if((found = what["type2"]).matched)
  {
     // do stuff with type2
  }
  // ...
  else if((found = what["typeN"]).matched)
  {
     // do stuff with typeN
  }
}

但是 match_t 是一个 const 引用，所以它是不可赋值的。 (tl;dr 我也不知道底层类型是什么，通常我真的不想知道，因为我更喜欢一个更通用的解决方案，我可以在这个正则表达式示例之外使用它。甚至std::move() 用于 what[...] 它变得更加冗长并且文档没有说它使用 sub_match 的移动语义。当然，由于第一个给出的原因，所有这些都是没有实际意义的本段的句子。)

另一种选择是这样做:

if(regex_search(str.cbegin(), str.cend(), what, re, flags))
{
  match_t type1 = what["type1"];
  if(type1.matched)
  {
     // do stuff with type1
  }
  else {
    match_t type2 = what["type2"];
    if(type2.matched)
    {
       // do stuff with type2
    }
    // ...
          else {
            match_t typeN = what["typeN"];
            if((match_t typeN = what["typeN"]).matched)
            {
               // do stuff with typeN
            }
          }
    // ...
    }
  }
}

由于大括号嵌套很深，我不喜欢。

也许在每个 if 主体的末尾滥用带有 break 的循环结构，如下所示:

if(regex_search(str.cbegin(), str.cend(), what, re, flags))
{
  do{
    {
      match_t type1 = what["type1"];
      if(type1.matched)
      {
         // do stuff with type1
         break;
      }
    }
    {
      match_t type2 = what["type2"];
      if(type2.matched)
      {
         // do stuff with type2
         break;
      }
    }
    // ...
    {
      match_t typeN = what["typeN"];
      if(typeN.matched)
      {
         // do stuff with typeN
         break;
      }
    }
  } while(0);
}

哪个更好，但仍然不是很好。使用宏，可以隐藏大部分噪音。喜欢:

#define IF(declare, cond) do{{declare;if(cond){                
#define ELSE_IF(declare, cond) break;}}{declare; if(cond){     
#define ELSE break;}}{{                                        
#define END_IF break;}}}while(0);                              

if(regex_search(str.cbegin(), str.cend(), what, re, flags))
{
  IF(match_t type1 = what["type1"], type1.matched)
  {
     // do stuff with type1
  }
  ELSE_IF(match_t type2 = what["type2"], type2.matched)
  {
     // do stuff with type2
  }
    // ...
  ELSE_IF(match_t typeN = what["typeN"], typeN.matched)
  {
     // do stuff with typeN
  }
  END_IF
}

大括号实际上是由宏隐含的，但通过重述它们可以使阅读更清楚。

我能想到的另一个选择是进入 boost::sub_match 类并添加一个转换函数以将该类型转换为 bool，其返回值将是 matched 成员的值。然后我可以在 if 表达式中声明一个 match_t 变量，它会被 if 自动转换为 bool 值。我不确定我是否已经到达那里并且它不是通用的。

在风格上，我建议的是好还是坏(只有最后 3 个实际有效，所以我可能会限制对它们的评论)。

还有，大家有什么更好的建议吗？请说明您认为它们更好的原因。

最佳答案

通常建议避免嵌套的 if - 它们会使代码更难阅读。如果有嵌套的 if，它可能应该被函数调用取代。

在您的情况下，您需要使用循环。

你的第二个例子:

if(regex_search(str.cbegin(), str.cend(), what, re, flags))
{
  match_t found = what["type1"];
  if(found.matched)
  {
     // do stuff with type1
  }
  else if((found = what["type2"]).matched)
  {
     // do stuff with type2
  }
  // ...
  else if((found = what["typeN"]).matched)
  {
     // do stuff with typeN
  }
}

求一个循环:

const char *types[] = {"type1", "type2", "typeN", 0};
for(const char **cur = types; *cur; cur++){
    found = what[*cur];
    if (found.matched){
         //initiate robot uprising
         break;
    }
}

您的所有其他示例 (IMO) 都是糟糕的编码风格。我更喜欢保持循环和 ifs 简短。如果它不适合 20 行代码，那么最好做一些非常复杂的事情(这不是你的情况)。如果它不做任何复杂的事情，就需要对其进行重组。

关于c++ - 如何在 C++ 中创建干净的级联结构？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/16728019/