作为程序员，您当然知道由于明显的递归而导致的堆栈溢出错误。但是，当然有很多怪异和不寻常的方法可以使您喜欢的语言吐出该错误。

目标：

1. 必须引起堆栈溢出，该堆栈溢出在错误输出中清晰可见。
2. 不允许使用明显的递归。

无效程序的示例：

// Invalid, direct obvious recursion.
methodA(){ methodA(); }

// Invalid, indirect, but obvious recursion.
methodA(){ methodB(); }
methodB(){ methodA(); }

最有创意的方式是最好的，因为这是一场人气比赛。也就是说，避免无聊的答案是这样的：

throw new StackOverflowError(); // Valid, but very boring and downvote-deserving.

即使我现在接受了答案，也可以添加更多答案:)

蟒蛇

import sys
sys.setrecursionlimit(1)

这将导致解释器立即失败：

$ cat test.py
import sys
sys.setrecursionlimit(1)
$ python test.py
Exception RuntimeError: 'maximum recursion depth exceeded' in <function _remove at 0x10e947b18> ignored
Exception RuntimeError: 'maximum recursion depth exceeded' in <function _remove at 0x10e8f6050> ignored
$ 

它不使用递归，而只是收缩堆栈，因此它将立即溢出。

蟒蛇

import webbrowser
webbrowser.open("http://stackoverflow.com/")

C / Linux 32位

void g(void *p){
        void *a[1];
        a[2]=p-5;
}
void f(){
        void *a[1];
        g(a[2]);
}
main(){
        f();
        return 0;
}

通过覆盖返回地址来工作，因此g返回到main调用之前的位置f。适用于返回地址在堆栈上的任何平台，但可能需要进行调整。

当然，在数组外部进行写操作是未定义的行为，您无法保证会导致堆栈溢出，而不是将胡须涂成蓝色。平台，编译器和编译标志的详细信息可能会有很大的不同。

JavaScript / DOM

with (document.body) {
    addEventListener('DOMSubtreeModified', function() {
        appendChild(firstChild);
    }, false);

    title = 'Kill me!';
}

如果您想杀死浏览器，请在控制台中尝试一下。

爪哇

在这里某处看到这样的东西：

编辑：找到我在哪里看到：乔K对引发StackOverflow错误的最短程序的答案

public class A {
    String val;
    public String toString() {
        return val + this;
    }

    public static void main(String[] args) {
        System.out.println(new A());
    }
}

这会使一些Java初学者感到困惑。它只是隐藏了递归调用。val + this成为val + this.toString()因为val是一个字符串。

看到它在这里运行：http : //ideone.com/Z0sXiD

C

很简单：

int main()
{
    int large[10000000] = {0};
    return 0;
}

C中的非递归堆栈溢出

调用约定不匹配。

typedef void __stdcall (* ptr) (int);

void __cdecl hello (int x) { }

void main () {
  ptr goodbye = (ptr)&hello;
  while (1) 
    goodbye(0);
}

用编译gcc -O0。

__cdecl函数希望调用者清理堆栈，并__stdcall希望被调用者这样做，因此通过类型转换函数指针进行调用，清理永远不会完成- main将参数推送到每次调用的堆栈上，但不会弹出，最终堆栈填充。

的JavaScript

window.toString = String.toLocaleString;
+this;

我对Java 7和Java 8不受我先前回答中的恶意代码的困扰而感到沮丧。因此，我认为有必要为此添加一个补丁。

成功！我printStackTrace()扔了一个StackOverflowError。printStackTrace()通常用于调试和日志记录，没有人合理地怀疑它可能很危险。不难看出该代码可能会被滥用以产生一些严重的安全问题：

