为什么大多数编程语言仅支持从函数返回单个值？ [关闭]

#1 楼

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

但是通常，即使在支持它们的语言中，也不经常使用多个返回值因为它们草率：


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

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

(password, username) = GetUsernameAndPassword()  

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

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

它们相当方便的地方是使用多种语言（例如Python）一个函数的返回值可以用作另一个函数的多个输入参数。但是，这是比使用类更好的设计的用例。

#2 楼

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

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

#3 楼

在数学中，“定义明确”的函数是给定输入只有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就足够了。

#4 楼

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

#5 楼

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

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

这里有一些语言示例不支持返回多个值。我真的看不到如何增加对多个返回值的支持，从而使它们显着地表现出来，以抵消新语言功能的成本。 “ lang-rb prettyprint-override”> def foo; return 1, 2, 3 end one, two, three = foo one # => 1 three # => 3

Python

 def foo(): return 1, 2, 3

one, two, three = foo()

one
# >>> 1

three
# >>> 3
 

Scala

 def foo = (1, 2, 3)

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

Haskell

>

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

#6 楼

单个返回值如此受欢迎的真正原因是在许多语言中使用的表达式。在任何可以使用x + 1这样的表达式的语言中，您已经在考虑单一返回值，因为您可以通过将表达式分解成小段并确定每段的值来评估表达式。您查看x并确定其值为3（例如），然后查看1，然后查看x + 1并将其放在一起确定整体的值为4。表达式的每个句法部分都有一个值，没有其他数量的值；这是每个人都期望的表达式的自然语义。即使一个函数返回一对值，它实际上仍在返回一个正在执行两个值的值，因为返回不以某种方式包装到单个集合中的两个值的函数的想法太奇怪了。 />
人们不想处理使函数返回多个值所需要的替代语义。例如，在像Forth这样基于堆栈的语言中，您可以具有任意数量的返回值，因为每个函数仅修改堆栈的顶部，弹出输入并随意推送输出。这就是为什么Forth没有普通语言所具有的那种表达的原因。
Perl是另一种有时可以像函数一样返回多个值的语言，即使通常只考虑返回列表。 Perl中的“内插”列表方式为我们提供了(1, foo(), 3)之类的列表，其中可能包含3个元素，这与大多数不了解Perl的人所期望的一样，但也很容易只有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。

#7 楼

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


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


Fortran，Lisp和COBOL，第一个使用单个返回值，因为它是基于数学建模的。第二个返回任意数量的参数，方式与接收它们的方式相同：作为一个列表（也可以说它只传递并返回了一个参数：列表的地址）。第三种返回零或一个值。

这些第一种语言对跟随其后的语言的设计产生了很大影响，尽管唯一返回多个值的语言Lisp从未受到广泛欢迎。 />
当C语言问世时，它受到以前的语言的影响，但它非常注重有效地利用硬件资源，使C语言的功能与实现它的机器代码之间保持紧密的联系。它的一些最古老的功能（例如“ auto”和“ register”变量）是这种设计理念的结果。

还必须指出，汇编语言在80年代以前很流行。终于开始逐步退出主流发展。编写编译器和创建语言的人都熟悉汇编语言，并且在大多数情况下，都坚持在其中工作得最好。

大多数与该规范不同的语言从未受到欢迎，并且，因此，从来没有在影响语言设计师的决策方面发挥过强大的作用（当然，他们是受他们所了解的启发）。

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

在技​​术说明中，它具有5个寄存器以及一些1位标志。唯一的“满”寄存器是程序计数器（PC）－该寄存器指向要执行的下一条指令。其他寄存器中有累加器（A），两个“索引”寄存器（X和Y）以及堆栈指针（SP）。 SP，然后递减SP。从子例程返回则相反。一个人可以在堆栈中推入和拉出其他值，但是相对于SP而言，它很难引用内存，因此，编写可重入子例程非常困难。我们认为这是理所当然的，它在我们认为可以随时调用子例程的情况下，在这种体系结构上并不常见。通常，会创建一个单独的“堆栈”，以便将参数和子例程返回地址保持分开。索引寄存器（IX），与SP一样宽，可以从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上使用的8080和许多基于CP / M的微型计算机可以通过将SP压入堆栈，然后将其弹出到其间接寄存器HL中来实现与6800类似的功能。

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

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

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

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

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

至于数学……好吧，在我上数学课之前，我正在用计算机编程。 CS和编程语言的整个部分都受到数学的影响，但同样，整个部分都没有。

因此，我们将数学影响早期语言设计的因素融合在一起，其中硬件限制决定了易于实现的方面，流行语言在哪些方面影响了硬件的发展方式（在此过程中，Lisp机器和Forth机器处理器是必杀技）。

#8 楼

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

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个整数的函数。 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参数（在大多数情况下为2或允许使用更多这些方法。）

#9 楼

我认为这是由于诸如(a + b[i]) * c之类的表达式引起的。

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

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

#10 楼

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

#11 楼

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

x = n + sqrt(y);

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

#12 楼

我只想基于Harvey的答案。我最初是在新闻技术网站（arstechnica）上找到这个问题的，并找到了一个令人惊奇的解释，我认为它确实回答了这个问题的核心，而其他所有答案（除了Harvey的答案）都没有：函数的单次返回源于机器代码。在机器代码级别，函数可以在A（累加器）寄存器中返回一个值。任何其他返回值都将在堆栈上。

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

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

#13 楼

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

COBOL几乎和以前一样，没有明确的返回值。它几乎没有子例程。从那时起，它一直都是惯性。例如，Go具有多个返回值，并且结果比使用“ out”参数更整洁，模棱两可。经过一点使用，它是非常自然和高效的。我建议为所有新语言考虑多个返回值。也许也适用于旧语言。

#14 楼

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

处理器如何执行函数调用

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

现在，为什么要以这种方式设计处理器...这可能是资源限制的问题。