为什么大多数（？）编程语言中的函数都设计为支持任意数量的输入参数，但仅支持一个返回值？

在大多数语言中，可以通过使用输出参数，返回指针或定义/返回结构/类来“解决”该限制。但是，编程语言没有设计为以更“自然”的方式支持多个返回值似乎很奇怪。

请问对此有解释吗？

某些语言（如Python）本机支持多个返回值，而某些语言（如C＃）则通过其基础库支持它们。

但是总的来说，即使在支持它们的语言中，也很少使用多个返回值，因为它们草率：

• 返回多个值的函数很难清楚地命名。

• 容易误认为返回值的顺序

  (password, username) = GetUsernameAndPassword()  
  

  （出于同样的原因，许多人避免对一个函数使用过多的参数；甚至有人甚至认为一个函数不应具有两个相同类型的参数！）

• OOP语言已经可以更好地替代多个返回值： 类。
  它们的类型更强，它们将返回值分组为一个逻辑单元，并且使返回值（属性）的名称在所有用途中保持一致。

的一处，他们是相当方便是在语言（如Python），其中从一个函数的多个返回值可以被用作多个输入参数到另一个。但是，这是比使用类更好的设计的用例。

因为函数是执行计算并返回结果的数学构造。确实，很少有几种编程语言在“幕后”上仅着眼于一个输入和一个输出，而多个输入只是对输入的一薄包装-当单个值输出不起作用时，使用单个内聚结构（或元组或Maybe）是输出（尽管“单个”返回值由许多值组成）。

这没有改变，因为程序员发现out参数是笨拙的构造，仅在有限的一组场景中有用。像许多其他事情一样，由于需求/需求不存在，因此也没有支持。

在数学中，“定义明确”的函数是给定输入只有1个输出的函数（请注意，您只能使用单个输入函数，并且在语义上仍使用currying获得多个输入）。

对于多值函数（例如，正整数的平方根），返回一个集合或值序列就足够了。

对于您正在谈论的函数类型（即，返回多个值，不同类型的函数），我所看到的与您似乎略有不同：我认为需要/使用out参数是一种更好的设计或解决方案。更有用的数据结构。例如，我更希望*.TryParse(...)方法返回一个Maybe<T>monad而不是使用out参数。考虑一下F＃中的以下代码：

let s = "1"
match tryParse s with
| Some(i) -> // do whatever with i
| None -> // failed to parse

对于这些构造，编译器/ IDE /分析支持非常好。这将解决大部分参数的“需求”。老实说，我无法想到其他任何方法都不是解决方案。

对于其他场景（我不记得了），一个简单的Tuple就足够了。

除了当您查看函数返回时在汇编中使用的范例时已经说过的内容之外，它还会在特定寄存器中留下指向返回对象的指针。如果他们使用变量/多个寄存器，则该函数在库中时，调用函数将不知道从何处获取返回值。因此，这将使链接到库变得困难，并且与其设置任意数量的可返回指针，不如使用它们。高级语言并没有完全相同的借口。

现代语言功能不再需要过去使用多个返回值的许多用例。要返回错误代码？引发异常或返回Either<T, Throwable>。是否要返回可选结果？返回Option<T>。是否要返回以下几种类型之一？返回一个Either<T1, T2>或已标记的联合。

即使在您确实需要返回多个值的情况下，现代语言通常也支持元组或某种数据结构（列表，数组，字典）或对象，以及某些形式的解构绑定或模式匹配，这使得打包您将多个值合并为一个值，然后将其再次分解为多个琐碎的值。

以下是一些不支持返回多个值的语言的示例。我真的看不到增加对多个返回值的支持如何使它们显着地表现出来以抵消新语言功能的成本。

红宝石

def foo; return 1, 2, 3 end

one, two, three = foo

one
# => 1

three
# => 3

蟒蛇

def foo(): return 1, 2, 3

one, two, three = foo()

one
# >>> 1

three
# >>> 3

斯卡拉

def foo = (1, 2, 3)