public class StillMoreEvilThanMyPreviousOne {
    public static void main(String[] args) {
        try {
            evilMethod();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void evilMethod() throws Exception {
        throw new EvilException();
    }

    public static class EvilException extends Exception {
        @Override
        public Throwable getCause() {
            return new EvilException();
        }
    }
}

有人可能认为这是显而易见的递归。它不是。该EvilException构造函数不调用getCause()方法，使异常实际上可以安全地毕竟抛出。调用该getCause()方法将不会导致StackOverflowError两者之一。递归位于JDK的正常printStackTrace()行为之外，以及用于检查异常的用于调试和日志记录的任何第三方库。此外，抛出异常的位置可能与处理异常的位置相距甚远。

无论如何，这里的代码确实会引发，并且根本不StackOverflowError包含任何递归方法调用。在StackOverflowError外面发生的main方法，在JDK的UncaughtExceptionHandler：

public class StillMoreEvilThanMyPreviousOneVersion2 {
    public static void main(String[] args) {
        evilMethod();
    }

    private static void evilMethod() {
        throw new EvilException();
    }

    public static class EvilException extends RuntimeException {
        @Override
        public Throwable getCause() {
            return new EvilException();
        }
    }
}

Exception: java.lang.StackOverflowError thrown from the UncaughtExceptionHandler in thread "main"

Linux x86 NASM组装

section .data
    helloStr:     db 'Hello world!',10 ; Define our string
    helloStrLen:  equ $-helloStr       ; Define the length of our string

section .text
    global _start

    doExit:
        mov eax,1 ; Exit is syscall 1
        mov ebx,0 ; Exit status for success
        int 80h   ; Execute syscall

    printHello:
        mov eax,4           ; Write syscall is No. 4
        mov ebx,1           ; File descriptor 1, stdout
        mov ecx,helloStr    ; Our hello string
        mov edx,helloStrLen ; The length of our hello string
        int 80h             ; execute the syscall

    _start:
        call printHello ; Print "Hello World!" once
        call doExit     ; Exit afterwards

扰流板：

忘记了从printHello返回，因此我们再次跳入_start。

编译时使用C ++

template <unsigned N>
struct S : S<N-1> {};

template <>
struct S<0> {};

template
struct S<-1>;

$ g ++ -c test.cc -ftemplate-depth = 40000
g ++：内部编译器错误：分段错误（程序cc1plus）
请提交完整的错误报告，
如果合适，请使用预处理的源。
有关说明，请参见。

此源文件没有递归，没有一个类本身具有基类，甚至没有间接的基类。（在C ++中，在这样的模板类中，S<1>并且S<2>是完全不同的类。）分段错误是由于在编译器中递归之后的堆栈溢出引起的。

重击（危险警报）

while true
do 
  mkdir x
  cd x
done

严格来说，这不会直接导致堆栈溢出，但会生成可能被标记为“ 持久性堆栈溢出生成情况 ”：当您运行此操作直到磁盘已满时，并希望使用“ rm -rf”消除混乱x”，表示已命中。

但是，并非所有系统都这样。有些比其他的更健壮。

大危险警告：

某些系统处理起来非常糟糕，您可能很难清理（因为“ rm -rf”本身会遇到响应问题）。您可能必须编写类似的脚本来进行清理。

如果不确定，最好在暂存VM中尝试。

PS：当然，如果以批处理脚本编程或完成，则同样适用。
PPS：获得您的评论，您的特定系统的行为方式可能会很麻烦...

爪哇

Java Puzzlers的一个不错的选择。它打印什么？

public class Reluctant {
    private Reluctant internalInstance = new Reluctant();

    public Reluctant() throws Exception {
        throw new Exception("I'm not coming out");
    }

    public static void main(String[] args) {
        try {
            Reluctant b = new Reluctant();
            System.out.println("Surprise!");
        } catch (Exception ex) {
            System.out.println("I told you so");
        }
    }
}

实际上，它失败并显示StackOverflowError。

构造函数中的异常只是一个红色鲱鱼。这是书上要说的：

调用构造函数时，实例变量初始化程序在构造函数的主体之前运行。在这种情况下，变量的初始化程序将internalInstance递归调用构造函数。反过来，该构造函数internalInstance通过再次调用Reluctant构造函数等来无限期地初始化其自己的 字段。这些递归调用会导致 StackOverflowError构造函数主体有机会执行之前。因为StackOverflowError是Error而不是 的子类型Exception，所以中的catch子句main不会捕获它。

胶乳

\end\end

输入堆栈溢出，因为\end反复膨胀本身无限循环，如解释在这里。

TeX失败，出现TeX capacity exceeded, sorry [input stack size=5000]或类似符号。

高炉

最终将使堆栈溢出，仅取决于解释程序使堆栈多长时间...

+[>+]

C＃，在编译时

有多种方法可以使Microsoft C＃编译器崩溃。每当您看到C＃编译器的“表达式过于复杂而无法编译”错误时，几乎可以肯定是因为堆栈已损坏。

解析器是递归下降的，因此任何深度嵌套的语言结构都将破坏堆栈：

 class C { class C { class C { ....

表达式解析器非常聪明，可以消除通常递归的那一侧的递归。通常：

x = 1 + 1 + 1 + 1 + .... + 1;

它构建了一个非常深的解析树，不会破坏堆栈。但是，如果您强制递归发生在另一侧：

x = 1 + (1 + (1 + (1 + ....+ (1 + 1))))))))))))))))))))))))))))))))))))))))))...;

