标签: 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");

}

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

我的电脑有2GB的RAM内存.当我在C#2008 Express Edition中形成具有70.000个项目的数组的3D网格对象时,我收到错误消息"Stack Overflow exception handling ...".如果我将RAM内存从2GB升级到4 GB,我可以克服此错误消息吗？

在嵌入式软件中,如何以通用方式处理堆栈溢出？我遇到了一些处理器,它像硬件一样保护最近的AMD处理器.维基百科上有一些技术,但那些是真正实用的方法吗？

任何人都可以提供一个明确的建议方法,适用于当今的32位嵌入式处理器吗？

我有两个简单的C++程序和两个问题.我在CentOS 5.2工作,我的开发环境如下:

• g ++(GCC)4.1.2 20080704(Red Hat 4.1.2-50)
• "ulimit -s"输出:10240(千字节),即10MB

计划#1:

main.cpp中:

int main(int argc, char * argv[])
{
    char buf[1024*1024*11] = {0};
    return 0;
}

(用"g ++ -g main.cpp"编译)

程序在堆栈上分配1024*1024*11字节(即11MB),但不会崩溃.将分配大小更改为1024*1024*12(即12MB)后,程序崩溃.我认为这应该是由堆栈溢出引起的. 但是为什么程序在分配大小为11MB时不会崩溃,这也大于10MB的上限？

计划#2:

main.cpp中:

#include <iostream>

int main(int argc, char * argv[])
{
    char buf[1024*1024*11] = {0};

    std::cout << "*** separation ***" << std::endl;

    char buf2[1024*1024] = {0};

    return 0;
}

(用"g ++ -g main.cpp"编译)

该程序将导致程序崩溃,因为它在堆栈上分配12MB字节.但是,根据核心转储文件(见下文),崩溃发生在buf但不是buf2. 不应该崩溃发生在buf2上,因为我们从程序#1知道char buf [1024*1024*11]的分配是正常的,因此在我们分配另一个1024*1024字节后,堆栈会溢出吗？

我认为必须有一些非常基本的概念,我没有建立一个坚实的理解.但是他们是什么？

附录:程序#2生成的核心转储信息:

Core was generated by `./a.out'.
Program terminated with signal …

例如,可以捕获SIGABRT并以longjump继续程序.

当我总是调用调用abort()的函数时,我想知道这是否会导致堆栈溢出.

我需要知道,因为我想在单元测试中使用assert宏(taht调用abort).如果断言失败,我想继续下一个单元测试.

继上一个问题:ECMAScript Regex的多行字符串,我实现了以下加载过程:

void Load( const std::string& szFileName )
{
     static const std::regex regexObject( "=== ([^=]+) ===\\n((?:.|\\n)*)\\n=== END \\1 ===", std::regex_constants::ECMAScript | std::regex_constants::optimize );
     static const std::regex regexData( "<([^>]+)>:([^<]*)\\n", std::regex_constants::ECMAScript | std::regex_constants::optimize );

     std::ifstream inFile( szFileName );
     inFile.exceptions( std::ifstream::badbit );

     std::string szFileData( (std::istreambuf_iterator<char>(inFile)), (std::istreambuf_iterator<char>()) );

     inFile.close();

     std::vector<std::future<void>> vecFutures;

     for( std::sregex_iterator itObject( szFileData.cbegin(), szFileData.cend(), regexObject ), end; itObject != end; ++itObject )
     {
          if( (*itObject)[1] == "OBJECT1" )
          {
               vecFutures.emplace_back( std::async( []( std::string szDataString ) {
                    for( std::sregex_iterator itData( szDataString.cbegin(), …

我正在使用Don Stewart 的软件包System.Random.Mersenne.Pure64和Control.Monad.Mersenne.Random,它们通常非常快,并且应该有助于避免常见错误,例如使用非严格状态monad.

尽管如此,我设法编写了一些代码,这些代码会导致中等大小的向量堆栈溢出.

import qualified Data.Vector.Unboxed as U
import Data.Int
import System.Random.Mersenne.Pure64
import Control.Monad.Mersenne.Random

main = do
    let dim = 1000000
        y = evalRandom (U.replicateM dim getInt64) (pureMT 13) :: U.Vector Int64
    putStr $ (show $ U.head y)

我猜这一定是由于Vector的replicateM实现中的懒惰,虽然它很难看到,因为它是使用实现的streams.

我如何编写使用常量堆栈空间来采样大向量的代码？

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

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

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

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

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

据Oracle称,StackOverflowError是:

在发生堆栈溢出时抛出,因为应用程序过于严重.

我知道递归是什么,通常递归函数,如果没有正确终止,会导致StackOverflowError.为了检查StackOverflowError抛出之前发生的递归调用的数量,我写了这段代码:

package ErrorCases;

public class StackOverFlowError {
static int i=0;
void a()
{

    //System.out.println("called "+(++i));
    try{
        ++i;
    a();
    }catch(Error e)
    {
        System.out.println(e.getClass());
        System.out.println(i);
    }
}

public static void main(String[] args) {

       new StackOverFlowError().a();

   }

}

在JVM抛出StackOverflowError之前,i给出递归调用计数的值a().每次运行
的价值i都不同,如:

output 1: class java.lang.StackOverflowError
           10466
Output 2: class java.lang.StackOverflowError
           10470

我的疑问是？

1. 在JVM抛出之前递归有多深 StackOverflowError？

2. 一旦StackOverflowError投掷,我们可以恢复吗？

几年前在VS2010中编写了一个web服务项目,问题是所有代码完全相同(同样的PC,使用相同的代码对vs2010和2015进行测试),但在vs2015中,它在调试模式下出错.选项>"项目和解决方案"设置都相同.我接受了这个错误并定义了它;

System.Runtime.Serialization.dll中发生了未处理的"System.StackOverflowException"类型异常

System.StackOverflowException未处理消息:mscorlib.dll中发生未处理的类型'System.StackOverflowException'异常

任何人都有这个想法,我很高兴关注.我不能共享代码,因为它有近30,000行.