使用单一出口点可以降低圈复杂度，因此，从理论上讲，可以降低在修改代码时引入错误的可能性。然而，实践往往表明需要更务实的方法。因此，我倾向于只有一个出口点，但如果可读性更好，允许我的代码有多个出口点。

我使用多个出口点使错误情况+处理+返回值尽可能接近。

所以必须测试条件a, b, c必须为真，你需要用不同的方式处理它们:

if (a is false) {
    handle this situation (eg. report, log, message, etc.)
    return some-err-code
}
if (b is false) {
    handle this situation
    return other-err-code
}
if (c is false) {
    handle this situation
    return yet-another-err-code
}

perform any action assured that a, b and c are ok.

a, b和c可能是不同的东西，比如a是输入参数检查，b是新分配内存的指针检查，c是检查参数a中的值。

如果你最终得到了很多返回值，那么你的代码可能有问题。否则，我同意有时能够从子例程的多个位置返回是很好的，特别是当它使代码更干净的时候。

Perl 6:坏例子

sub Int_to_String( Int i ){
  given( i ){
    when 0 { return "zero" }
    when 1 { return "one" }
    when 2 { return "two" }
    when 3 { return "three" }
    when 4 { return "four" }
    ...
    default { return undef }
  }
}

这样写会更好吗

Perl 6:好例子

@Int_to_String = qw{
  zero
  one
  two
  three
  four
  ...
}
sub Int_to_String( Int i ){
  return undef if i < 0;
  return undef unless i < @Int_to_String.length;
  return @Int_to_String[i]
}

注意，这只是一个简单的例子

有人可能会说……如果在执行函数的任务之前必须满足多个条件，那么在满足这些条件之前不要调用函数:

而不是:

function doStuff(foo) {
    if (foo != null) return;
}

Or

function doStuff(foo) {
    if (foo !== null) {
        ...
    }
}

在foo != null之前不要调用doStuff

if(foo != null) doStuff(foo);

这要求每个调用站点确保在调用之前满足调用的条件。如果有多个调用站点，则该逻辑最好放在单独的函数中、待调用函数的方法中(假设它们是一级公民)或代理中。

关于函数是否在数学上是可证明的这个话题，要考虑逻辑而不是语法。如果一个函数有多个返回点，这并不意味着(默认情况下)它在数学上不可证明。

我倾向于单一退出，除非事情真的变得复杂。我发现在某些情况下，多个存在点可以掩盖其他更重要的设计问题:

public void DoStuff(Foo foo)
{
    if (foo == null) return;
}

在看到这段代码时，我马上会问:

'foo'是否为空? 如果是这样，有多少客户端'DoStuff'曾经调用一个空'foo'函数?

根据这些问题的答案，可能是这样

这种检查毫无意义，因为它从来都不是真的。它应该是一个断言) 这种检查很少是正确的，所以最好改变那些特定的调用函数，因为它们可能应该采取一些其他的操作。

在上述两种情况下，代码可能都可以用断言重做，以确保'foo'永远不为空，并更改相关的调用者。

还有另外两个原因(我认为是针对c++代码的)，多重存在实际上会产生负面影响。它们是代码大小和编译器优化。

在函数出口作用域中的非pod c++对象将调用其析构函数。如果有几个return语句，那么作用域中可能有不同的对象，因此要调用的析构函数列表也会不同。因此，编译器需要为每个return语句生成代码:

void foo (int i, int j) {
  A a;
  if (i > 0) {
     B b;
     return ;   // Call dtor for 'b' followed by 'a'
  }
  if (i == j) {
     C c;
     B b;
     return ;   // Call dtor for 'b', 'c' and then 'a'
  }
  return 'a'    // Call dtor for 'a'
}

如果代码大小是一个问题，那么这可能是值得避免的。

另一个问题涉及到“命名返回值优化”(又名复制省略，ISO c++ '03 12.8/15)。c++允许实现在可以的情况下跳过调用复制构造函数:

A foo () {
  A a1;
  // do something
  return a1;
}

void bar () {
  A a2 ( foo() );
}

就像代码一样，对象'a1'是在'foo'中构造的，然后它的复制构造将被调用来构造'a2'。然而，复制省略允许编译器在堆栈上与'a2'相同的位置构造'a1'。因此，当函数返回时，不需要“复制”对象。

多个出口点会使编译器的检测工作复杂化，至少对于相对较新的vc++版本，优化不会发生在函数体有多个返回的地方。有关详细信息，请参阅Visual c++ 2005中的命名返回值优化。

这可能是一个不寻常的观点，但我认为任何相信多个return语句是有利的人都从未在只支持4个硬件断点的微处理器上使用过调试器。:-)

虽然“箭头代码”的问题是完全正确的，但当使用多个return语句时，一个问题似乎消失了，那就是在使用调试器的情况下。您没有一个方便的万能位置来放置断点，以保证您将看到退出，从而看到返回条件。