val (one, two, three) = foo
// => one:   Int = 1
// => two:   Int = 2
// => three: Int = 3

哈斯克尔

let foo = (1, 2, 3)

let (one, two, three) = foo

one
-- > 1

three
-- > 3

Perl6

sub foo { 1, 2, 3 }

my ($one, $two, $three) = foo

$one
# > 1

$three
# > 3

单个返回值如此受欢迎的真正原因是在许多语言中使用的表达式。在任何可以使用表达式的语言中，您x + 1都已经在考虑单个返回值，因为您可以通过将表达式分解成碎片并确定每个表达式的值来评估表达式。您查看x并确定其值为3（例如），然后查看1，然后查看x + 1并合计起来确定整体的值为4。表达式的每个句法部分都有一个值，没有其他数量的值；这是每个人都期望的表达式的自然语义。即使一个函数返回一对值，它实际上仍在返回一个正在执行两个值的值，因为函数返回两个未以某种方式包装到单个集合中的值的想法太奇怪了。

人们不想处理使函数返回多个值所需的替代语义。例如，在像Forth这样的基于堆栈的语言中，您可以具有任意数量的返回值，因为每个函数仅修改堆栈的顶部，弹出输入并随意推送输出。这就是为什么Forth没有普通语言所具有的那种表达方式的原因。

Perl是另一种语言，有时可以像函数一样返回多个值，尽管通常只考虑返回一个列表。Perl 中的“内插”列表方式为我们提供了这样的列表，就像(1, foo(), 3)大多数不了解Perl的人所希望的那样，其中可能包含3个元素，但也可能仅包含2个元素，4个元素或更多的元素，具体取决于foo()。Perl中的列表是扁平的，因此语法列表并不总是具有列表的语义。它可能只是更大列表的一部分。

使函数返回多个值的另一种方式是具有替代的表达式语义，其中任何表达式都可以具有多个值，并且每个值都代表一种可能性。请x + 1再试一次，但是这次假设x有两个值{3，4}，则的值x + 1将为{4，5}，并且的值x + x将为{6，8}，或者可能是{6，7，8} ，取决于是否允许一个评估使用多个值x。类似于Prolog用来为查询提供多个答案的语言，可以使用回溯来实现。

简而言之，函数调用是单个语法单元，并且单个语法单元在我们都知道并喜欢的表达语义中具有单个值。任何其他语义都会迫使您采用奇怪的处理方式，例如Perl，Prolog或Forth。

正如该答案所建议的，这是硬件支持的问题，尽管语言设计中的传统也起着作用。

当函数返回时，它将指针指向特定寄存器中的返回对象

在Fortran，Lisp和COBOL这三种第一语言中，第一种使用的返回值是基于数学建模的。第二个返回任意数量的参数，就像接收它们一样：作为一个列表（也可以说它仅传递并返回一个参数：列表的地址）。第三个返回零或一个值。

这些最早的语言对跟随它们的语言的设计产生了很大的影响，尽管唯一返回多个值的语言Lisp从未受到广泛的欢迎。

当C语言问世时，虽然受到了之前的语言的影响，但它非常注重有效利用硬件资源，并在C语言所做的工作与实现它的机器代码之间保持着紧密的联系。它的一些最古老的功能，例如“自动”与“注册”变量，是这种设计理念的结果。

还必须指出的是，汇编语言直到80年代才开始广泛流行，直到80年代才逐渐被主流开发所淘汰。编写编译器和创建语言的人都熟悉汇编语言，并且在大多数情况下，保持最佳状态。

与该规范背道而驰的大多数语言都从未受到太大欢迎，因此也从未在影响语言设计师的决策方面发挥过强大的作用（当然，他们的灵感来自于他们所知道的）。

因此，让我们来看一下汇编语言。首先让我们看一下6502，这是1975年的微处理器，在Apple II和VIC-20微型计算机中广为使用。与当时的大型机和小型计算机相比，它非常脆弱，尽管与20年前30年代编程语言兴起时的第一台计算机相比，它具有强大的功能。

