如何在c ++中创建一个干净的级联结构？ [英] How do I create a clean cascading if structure in c++?
问题描述
我使用boost的regex库，我发现确定是否找到命名的匹配，然后使用该信息是有点恼人。要检测命名匹配，我想这样做：
I'm using boost's regex library, and I'm finding that determining if a named match is found and then using that information is a little annoying. To detect a named match, I'd like to do this:
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 that'd would work, that would be great. Scoping would be constrained to the if's body, memory can be used efficiently and it looks fairly clean. Sadly, it doesn't work as you cannot define a variable within a list. :(
这可能是一种可能性：
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（）被使用在什么[...]它变得更冗长，文档没有说它使用move语义sub_match。所有这一切都是由于第一个给出的原因）
But match_t is a const reference so it's not assignable. (tl;dr Also I don't know what the underlying type is and generally I don't really want to know as I'd prefer a more generic solution that I could use outside of this one example of regex. Even std::move() was used around what[...] it gets even more verbose and the documentation doesn't say that it uses move semantics for sub_match. All of this is moot of course due to the reason given in the first sentence of this paragraph.)
另一个选择是这样做：
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
}
}
// ...
}
}
}
可能使用 break 的循环结构滥用每个如果如此：
Perhaps abusing a loop structure with breaks at the end of each if body like this:
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);
}
这更好，但还不是很好。使用宏，许多噪声可能被隐藏看不到。喜欢：
Which is better, but still not great. Using macros, much of the noise could be hidden from view. Like:
#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
}
$ b b
大括号实际上是由宏指令隐含的，但它可以通过重置来更清楚地读取。
The braces are actually implied by the macros, but it makes for clearer reading by restating them.
我可以想到的另一个选择是进入boost :: sub_match类，并添加一个转换函数将该类型转换为bool，其返回值将是匹配成员的值。然后，我可以在if表达式中声明一个match_t变量，它会被if自动转换为布尔值。我不知道我是否还在那里，它不是一般的。
One other option I can think of is to go into the boost::sub_match class and add a conversion function to convert that type to a bool who's return value would be that of the matched member. Then I could declare a match_t variable in the if expression and it would automagically be converted to a boolean value by the if. I'm not sure if I'm there yet and it's not generic.
在文体上，是我提议的好或坏（只有最后3个实际工作，所以
Stylistically, are the ones I propose good or bad (only the last 3 actually work, so I'd probably confine comments to them).
此外，有没有更好的建议？
Also, does anyone have any better suggestions? Please state why you think they are better.
推荐答案
通常建议避免嵌套 if code> s - 他们使代码更难读。如果有嵌套if，它应该被一个函数调用所取代。
It is generally recommended to avoid nested ifs - they make code harder to read. If there's nested if, it should probably replaced by a function call.
在你的情况下，你需要使用一个循环。
In your case, you need to use a loop.
第二个例子：
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
}
}
BEGS ：
const char *types[] = {"type1", "type2", "typeN", 0};
for(const char **cur = types; *cur; cur++){
found = what[*cur];
if (found.matched){
//initiate robot uprising
break;
}
}
所有其他示例样式。我喜欢保持循环和ifs短。如果它不适合20行代码，那么最好做一些非常复杂的事情（这不是你的case）。如果它没有做任何复杂的事情，它需要重组。
All your other examples (IMO) are a bad coding style. I prefer to keep loops and ifs short. If it doesn't fit into 20 lines of code, then it better be doing something very complicated (which is not your case). If it doesn't do anything complicated, it needs to be restructured.
这篇关于如何在c ++中创建一个干净的级联结构？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
