标签: stack-overflow

问题实际上是关于C中的堆栈溢出.我有一个不能完成我的生活的分配,我已经查看了gdb中的所有内容,我只是无法想象它.

问题如下:

int i,n;

void confused()
{
    printf("who called me");
    exit(0);
}

void shell_call(char *c)
{
    printf(" ***Now calling \"%s\" shell command *** \n",c);
    system(c);
    exit(0);
}

void victim_func()
{
    int a[4];
    printf("[8]:%x\n", &a[8]);
    printf("Enter n: "); scanf("%d",&n);
    printf("Enter %d HEX Values \n",n);
    for(i=0;i<n;i++) scanf("%x",&a[i]);
    printf("Done reading junk numbers\n");
}

int main()
{
    printf("ls=736c --- ps = 7370 --- cal = 6c6163\n");
    printf("location of confused %x \n", confused);
    printf("location of shell_call %x \n", shell_call);
    victim_func();
    printf("Done, thank you\n");

}

好的,所以我设法正确地得到了第一个问题,即任意调用主路径中未明确调用的两个函数之一.顺便说一下,这必须在运行程序时完成而不做任何修改.我这样做是通过运行程序,设置 …

我的MySQL看起来像这样:(表的名称是类别)

'id', 'content', 'parent'

哪里:

• id =类别的ID
• content = some-text-we-dont-care-about
• parent =父类别的ID

这就是我现在正在尝试的:

function remrecurs($id) {
    $qlist=mysql_query("SELECT * FROM category WHERE parent='$id'");
    if (mysql_num_rows($qlist)>0) {
         while($curitem=mysql_fetch_array($qlist)) {
              remrecurs($curitem['parent']);
         }
    }
    mysql_query("DELETE FROM category WHERE id='$id'");
}

由于某种原因,它不起作用和崩溃..任何想法我做错了什么？

我有一个递归函数,BaseClass它依赖于protected virtual函数的返回条件.

子类可能会错误地覆盖此函数并导致StackOverFlow异常.最糟糕的是网络呼叫速度很慢,而且不会很快发生异常(许多资源浪费很长时间).

我正在寻找StackOverFlow一种在基类中以某种方式检查早期阶段的方法(可能使用Reflection和当前的递归级别).

任何的想法 ？

我已经用Fortran 90.一直致力于精美的相当长一段时间写了一个相当大的程序,但今天我上前一步了一个档次,增加问题大小(它是一家集科研非标准FE-求解,如果帮助任何人...)现在我得到"堆栈溢出"错误消息,自然程序终止,而没有给我任何有用的工作.

该程序首先设置所有相关的数组和矩阵,然后完成后,它会将一些关于此的统计信息打印到日志文件中.即使我有一个新的,更大的问题,这个工作正常(尽管有点慢),但随着"数字运算"开始失败.

让我感到困惑的是,那一点上的所有东西都已经分配了(而且没有错误).我不完全确定堆栈是什么(维基百科和这里的几个步骤没有做太多,因为我对计算机的"幕后"工作只有非常基本的知识).

假设我有一些数组初始化为:

INTEGER,DIMENSION(64) :: IA
REAL(8),DIMENSION(:,:),ALLOCATABLE :: AA, BB

在一些初始化例程(即从文件读取输入等)之后被分配为(我存储一些大小整数以便更容易地传递到固定大小的IA中的子例程):

ALLOCATE( AA(N1,N2) , BB(N1,N2) )
IA(1) = N1
IA(2) = N2

这基本上是在初始部分发生的事情,到目前为止一直很好.但是当我接下来调用子程序时

CALL ROUTINE_ONE(AA,BB,IA)

例程看起来像(没什么特别的):

SUBROUTINE ROUTINE_ONE(AA,BB,IA)
IMPLICIT NONE
INTEGER,DIMENSION(64) :: IA
REAL(8),DIMENSION(IA(1),IA(2)) :: AA, BB
...
do lots of other stuff
...
END SUBROUTINE ROUTINE_ONE