如果您看一下技术说明，它有5个寄存器和几个1位标志。唯一的“满”寄存器是程序计数器（PC）-该寄存器指向要执行的下一条指令。其他寄存器是累加器（A），两个“索引”寄存器（X和Y）以及堆栈指针（SP）。

调用子例程会将PC放入SP指向的内存中，然后递减SP。从子例程返回则相反。一个人可以在栈中推入和拉出其他值，但是相对于SP而言，它很难引用到内存，因此编写重入子例程非常困难。我们认为这是理所当然的，它在我们认为随时都可以调用子例程的情况下，在这种体系结构上并不常见。通常，将创建一个单独的“堆栈”，以便将参数和子例程返回地址保持分开。

如果您看一下激发6502的处理器6800，它还有一个与SP一样宽的寄存器，即索引寄存器（IX），可以从SP接收值。

在机器上，调用重入子例程包括将参数压入堆栈，压入PC，将PC更改为新地址，然后该子例程会将其局部变量压入堆栈。由于局部变量和参数的数量是已知的，因此可以相对于堆栈进行寻址。例如，一个接收两个参数并具有两个局部变量的函数如下所示：

SP + 8: param 2
SP + 6: param 1
SP + 4: return address
SP + 2: local 2
SP + 0: local 1

可以调用任意次，因为所有临时空间都在堆栈上。

在TRS-80和许多基于CP / M的微型计算机上使用的8080，可以通过将SP压入堆栈，然后将其弹出到其间接寄存器HL中来实现与6800类似的功能。

这是一种非常常见的实现方式，它在更现代的处理器上获得了更多的支持，它的基本指针使返回之前的所有局部变量都易于转储。

问题是，您如何退还任何东西？处理器寄存器在早期并不是很多，经常需要使用其中一些来找出要寻址的内存。返回堆栈上的东西会很复杂：您必须弹出所有内容，保存PC，然后推回返回的参数（该参数将同时存储在哪里？），然后再次推PC并返回。

因此，通常要做的是为返回值保留一个寄存器。调用代码知道返回值将在特定的寄存器中，必须保留该值，直到可以保存或使用它为止。

让我们看一下一种允许多个返回值的语言：Forth。Forth所做的是保持单独的返回堆栈（RP）和数据堆栈（SP），以便函数必须要做的就是弹出其所有参数，并将返回值保留在堆栈上。由于返回堆栈是单独的，因此不会妨碍您的操作。

作为在使用计算机的前六个月中学习汇编语言和Forth的人，多个返回值对我来说似乎完全正常。像Forth这样的运算符/mod返回整数除法，其余运算符似乎很明显。另一方面，我可以很容易地看到一个有C思维的早期经验的人如何发现这个概念很奇怪：它违背了他们对“功能”的根深蒂固的期望。

至于数学……好吧，在我上数学课之前，我正在用计算机编程。还有就是 CS和由数学影响编程语言的一个整体部分，但是，话又说回来，有一整节是不是。

因此，在数学影响早期语言设计，硬件限制决定了易于实现的因素以及流行语言影响硬件演变方式的因素方面，我们综合了一些因素（Lisp机器和Forth机器处理器是此过程中的杀手kill）。

我知道的功能语言可以通过使用元组轻松返回多个值（在动态类型的语言中，甚至可以使用列表）。其他语言也支持元组：

f :: Int -> (Int, Int)
f x = (x - 1, x + 1)

// Even C++ have tuples - see Boost.Graph for use
std::pair<int, int> f(int x) {
  return std::make_pair(x - 1, x + 1);
}

在上面的示例中，f函数返回2个整数。

同样，ML，Haskell，F＃等也可以返回数据结构（对于大多数语言而言，指针的级别太低）。我还没有听说过现代GP语言有这样的限制：

data MyValue = MyValue Int Int

g :: Int -> MyValue
g x = MyValue (x - 1, x + 1)