然后可以将堆栈吹散。

这些具有程序非常大的特性。也有可能使语义分析器使用一个小的程序进入无限的递归，因为它不够智能，无法删除类型系统中的某些奇数循环。（罗斯林可能会改善这一点。）

public interface IN<in U> {}
public interface IC<X> : IN<IN<IC<IC<X>>>> {}
...
IC<double> bar = whatever;
IN<IC<string>> foo = bar;  // Is this assignment legal? 

我在这里描述了为什么这种分析进行无限递归：

http://blogs.msdn.com/b/ericlippert/archive/2008/05/07/covariance-and-contravariance-part-twelve-to-infinity-but-not-beyond.aspx

对于更多有趣的示例，您应该阅读本文：

http://research.microsoft.com/en-us/um/people/akenn/generics/FOOL2007.pdf

在互联网上 （每天有十亿人使用）

Redirects, HTTP status code: 301

例如，在Dell支持网站上（无罪，对不起Dell）：

如果从URL中删除了支持TAG，那么它将进入 无限重定向。在以下URL中，######是任何支持TAG。

http://www.dell.com/support/drivers/uk/zh-CN/ukdhs1/ServiceTag/#######ss=BSD&~ck=mn

我相信这相当于堆栈溢出。

的PHP

仅使用循环元素完成的stackoverflow。

$a = array(&$a);
while (1) {
    foreach ($a as &$tmp) {
        $tmp = array($tmp, &$a);
    }
}

说明（悬停以查看扰流板）：

当解释器尝试将$tmp数组垃圾回收时（在$tmp此处重新分配时），该程序将出现段错误。仅仅因为数组太深（自引用），然后垃圾回收器最终以递归的形式结束。

爪哇

我做的恰恰相反–一个程序显然应该引发堆栈溢出错误，但是没有。

public class Evil {
    public static void main(String[] args) {
        recurse();
    }

    private static void recurse() {
        try {
            recurse();
        } finally {
            recurse();
        }
    }
}

提示：程序运行时间为O（2 ⁿ），n是堆栈的大小（通常为1024）。

来自Java难题者＃45：

假设我们的机器每秒可以执行10 10 ^个调用并每秒生成10 ^10个异常，这在当前标准下是相当慷慨的。根据这些假设，该程序将在大约1.7×10 ²⁹¹年内终止。从这个角度来看，我们的太阳寿命估计为10 ¹⁰年，因此可以肯定的是，我们谁也不会看到这个程序终止。尽管它不是无限循环，但也可能是无限循环。

C＃

第一篇文章，所以请对我轻松一点。

class Program
{
    static void Main()
    {
        new System.Diagnostics.StackTrace().GetFrame(0).GetMethod().Invoke(null, null);
    }
}

