很简单，什么是尾部调用优化？更具体地说，任何人都可以显示一些可以应用的小代码片段，而不是在哪里，并解释为什么？
尾调用优化是您可以避免为函数分配新堆栈帧的地方，因为调用函数将只返回它从被调用函数获得的值。最常见的用法是尾递归，其中为利用尾调用优化而编写的递归函数可以使用常量堆栈空间。
Scheme是规范中保证任何实现都必须提供此优化的少数编程语言之一（JavaScript也从ES6开始），因此这里有两个Scheme中的阶乘函数示例：
(define (fact x)
(if (= x 0) 1
(* x (fact (- x 1)))))
(define (fact x)
(define (fact-tail x accum)
(if (= x 0) accum
(fact-tail (- x 1) (* x accum))))
(fact-tail x 1))
第一个函数不是尾递归，因为在进行递归调用时，函数需要跟踪调用返回后它需要对结果进行的乘法。因此，堆栈如下所示：
(fact 3)
(* 3 (fact 2))
(* 3 (* 2 (fact 1)))
(* 3 (* 2 (* 1 (fact 0))))
(* 3 (* 2 (* 1 1)))
(* 3 (* 2 1))
(* 3 2)
6
相反，尾递归阶乘的堆栈跟踪如下所示：
(fact 3)
(fact-tail 3 1)
(fact-tail 2 3)
(fact-tail 1 6)
(fact-tail 0 6)
6
正如您所看到的，我们只需要跟踪每次调用事实尾部的相同数据量，因为我们只是将我们直接返回的值返回到顶部。这意味着即使我打电话（事实1000000），我只需要与（事实3）相同的空间。非尾递归事实不是这种情况，因此大的值可能导致堆栈溢出。
让我们来看一个简单的例子：在C中实现的阶乘函数。
我们从明显的递归定义开始
unsigned fac(unsigned n)
{
if (n < 2) return 1;
return n * fac(n - 1);
}
如果函数返回之前的最后一个操作是另一个函数调用，则函数以尾调用结束。如果此调用调用相同的函数，则它是尾递归的。
即使fac()乍一看看起来是尾递归的，但事实并非如此
unsigned fac(unsigned n)
{
if (n < 2) return 1;
unsigned acc = fac(n - 1);
return n * acc;
}
即最后一个操作是乘法，而不是函数调用。
但是，通过将累积值作为附加参数传递给调用链并仅将最终结果作为返回值再次传递，可以将fac()重写为尾递归：
unsigned fac(unsigned n)
{
return fac_tailrec(1, n);
}
unsigned fac_tailrec(unsigned acc, unsigned n)
{
if (n < 2) return acc;
return fac_tailrec(n * acc, n - 1);
}
现在，为什么这有用？因为我们在尾调用之后立即返回，所以我们可以在尾部位置调用函数之前丢弃先前的堆栈帧，或者，在递归函数的情况下，按原样重用堆栈帧。
尾调用优化将我们的递归代码转换为
unsigned fac_tailrec(unsigned acc, unsigned n)
{
TOP:
if (n < 2) return acc;
acc = n * acc;
n = n - 1;
goto TOP;
}
这可以内联到fac()，我们到达
unsigned fac(unsigned n)
{
unsigned acc = 1;
TOP:
if (n < 2) return acc;
acc = n * acc;
n = n - 1;
goto TOP;
}
这相当于
unsigned fac(unsigned n)
{
unsigned acc = 1;
for (; n > 1; --n)
acc *= n;
return acc;
}
正如我们在这里看到的，一个足够先进的优化器可以用迭代替换尾递归，这比避免函数调用开销和仅使用恒定量的堆栈空间更有效。
TCO（尾调用优化）是智能编译器可以调用函数并且不占用额外堆栈空间的过程。发生这种情况的唯一情况是，函数f中执行的最后一条指令是对函数g的调用（注意：g可以是f）。这里的关键是f不再需要堆栈空间 - 它只是调用g然后返回g将返回的任何内容。在这种情况下，可以进行优化，g只运行并返回它对调用f的东西所具有的任何值。
这种优化可以使递归调用占用不变的堆栈空间，而不是爆炸。
示例：此阶乘函数不是TCOptimizable：
def fact(n):
if n == 0:
return 1
return n * fact(n-1)
除了在return语句中调用另一个函数之外，该函数还可以执
以下功能是TCOptimizable：
def fact_h(n, acc):
if n == 0:
return acc
return fact_h(n-1, acc*n)
def fact(n):
return fact_h(n, 1)
这是因为在这些函数中发生的最后一件事是调用另一个函数。
我发现尾部调用，递归尾调用和尾调用优化的最佳高级描述可能是博客文章
"What the heck is: A tail call"
作者Dan Sugalski。关于尾调用优化，他写道：
暂时考虑一下这个简单的功能：
sub foo (int a) { a += 15; return bar(a); }那么，你或者你的语言编译器能做什么呢？那么，它能做的是将
return somefunc();形式的代码转换为低级序列pop stack frame; goto somefunc();。在我们的例子中，这意味着在我们调用bar之前，foo清理自己然后，而不是将bar称为子例程，我们在goto的开始做一个低级别的bar操作。Foo已经清理了自己的堆栈，所以当bar开始时，看起来无论谁叫foo真的叫bar，当bar返回它的值时，它直接将它返回给任何叫foo的人，而不是将它返回到foo然后返回它给它的来电者。
并在尾递归：
如果函数作为其最后一个操作返回调用自身的结果，则会发生尾递归。尾部递归更容易处理，因为你不必在某个地方跳到某个随机函数的开头，而只是回到自己的开头，这是一件很容易做的事情。
这样：
sub foo (int a, int b) { if (b == 1) { return a; } else { return foo(a*a + a, b - 1); }
悄然变成：
sub foo (int a, int b) { label: if (b == 1) { return a; } else { a = a*a + a; b = b - 1; goto label; }
我喜欢这个描述的是那些来自命令式语言背景的人（C，C ++，Java）如何简洁易懂
首先要注意的是，并非所有语言都支持它。
TCO适用于递归的特殊情况。它的要点是，如果你在函数中做的最后一件事是调用自身（例如它从“尾部”位置调用自身），编译器可以优化它，就像迭代而不是标准递归一样。
您会看到，通常在递归期间，运行时需要跟踪所有递归调用，以便在返回时它可以在上一次调用时恢复，依此类推。 （尝试手动写出递归调用的结果，以便直观地了解其工作原理。）跟踪所有调用会占用空间，当函数调用自身时，空间会变得很大。但是对于TCO，它可以说“回到开头，只是这次将参数值更改为这些新值。”它可以做到这一点，因为在递归调用之后没有任何内容引用那些值。
使用x86反汇编分析的GCC最小可运行示例
让我们看看GCC如何通过查看生成的程序集来自动为我们进行尾调用优化。
这将作为https://stackoverflow.com/a/9814654/895245等其他答案中提到的极其具体的例子，即优化可以将递归函数调用转换为循环。
由于memory accesses are often the main thing that makes programs slow nowadays，这反过来可以节省内存并提高性能。
作为输入，我们给GCC一个非优化的天真堆栈基因：
tail_call.c
#include <stdio.h>
#include <stdlib.h>
unsigned factorial(unsigned n) {
if (n == 1) {
return 1;
}
return n * factorial(n - 1);
}
int main(int argc, char **argv) {
int input;
if (argc > 1) {
input = strtoul(argv[1], NULL, 0);
} else {
input = 5;
}
printf("%u\n", factorial(input));
return EXIT_SUCCESS;
}
编译和反汇编：
gcc -O1 -foptimize-sibling-calls -ggdb3 -std=c99 -Wall -Wextra -Wpedantic \
-o tail_call.out tail_call.c
objdump -d tail_call.out
其中-foptimize-sibling-calls是根据man gcc的尾调用泛化的名称：
-foptimize-sibling-calls
Optimize sibling and tail recursive calls.
Enabled at levels -O2, -O3, -Os.
如上所述：How do I check if gcc is performing tail-recursion optimization?
我选择-O1是因为：
-O0完成的。我怀疑这是因为缺少必要的中间转换。-O3产生不具有效率的非常有效的代码，尽管它也是尾部调用优化的。使用-fno-optimize-sibling-calls进行反汇编：
0000000000001145 <factorial>:
1145: 89 f8 mov %edi,%eax
1147: 83 ff 01 cmp $0x1,%edi
114a: 74 10 je 115c <factorial+0x17>
114c: 53 push %rbx
114d: 89 fb mov %edi,%ebx
114f: 8d 7f ff lea -0x1(%rdi),%edi
1152: e8 ee ff ff ff callq 1145 <factorial>
1157: 0f af c3 imul %ebx,%eax
115a: 5b pop %rbx
115b: c3 retq
115c: c3 retq
使用-foptimize-sibling-calls：
0000000000001145 <factorial>:
1145: b8 01 00 00 00 mov $0x1,%eax
114a: 83 ff 01 cmp $0x1,%edi
114d: 74 0e je 115d <factorial+0x18>
114f: 8d 57 ff lea -0x1(%rdi),%edx
1152: 0f af c7 imul %edi,%eax
1155: 89 d7 mov %edx,%edi
1157: 83 fa 01 cmp $0x1,%edx
115a: 75 f3 jne 114f <factorial+0xa>
115c: c3 retq
115d: 89 f8 mov %edi,%eax
115f: c3 retq
两者之间的关键区别在于：
-fno-optimize-sibling-calls使用callq，这是典型的非优化函数调用。
该指令将返回地址推送到堆栈，从而增加它。
此外，这个版本也做push %rbx，pushes %rbx to the stack。
GCC这样做是因为它存储edi，这是第一个函数参数（n）到ebx，然后调用factorial。
海湾合作委员会需要这样做，因为它正准备再次调用factorial，它将使用新的edi == n-1。
它选择ebx，因为这个寄存器是被调用者保存的：What registers are preserved through a linux x86-64 function call所以factorial的子语句不会改变它并丢失n。-foptimize-sibling-calls没有使用任何推进堆栈的指令：它只会使用goto和factorial指令在je内跳跃。
因此，这个版本相当于一个while循环，没有任何函数调用。堆栈使用量是不变的。在Ubuntu 18.10，GCC 8.2中测试。
看这里：
jne
您可能知道，递归函数调用可能会对堆栈造成严重破坏;很容易快速耗尽堆栈空间。尾调用优化是一种可以创建使用常量堆栈空间的递归样式算法的方法，因此它不会增长和增长，并且会出现堆栈错误。
递归函数方法存在问题。它构建了一个大小为O（n）的调用堆栈，这使得我们的总内存成本为O（n）。这使得它容易受到堆栈溢出错误的影响，其中调用堆栈变得太大并且空间不足。尾部成本优化（TCO）计划。它可以优化递归函数，以避免构建一个高调用堆栈，从而节省内存成本。
有许多语言正在进行TCO，如（Javascript，Ruby和少数C），而Python和Java不做TCO。
JavaScript语言已确认使用:) void eternity()
{
eternity();
}