现在我收到一个错误!屏幕输出显示:

forrtl: severe (170): Program Exception - stack overflow

然而,当我与调试器中运行该程序它一个名为处断裂线419 winsig.c(不是我的文件,但可能是编译器的一部分？).它似乎是一个sigreterror:被调用的例程的一部分,它是已被调用的默认情况,返回文本Invalid signal or error.这附有评论专栏,奇怪地说/* should never happen, but compiler can't tell */......？

所以我想我的问题是,为什么会发生这种情况以及实际发生了什么？我认为只要我可以分配所有相关的内存我应该没问题？对子程序的调用是否会复制参数,或只是指向它们的指针？如果答案是副本,那么我可以看到问题可能在哪里,如果是这样的话:关于如何绕过它的任何想法？

我试图解决的问题很大,但不以任何方式疯狂.标准的FE解算器可以处理比我现在更大的问题.我在Dell …

请在下面的代码中查看我的评论.我应该如何检查参数null？它看起来像null被转换为Foo基本上使递归调用==操作符.为什么会这样？

public class Foo
{
    public static bool operator ==(Foo f1, Foo f2)
    {
        if (f1 == null) //This throw a StackOverflowException
            return f2 == null;
        if (f2 == null)
            return f1 == null;
        else
            return f1.Equals((object)f2);
    }

    public static bool operator !=(Foo f1, Foo f2)
    {
        return !(f1 == f2);
    }