这只是创建一个堆栈跟踪，获取顶部框架（这是我们对的最后一次调用Main()），获取方法，然后调用它。

爪哇

• 在Java 5中，printStackTrace()进入无限循环。
• 在Java 6中，printStackTrace()throws StackOverflowError。
• 在Java 7和8中，此问题已修复。

疯狂的是，在Java 5和6中，它不是来自用户代码，而是发生在JDK的代码中。没有一个合理的嫌疑人可能printStackTrace()会被处决。

public class Bad {
    public static void main(String[] args) {
        try {
            evilMethod();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void evilMethod() throws Exception {
        Exception a = new Exception();
        Exception b = new Exception(a);
        a.initCause(b);
        throw a;
    }
}

JavaScript：非递归的迭代函数变异

var f = function() {
    console.log(arguments.length);
};

while (true) {
    f = f.bind(null, 1);
    f();
}

这里根本没有递归。f它将反复使用越来越多的参数，直到它可以在单个函数调用中使堆栈溢出。console.log如果要查看执行此操作需要多少个参数，则该部分是可选的。它还确保了聪明的JS引擎不会对此进行优化。

CoffeeScript中的代码高尔夫球版本，28个字符：

f=->
do f=f.bind f,1 while 1

具有史诗般失败的C＃

using System.Xml.Serialization;

[XmlRoot]
public class P
{
    public P X { get { return new P(); } set { } }
    static void Main()
    {
        new XmlSerializer(typeof(P)).Serialize(System.Console.Out, new P());
    }
}

失败的方式是史诗般的，它使我完全震惊：

它只是一系列看似无限的奇怪图像的一帧。

这一定是有史以来最奇怪的事情。有人可以解释吗？显然，用于缩进的空间的不断增加导致这些白色块出现。它发生在带有.NET 4.5的Win7 Enterprise x64上。

我还没有真正看到结局。如果替换System.Console.Out为System.IO.Stream.Null，它会很快消失。

解释很简单。我创建一个具有单个属性的类，并且该类始终返回其包含类型的新实例。因此，这是一个无限深的对象层次结构。现在，我们需要一些可以尝试通读的内容。那是我使用的地方XmlSerializer，它就是这样做的。显然，它使用递归。

重击

_(){ _;};_

尽管许多人可能认识到递归是显而易见的，但它看起来很漂亮。没有？

执行后，可以保证看到：

Segmentation fault (core dumped)

哈斯克尔

（很遗憾，但直到至少ghc-7.6，它都是正确的，尽管使用O1或更多它会解决问题）

main = print $ sum [1 .. 100000000]

短暂聊天

这将创建在飞行的新方法，其
  产生的飞行，这一个新的方法
    创建上飞的新方法，它
      ...
    ...
  ..
然后转移到它。

通过创建越来越长的方法名称和大量的接收者，同时强调堆栈内存和堆内存，这又增加了一点点趣味……（但是递归首先打击了我们）。

在Integer中编译：

downTheRabbitHole
    |name deeperName nextLevel|

    nextLevel := self * 2.
    name := thisContext selector.
    deeperName := (name , '_') asSymbol.
    Class withoutUpdatingChangesDo:[
        nextLevel class 
            compile:deeperName , (thisContext method source copyFrom:name size+1).
    ].
    Transcript show:self; showCR:' - and down the rabbit hole...'.
    "/ self halt. "/ enable for debugging
    nextLevel perform:deeperName.

然后通过评估"2 downTheRabbitHole"…… 跳转
……一段时间之后，您将进入调试器，显示RecursionException。

然后，您必须清理所有混乱（SmallInteger和LargeInteger现在都具有大量的仙境代码）：

{SmallInteger . LargeInteger } do:[:eachInfectedClass |
    (eachInfectedClass methodDictionary keys 
        select:[:nm| nm startsWith:'downTheRabbitHole_'])
            do:[:each| eachInfectedClass removeSelector:each]

否则花一些时间在浏览器中，删除爱丽丝的仙境。

这是跟踪的开头：

2 - and down the rabbit hole...
4 - and down the rabbit hole...
8 - and down the rabbit hole...
16 - and down the rabbit hole...
[...]
576460752303423488 - and down the rabbit hole...
1152921504606846976 - and down the rabbit hole...
2305843009213693952 - and down the rabbit hole...
[...]
1267650600228229401496703205376 - and down the rabbit hole...
2535301200456458802993406410752 - and down the rabbit hole...
5070602400912917605986812821504 - and down the rabbit hole...
[...]
162259276829213363391578010288128 - and down the rabbit hole...
324518553658426726783156020576256 - and down the rabbit hole...
[...]
and so on...

PS：添加了“ withoutUpdatingChangesFile：”，以避免以后必须清除Smalltalk的永久更改日志文件。

PPS：感谢挑战：思考新事物和创新很有趣！

PPPS：我想指出，一些Smalltalk方言/版本将溢出的堆栈帧复制到堆中-因此它们可能会遇到内存不足的情况。

C＃

真的很大struct，没有递归，纯C＃，不是不安全的代码。

public struct Wyern
{
    double a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;
}
public struct Godzilla
{
    Wyern a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;
}
public struct Cyclops
{
    Godzilla a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;
}
public struct Titan
{
    Cyclops a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;
}
class Program
{
    static void Main(string[] args)
    {
        // An unhandled exception of type 'System.StackOverflowException' occurred in ConsoleApplication1.exe
        var A=new Titan();
        // 26×26×26×26×8 = 3655808 bytes            
        Console.WriteLine("Size={0}", Marshal.SizeOf(A));
    }
}

作为踢手，它使调试窗口崩溃，指出 {Cannot evaluate expression because the current thread is in a stack overflow state.}

和通用版本（感谢NPSF3000的建议）

public struct Wyern<T>
    where T: struct
{
    T a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;        
}


class Program
{
    static void Main(string[] args)
    {
        // An unhandled exception of type 'System.StackOverflowException' occurred in ConsoleApplication1.exe
        var A=new Wyern<Wyern<Wyern<Wyern<int>>>>();
    }
}

C＃

覆盖==运算符的错误实现：

public class MyClass
{
    public int A { get; set; }

    public static bool operator ==(MyClass obj1, MyClass obj2)
    {
        if (obj1 == null)
        {
            return obj2 == null;
        }
        else
        {
            return obj1.Equals(obj2);
        }
    }

    public static bool operator !=(MyClass obj1, MyClass obj2)
    {
        return !(obj1 == obj2);
    }

    public override bool Equals(object obj)
    {
        MyClass other = obj as MyClass;
        if (other == null)
        {
            return false;
        }
        else
        {
            return A == other.A;
        }
    }
}

可能有人会说operator==使用==操作符进行调用很明显，但是您通常不这么认为==，因此很容易陷入陷阱。

使用SnakeYAML开始回复

class A
{

    public static void main(String[] a)
    {
         new org.yaml.snakeyaml.Yaml().dump(new java.awt.Point());
    }
}

编辑：取消高尔夫

读者自行决定：P的工作原理（提示：stackoverflow.com）

顺便说一句：递归是由SnakeYAML动态进行的（您会知道，如果您知道它如何检测到它序列化的字段，然后在Point的源代码中查看）

编辑：告诉一个人如何工作：

SnakeYAML查找一个双getXXX和setXXXmthod具有相同名称为XXX并返回吸气剂的类型是相同的设定器的参数; 令人惊讶的是，Point该类具有Point getLocation()和void setLocation(Point P)并返回自身；SnakeYAML不会注意到它，而是在该怪癖和StackOverflows上重复进行。在与他们一起在a内HashMap并在其上询问stackoverflow.com 时发现了那个。

C＃

错误实现的属性获取器

class C
{
   public int P { get { return P; } }
}

static void Main()
{
   int p = new C().P;
}