为什么以下程序会出现段错误？

int main() { main(); }

即使它是一个没有结束的递归,因此根据定义也是无效的,我不明白它为什么是segfaults(gcc 4.4.3和clang 1.5(trunk)).

如何在Java中重现EXCEPTION_STACK_OVERFLOW错误.

PS:我不是在谈论优雅地关闭JVM的Java中的StackOverflowError错误.我在讨论error.log中的EXCEPTION_STACK_OVERFLOW,这会导致JVM崩溃.

我没有发现C99标准中计数函数参数的任何限制,我想它只受堆栈大小的限制.

但是,我编写了一个简单的测试程序来演示具有大量参数的函数的行为.当它大约10k时,我在gcc上遇到以下错误(gg版本4.5.3在Cygwin上):

/usr/lib/gcc/i686-pc-cygwin/4.5.3/../../../libcygwin.a(libcmain.o):(.text+0xa9): undefined reference to `_WinMain@16'

我意识到如此大量的参数不太可能,但我想知道编译器的哪个参数决定了这个限制？

编辑

脚本生成C源代码

#!/bin/sh

num=$1

echo "" > out.c
echo "#include <stdio.h>" >> out.c

echo "int getsum( " >> out.c

i=0
while [ $i -lt $num ]
do
    ((i++))
    if [ $i -eq $num ] 
    then
        echo "int p$i )" >> out.c
    else 
        echo -ne "int p$i," >> out.c
    fi
done

echo "{" >> out.c

echo -ne "  return " >> out.c

i=0
while [ $i -lt $num ]
do
    ((i++))
        if [ …

在Java中,有没有办法查看完整的,未截断的堆栈跟踪(例如,通过增加记录的帧数),或以其他方式获取堆栈跟踪的底部？通常情况下,堆栈跟踪在1024帧的情况下从顶部被截断,但是对于堆栈溢出问题,这实际上是毫无价值的,因为您确实需要查看是谁进行了触发递归的调用,靠近底部.更好的是在堆栈中间截断,但显然Sun的JVM不够聪明,无法做到这一点.

甚至可能是一些特殊的Sun特定标志？我尝试将堆栈大小减小到允许的最小值(-Xss1000),但仍然超过1024帧.

就我而言,我正在尝试调试Hadoop映射器中发生的堆栈溢出,但仅限于在非常大的输入上运行时.我假设问题来了,因为递归操作(Scala foldRight)正在一个非常大的链表上完成,我需要非递归地重写它...但我需要知道是谁调用了它foldRight.这是一个直接和间接在很多地方调用的基本例程,我正在使用很多很多代码,所以这是非常不明显的.

这段代码有什么问题:

using System;
namespace app1
{
    static class Program
    {
        static int x = 0;
        static void Main()
        {
            fn1();
        }
        static void fn1()
        {
            Console.WriteLine(x++);
            fn1();
        }
    }
}

我使用这个命令编译这段代码:

csc /warn:0 /out:app4noex.exe app4.cs

当我双击exe时,它似乎没有抛出异常(StackOverFlowException),并且永远保持运行.

使用visual studio命令提示符2010,但我也在系统上安装了vs 2012,都是最新的.

我正在开发一个Android应用程序,它使用JSON字符串从服务器下载兴趣点.一切都工作正常但是因为我已经开始测试4.2.1,我收到了以下错误:

01-28 15:32:14.167: E/AndroidRuntime(31174): FATAL EXCEPTION: AsyncTask #1
01-28 15:32:14.167: E/AndroidRuntime(31174): java.lang.RuntimeException: An error occured while executing doInBackground()
01-28 15:32:14.167: E/AndroidRuntime(31174):    at android.os.AsyncTask$3.done(AsyncTask.java:299)
01-28 15:32:14.167: E/AndroidRuntime(31174):    at java.util.concurrent.FutureTask.finishCompletion(FutureTask.java:352)
01-28 15:32:14.167: E/AndroidRuntime(31174):    at java.util.concurrent.FutureTask.setException(FutureTask.java:219)
01-28 15:32:14.167: E/AndroidRuntime(31174):    at java.util.concurrent.FutureTask.run(FutureTask.java:239)
01-28 15:32:14.167: E/AndroidRuntime(31174):    at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:230)
01-28 15:32:14.167: E/AndroidRuntime(31174):    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1080)
01-28 15:32:14.167: E/AndroidRuntime(31174):    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:573)
01-28 15:32:14.167: E/AndroidRuntime(31174):    at java.lang.Thread.run(Thread.java:856)
01-28 15:32:14.167: E/AndroidRuntime(31174): Caused by: java.lang.StackOverflowError
01-28 15:32:14.167: E/AndroidRuntime(31174):    at com.google.gson.internal.$Gson$Types.resolve($Gson$Types.java:371)
01-28 15:32:14.167: E/AndroidRuntime(31174):    at com.google.gson.internal.$Gson$Types.resolve($Gson$Types.java:375)
01-28 15:32:14.167: E/AndroidRuntime(31174):    at com.google.gson.internal.$Gson$Types.resolve($Gson$Types.java:380)
01-28 …

我编写了一个天真的测试平台来测量三种阶乘实现的性能:基于循环,非尾递归和尾递归.

令我惊讶的是,最差的性能是循环的(«while»预计效率更高,所以我提供了两者) ,其成本几乎是尾部递归替代的两倍.

答案:修复循环实现,避免使用BigInt的*=运算符,因为其内部«循环»变得如预期的那样快

我遇到的另一个"woodoo"行为是StackOverflow异常,在非尾递归实现的情况下,对于相同的输入没有抛出异常.我可以通过逐步调用具有越来越大的值的函数来规避StackOverlow ...我感到很疯狂:) 答案:JVM需要在启动期间收敛,然后行为是连贯的和系统的

这是代码:

final object Factorial {
  type Out = BigInt

  def calculateByRecursion(n: Int): Out = {
    require(n>0, "n must be positive")

    n match {
      case _ if n == 1 => return 1
      case _ => return n * calculateByRecursion(n-1)
    }
  }

  def calculateByForLoop(n: Int): Out = {
    require(n>0, "n must be positive")

    var accumulator: Out = 1
    for (i <- 1 to n)
      accumulator = i * accumulator
    accumulator
  }

  def calculateByWhileLoop(n: …

我的问题是,当我使用递归时,我通常会得到一个java.lang.StackOverflowError.我的问题是 - 为什么递归导致stackoverflow比循环更多,并且是否有任何使用递归来避免堆栈溢出的好方法？

这是一个解决问题107的尝试,它适用于他们的示例,但是为了自身的问题耗尽了堆栈空间.

//-1 16 12 21 -1 -1 -1 16 -1 -1 17 20 -1 -1 12 -1 -1 28 -1 31 -1 21 17 28 -1 18 19 23 -1 20 -1 18 -1 -1 11 -1 -1 31 19 -1 -1 27 -1 -1 -1 23 11 27 -1
public class tries
{
    public static int n=7,min=Integer.MAX_VALUE;
    public static boolean[][] wasHere=new boolean[n][60000];
    public static void main(String[] args)
    {
        int[] lines=new int[n]; Arrays.fill(lines, -1000); lines[0]=0; …

问题

当我尝试在自身中嵌套复合组件时,使用一些逻辑来结束无限递归,我收到堆栈溢出异常.我的理解是<c:xxx>标签在视图构建时运行,所以我不希望有无限的视图构建,因为我认为是这样的.

这是复合组件 simpleNestable.xhtml

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
  xmlns:composite="http://java.sun.com/jsf/composite"
  xmlns:h="http://java.sun.com/jsf/html"
  xmlns:em="http://xmlns.jcp.org/jsf/composite/emcomp"

  xmlns:c="http://xmlns.jcp.org/jsp/jstl/core">

    <h:head>
        <title>This content will not be displayed</title>
    </h:head>
    <h:body>
        <composite:interface>
            <composite:attribute name="depth" required="true" type="java.lang.Integer"/>
        </composite:interface>

        <composite:implementation>
            <c:if test="#{cc.attrs.depth lt 3}">
                 #{cc.attrs.depth}
                 #{cc.attrs.depth+1}
                 <em:simpleNestable depth="#{cc.attrs.depth+1}" /> 

            </c:if>

        </composite:implementation>
    </h:body>
</html>

这就是它的用法

<h:head>
    <title>Facelet Title</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <h:outputStylesheet name="./css/default.css"/>
    <h:outputStylesheet name="./css/cssLayout.css"/>
</h:head>
<h:body>        
     <emcomp:simpleNestable depth="1"/>

</h:body>

堆栈溢出异常

java.lang.StackOverflowError
    at com.sun.faces.facelets.el.TagValueExpression.getValue(TagValueExpression.java:109)
    at javax.faces.component.UIComponentBase$AttributesMap.get(UIComponentBase.java:2407)
    at com.sun.faces.el.CompositeComponentAttributesELResolver$ExpressionEvalMap.get(CompositeComponentAttributesELResolver.java:393)
    at javax.el.MapELResolver.getValue(MapELResolver.java:199)
    at com.sun.faces.el.DemuxCompositeELResolver._getValue(DemuxCompositeELResolver.java:176) …

我正在尝试使用glmnet包构建模型,但是当我运行以下行时出现以下错误:

#library('glmnet')
x = model.matrix(response ~ ., data = acgh_frame[,c(3:ncol(acgh_frame))])

Error: protect(): protection stack overflow

我知道这是由于我在数据帧中有大量变量(26​​k +).当我使用较少的变量时,错误不会显示.我知道如何在命令行R中解决这个问题,但我需要留在R studio中,所以我想从R Studio修复它.那么,我该怎么做？