    public override bool Equals(object obj)
    {
        Foo f = obj as Foo;
        if (f == (Foo)null)
            return false;

        return false; …

为什么这个？这是我的代码:

public class KPage
{
    public KPage()
    {
       this.Titolo = "example";
    }

    public string Titolo
    {
        get { return Titolo; }
        set { Titolo = value; }
    }
}

我通过构造函数设置数据.所以,我想做些喜欢的事情

KPage page = new KPage();
Response.Write(page.Titolo);

但是我得到了这个错误:

set { Titolo = value; }

现代编译器GCC非常强大,甚至可以防止编译阶段的缓冲区溢出,因此OS无法在堆栈空间上运行代码.

例如:

void function(char *str) 
{
   char buffer[16];

   strncpy(buffer, str, 256);
}

void main() 
{
  char large_string[256];
  int i;

  for( i = 0; i < 256; i++)
    large_string[i] = 'A';

  function(large_string);
}

我可以获得神奇的0x41414141的唯一方法是设置GCC编译参数,如:

gcc -fno-stack-protector -z execstack stackoverflow.c -o stackoverflow

(我在ubuntu 10.04 x86清晰32位盒子上测试过它)

有什么方法可以绕过GCC堆栈粉碎保护吗？

我正在编写一个文档,打算在C#项目中显示代码更改,我正在寻找一个好的格式来显示代码片段.

我喜欢StackOverflow网站在其问题和答案(滚动条和背景颜色)中显示代码片段的方式.

任何人都可以指导我创建类似的背景/视图来显示word文档中的代码片段(主要是滚动条).

我尝试从StackOverflow复制并粘贴它,但背景不会出现.

我搜索并发现这个有用的链接,但它没有改变背景颜色,也没有滚动条如何在MS Word保留格式和语法高亮显示代码片段？

请考虑以下代码(仅用于演示目的):

#include <iostream>

int main()
{
    char pixels[4][1280][720]; // Big enough to cause a stack overflow on my machine
    for (unsigned int i = 0; i < 4; i++)
    {
        for (unsigned int j = 0; j < 1280; j++)
        {
            for (unsigned int k = 0; k < 720; k++)
            {
                pixels[i][j][k] = i + j + k;
            }
        }
    }

    std::cout << pixels[2][640][360];
    return 0;
}

根据这个问题的答案,最大堆栈大小由visual studio设置.

假设它可以警告用户潜在的堆栈溢出,我是否正确？(我自己尝试了这个并没有得到警告)

PS:我问的唯一原因是因为我看到很多关于SO的问题可以通过这样的警告来防止(是的,我知道不是每个SO用户都使用VS).

我正在使用rxjava1开发一个项目,我有一个Observable链,偶尔会包含数千个可合并或连接在一起的observable.当发生这种情况时,将发生StackOverflow异常,我们将得到如下内容:

java.lang.StackOverflowError
    at java.util.HashMap.putVal(HashMap.java:631)
    at java.util.HashMap.put(HashMap.java:612)
    at rx.internal.operators.OnSubscribeToMap$ToMapSubscriber.onNext(OnSubscribeToMap.java:127)
    at rx.internal.operators.OnSubscribeFilter$FilterSubscriber.onNext(OnSubscribeFilter.java:76)
    at rx.internal.operators.OperatorMerge$MergeSubscriber.emitScalar(OperatorMerge.java:395)
    at rx.internal.operators.OperatorMerge$MergeSubscriber.tryEmit(OperatorMerge.java:355)
    at rx.internal.operators.OperatorMerge$InnerSubscriber.onNext(OperatorMerge.java:846)
    at rx.internal.operators.OperatorMerge$MergeSubscriber.emitScalar(OperatorMerge.java:395)
    at rx.internal.operators.OperatorMerge$MergeSubscriber.tryEmit(OperatorMerge.java:355)
    at rx.internal.operators.OperatorMerge$InnerSubscriber.onNext(OperatorMerge.java:846)
    at rx.internal.operators.OperatorMerge$MergeSubscriber.emitScalar(OperatorMerge.java:395)
    at rx.internal.operators.OperatorMerge$MergeSubscriber.tryEmit(OperatorMerge.java:355)
    at rx.internal.operators.OperatorMerge$InnerSubscriber.onNext(OperatorMerge.java:846)
    at rx.internal.operators.OperatorMerge$MergeSubscriber.emitScalar(OperatorMerge.java:395)
    at rx.internal.operators.OperatorMerge$MergeSubscriber.tryEmit(OperatorMerge.java:355)
    at rx.internal.operators.OperatorMerge$InnerSubscriber.onNext(OperatorMerge.java:846)
    at rx.internal.operators.OperatorMerge$MergeSubscriber.emitScalar(OperatorMerge.java:395)
    at rx.internal.operators.OperatorMerge$MergeSubscriber.tryEmit(OperatorMerge.java:355)

堆栈跟踪将持续数百行.我见过的唯一相关帖子是github中的这个问题:https://github.com/ReactiveX/RxJava/issues/3035.但是建议的将可观察量添加到列表中的解决方案是我们使用过的并且不起作用的.

我该怎么做才能防止这些StackOverflow异常？我需要做某种节流或背压吗？

以下是当前代码的示例以及导致stackoverflows的示例:

public Observable<Map<String, JsonObject>> extractTopLevelSummariesFromForms(JsonArray summaries, Func2<String, String, Observable<JsonObject>> summaryGatherer) {
    List<Observable<JsonObject>> summaryObservables = new LinkedList<>();
    summaries.stream()
             .map(JsonUtil::safeJsonObject)
             .filter(summary -> StringUtils.isNotEmpty(summary.getString(NAME))|| StringUtils.isNotEmpty(summary.getString(Form.TITLE)))
             .forEach(summary -> {
                 if (StringUtils.isNotEmpty(summary.getString(TEXT)))
                     summaryObservables.add(gatherSummariesFromElement(summary.getString(Summary.SHORT_NAME), Summary.SummaryValues.FORM,
                                                                       summary.getString(Summary.SHORT_NAME) + ".hidden",
                                                                       summary.getString(VALUE), summaryGatherer));
                 if (StringUtils.isNotEmpty(summary.getString(Form.TEXT))) …