当代码流是这样的:
if(check())
{
...
...
if(check())
{
...
...
if(check())
{
...
...
}
}
}
我通常看到这种方法可以避免上述混乱的代码流:
do {
if(!check()) break;
...
...
if(!check()) break;
...
...
if(!check()) break;
...
...
} while(0);
有什么更好的方法可以避免这种工作/黑客，从而使其成为更高级别(行业级别)的代码?
任何跳出盒子的建议都是欢迎的!
当前回答
类似于dasblinkenlight的答案，但避免了if语句中的赋值，这可能会被代码评审员“修复”:
bool goOn = check0();
if (goOn) {
...
goOn = check1();
}
if (goOn) {
...
goOn = check2();
}
if (goOn) {
...
}
...
当一个步骤的结果需要在下一步之前检查时，我使用这种模式，这与所有检查都可以在前面用一个大if(check1() && check2()…类型的模式。
其他回答
类似于dasblinkenlight的答案，但避免了if语句中的赋值，这可能会被代码评审员“修复”:
bool goOn = check0();
if (goOn) {
...
goOn = check1();
}
if (goOn) {
...
goOn = check2();
}
if (goOn) {
...
}
...
当一个步骤的结果需要在下一步之前检查时，我使用这种模式，这与所有检查都可以在前面用一个大if(check1() && check2()…类型的模式。
也许就像这样
#define EVER ;;
for(EVER)
{
if(!check()) break;
}
或者使用异常
try
{
for(;;)
if(!check()) throw 1;
}
catch()
{
}
使用异常还可以传递数据。
对我来说，当(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仍然可以生成意大利面条代码。
TLDR: RAII、事务性代码(仅设置结果或在已经计算时返回内容)和异常。
长一点的回答:
在C语言中，这类代码的最佳实践是在代码中添加一个EXIT/CLEANUP/other标签，在该标签中进行本地资源的清理，并返回错误代码(如果有的话)。这是最佳实践，因为它将代码自然地划分为初始化、计算、提交和返回:
error_code_type c_to_refactor(result_type *r)
{
error_code_type result = error_ok; //error_code_type/error_ok defd. elsewhere
some_resource r1, r2; // , ...;
if(error_ok != (result = computation1(&r1))) // Allocates local resources
goto cleanup;
if(error_ok != (result = computation2(&r2))) // Allocates local resources
goto cleanup;
// ...
// Commit code: all operations succeeded
*r = computed_value_n;
cleanup:
free_resource1(r1);
free_resource2(r2);
return result;
}
在C语言中，在大多数代码库中，if(error_ok !=…goto代码通常隐藏在一些方便的宏(RET(computation_result)， ENSURE_SUCCESS(computation_result, return_code)等)后面。
c++比C提供了额外的工具:
清理块功能可以作为RAII实现，这意味着您不再需要整个清理块，并允许客户端代码添加早期返回语句。 当无法继续时抛出抛出，转换所有if(error_ok !=…变成直接的通话。
等价的c++代码:
result_type cpp_code()
{
raii_resource1 r1 = computation1();
raii_resource2 r2 = computation2();
// ...
return computed_value_n;
}
这是最佳实践，因为:
It is explicit (that is, while error handling is not explicit, the main flow of the algorithm is) It is straightforward to write client code It is minimal It is simple It has no repetitive code constructs It uses no macros It doesn't use weird do { ... } while(0) constructs It is reusable with minimal effort (that is, if I want to copy the call to computation2(); to a different function, I don't have to make sure I add a do { ... } while(0) in the new code, nor #define a goto wrapper macro and a cleanup label, nor anything else).
有些时候，使用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是比其他解决方案更好的解决方案。
例如，想象一下，我们正在收集一些数据，测试的不同条件是某种“这是正在收集的数据的结束”——这取决于某种“继续/结束”标记，这些标记根据您在数据流中的位置而变化。
现在，当我们完成之后，我们需要将数据保存到一个文件中。
是的，通常有其他解决方案可以提供合理的解决方案，但并不总是如此。