最后，out即使使用功能语言，也可以使用来模拟参数IORef。在大多数语言中，没有本地支持out变量的原因有几个：

• 语义不明确：以下函数是否打印0或1？我知道可以打印0的语言和可以打印1的语言。这两种语言都有好处（在性能方面，以及与程序员的思维模型相匹配）：

  int x;
  
  int f(out int y) {
    x = 0;
    y = 1;
    printf("%d\n", x);
  }
  f(out x);
  

• 非本地化的效果：如上例所示，您可以发现您的链条很长，并且最里面的函数会影响全局状态。通常，很难确定功能的要求以及更改是否合法。鉴于大多数现代范例都试图定位效果（封装在OOP中）或消除副作用（功能编程），因此它与这些范例冲突。

• 是多余的：如果有元组，则您有99％的out参数功能和100％的惯用用法。如果将指针添加到混合，则覆盖剩余的1％。

我很难命名一种语言，该语言不能通过使用元组，类或out参数来返回多个值（并且在大多数情况下，允许使用两个或多个这些方法）。

我认为这是因为诸如的表达式(a + b[i]) * c。

表达式由“奇异”值组成。因此，可以将返回奇异值的函数直接用于表达式中，以代替上面显示的四个变量中的任何一个。多输出函数在表达式中至少有些笨拙。

我个人觉得，这是在这特殊的有关同一个返回值的东西。您可以通过添加语法来解决此问题，该语法用于指定要在表达式中使用的多个返回值中的哪一个，但它肯定比老式的数学符号更笨拙，后者对于每个人来说都是简洁明了的。

它确实使语法复杂了一点，但是在实现级别没有充分的理由不允许这样做。与某些其他响应相反，在可用时返回多个值会导致代码更清晰，更高效。我无法计数我希望多久返回一次X 和 Y，或者返回“成功”布尔值和有用的值。

在大多数支持功​​能的语言中，您可以在任何可以使用该类型变量的地方使用函数调用：

x = n + sqrt(y);

如果该函数返回多个值，则将无法使用。动态类型的语言（例如python）将允许您执行此操作，但是，在大多数情况下，除非它可以解决与方程式中间的元组相关的问题，否则它将引发运行时错误。

我只想基于Harvey的答案。我最初是在新闻技术网站（arstechnica）上找到此问题的，并找到了一个令人惊奇的解释，我认为它确实回答了该问题的核心，而其他所有答案（除了Harvey的答案）都没有：

函数的单次返回源于机器代码。在机器代码级别，函数可以在A（累加器）寄存器中返回一个值。任何其他返回值将在堆栈上。

支持两个返回值的语言会将其编译为返回一个返回值并将第二个返回栈的机器码。换句话说，无论如何，第二个返回值最终都将作为out参数。

这就像问为什么赋值一次是一个变量。您可能使用的语言允许a，b = 1，2。但这最终会在机器代码级别为a = 1，然后是b = 2。

使编程语言结构与在编译和运行代码时实际发生的情况有一些相似之处，这是有一定道理的。

它从数学开始。以“公式转换”命名的FORTRAN是第一个编译器。FORTRAN过去是并且面向物理学/数学/工程学。

几乎和以前一样，COBOL没有明确的返回值。它几乎没有子例程。从那时起，大部分时间都是惯性。

例如，Go具有多个返回值，并且结果比使用“ out”参数更整洁，模棱两可。经过一点使用，它是非常自然和高效的。我建议为所有新语言考虑多个返回值。也许也适用于古老的语言。

它可能与处理器机器指令中如何进行函数调用的遗留问题以及所有编程语言均源自机器代码的事实有关，例如C-> Assembly-> Machine。

处理器如何执行功能调用

首先用机器代码编写程序，然后进行汇编。处理器通过将所有当前寄存器的副本压入堆栈来支持函数调用。从函数返回将从堆栈中弹出已保存的寄存器集。通常，一个寄存器保持不变，以允许返回函数返回一个值。

现在，为什么要这样设计处理器……这可能是资源紧张的问题。