当代码流是这样的:
if(check())
{
...
...
if(check())
{
...
...
if(check())
{
...
...
}
}
}
我通常看到这种方法可以避免上述混乱的代码流:
do {
if(!check()) break;
...
...
if(!check()) break;
...
...
if(!check()) break;
...
...
} while(0);
有什么更好的方法可以避免这种工作/黑客，从而使其成为更高级别(行业级别)的代码?
任何跳出盒子的建议都是欢迎的!
当前回答
如果你的代码有一个很长的If ..else If ..else语句块，你可以尝试在函子或函数指针的帮助下重写整个块。这可能并不总是正确的解决方案，但通常是正确的。
http://www.cprogramming.com/tutorial/functors-function-objects-in-c++.html
其他回答
对我来说，当(0)是好的时候做{…}。如果您不想看到do{…}while(0)，您可以为它们定义替代关键字。
例子:
SomeUtilities.hpp:
#define BEGIN_TEST do{
#define END_TEST }while(0);
SomeSourceFile.cpp:
BEGIN_TEST
if(!condition1) break;
if(!condition2) break;
if(!condition3) break;
if(!condition4) break;
if(!condition5) break;
//processing code here
END_TEST
我认为编译器将在二进制版本的do{…}while(0)中删除不必要的while(0)条件，并将断点转换为无条件跳转。您可以检查它的汇编语言版本来确定。
使用goto还可以生成更简洁的代码，并且使用条件-然后跳转的逻辑非常简单。您可以执行以下操作:
{
if(!condition1) goto end_blahblah;
if(!condition2) goto end_blahblah;
if(!condition3) goto end_blahblah;
if(!condition4) goto end_blahblah;
if(!condition5) goto end_blahblah;
//processing code here
}end_blah_blah:; //use appropriate label here to describe...
// ...the whole code inside the block.
注意标签放在结束}之后。这是避免一个可能的问题，在goto中，不小心将代码放在中间，因为你没有看到标签。现在就像do{…}while(0)没有条件代码。
为了让代码更清晰，更容易理解，你可以这样做:
SomeUtilities.hpp:
#define BEGIN_TEST {
#define END_TEST(_test_label_) }_test_label_:;
#define FAILED(_test_label_) goto _test_label_
SomeSourceFile.cpp:
BEGIN_TEST
if(!condition1) FAILED(NormalizeData);
if(!condition2) FAILED(NormalizeData);
if(!condition3) FAILED(NormalizeData);
if(!condition4) FAILED(NormalizeData);
if(!condition5) FAILED(NormalizeData);
END_TEST(NormalizeData)
有了这个，你可以做嵌套块，并指定你想要退出/跳出的位置。
BEGIN_TEST
if(!condition1) FAILED(NormalizeData);
if(!condition2) FAILED(NormalizeData);
BEGIN_TEST
if(!conditionAA) FAILED(DecryptBlah);
if(!conditionBB) FAILED(NormalizeData); //Jump out to the outmost block
if(!conditionCC) FAILED(DecryptBlah);
// --We can now decrypt and do other stuffs.
END_TEST(DecryptBlah)
if(!condition3) FAILED(NormalizeData);
if(!condition4) FAILED(NormalizeData);
// --other code here
BEGIN_TEST
if(!conditionA) FAILED(TrimSpaces);
if(!conditionB) FAILED(TrimSpaces);
if(!conditionC) FAILED(NormalizeData); //Jump out to the outmost block
if(!conditionD) FAILED(TrimSpaces);
// --We can now trim completely or do other stuffs.
END_TEST(TrimSpaces)
// --Other code here...
if(!condition5) FAILED(NormalizeData);
//Ok, we got here. We can now process what we need to process.
END_TEST(NormalizeData)
杂乱的代码不是goto的错，而是程序员的错。不使用goto仍然可以生成意大利面条代码。
有些时候，使用goto实际上是正确的答案——至少对那些没有在宗教信仰中长大的人来说，“不管问题是什么，goto永远都不是答案”——这是其中的一个例子。
此代码使用了do{…}, (0);唯一的目的就是把一个傻瓜打扮成休息的样子。如果你打算使用goto，那就公开使用它。让代码更难阅读是没有意义的。
一种特殊的情况是当你有很多代码和相当复杂的条件时:
void func()
{
setup of lots of stuff
...
if (condition)
{
...
...
if (!other condition)
{
...
if (another condition)
{
...
if (yet another condition)
{
...
if (...)
...
}
}
}
....
}
finish up.
}
没有如此复杂的逻辑，实际上可以更清楚地表明代码是正确的。
void func()
{
setup of lots of stuff
...
if (!condition)
{
goto finish;
}
...
...
if (other condition)
{
goto finish;
}
...
if (!another condition)
{
goto finish;
}
...
if (!yet another condition)
{
goto finish;
}
...
....
if (...)
... // No need to use goto here.
finish:
finish up.
}
编辑:澄清一下，我绝不是建议使用goto作为通用解决方案。但在某些情况下，goto是比其他解决方案更好的解决方案。
例如，想象一下，我们正在收集一些数据，测试的不同条件是某种“这是正在收集的数据的结束”——这取决于某种“继续/结束”标记，这些标记根据您在数据流中的位置而变化。
现在，当我们完成之后，我们需要将数据保存到一个文件中。
是的，通常有其他解决方案可以提供合理的解决方案，但并不总是如此。
如果根据故障发生的位置需要不同的清理步骤，另一个模式很有用:
private ResultCode DoEverything()
{
ResultCode processResult = ResultCode.FAILURE;
if (DoStep1() != ResultCode.SUCCESSFUL)
{
Step1FailureCleanup();
}
else if (DoStep2() != ResultCode.SUCCESSFUL)
{
Step2FailureCleanup();
processResult = ResultCode.SPECIFIC_FAILURE;
}
else if (DoStep3() != ResultCode.SUCCESSFUL)
{
Step3FailureCleanup();
}
...
else
{
processResult = ResultCode.SUCCESSFUL;
}
return processResult;
}
代码流本身已经是一个代码气味，在函数中发生了太多的事情。如果没有直接的解决方案(函数是一个通用的检查函数)，那么使用RAII，这样您就可以返回，而不是跳转到函数的结束部分，可能会更好。
I'm adding an answer for the sake of completeness. A number of other answers pointed out that the large condition block could be split out into a separate function. But as was also pointed out a number of times is that this approach separates the conditional code from the original context. This is one reason that lambdas were added to the language in C++11. Using lambdas was suggested by others but no explicit sample was provided. I've put one in this answer. What strikes me is that it feels very similar to the do { } while(0) approach in many ways - and maybe that means it's still a goto in disguise....
earlier operations
...
[&]()->void {
if (!check()) return;
...
...
if (!check()) return;
...
...
if (!check()) return;
...
...
}();
later operations
