如果不使用递归如何堆栈溢出异常被抛出？(Without using recursion how ca

如果不使用递归如何堆栈溢出异常被抛出？

Answer 1:

如果调用足够的方法，随时可能发生堆栈溢出。尽管如此，如果你得到栈溢出错误，而无需使用递归，你可能要重新考虑你是如何做的事情。这只是很容易用递归，因为在一个无限循环，你叫一吨的方法。

Answer 2:

由于没有其他人提到它：

throw new System.StackOverflowException();

测试或做故障注入时，你可以这样做。

Answer 3:

声明一个巨大的数组作为局部变量。

Answer 4:

以下内容适用于Windows，但大多数操作系统实现这个以类似的方式。

简短的回答是：如果你摸的最后保护页，它会抛出。

当你的应用程序接触到纸堆的底部页面（C00000FD）型EXCEPTION_STACK_OVERFLOW的异常升高，即标志着一个PAGE_GUARD保护标志，并没有成长空间堆栈（提交一个多页），请参阅如何捕获堆溢出在Visual C ++应用程序。
当发生这种情况的典型的情况是，当堆栈已经发展许多功能的帧的堆栈上的结果（即失控递归的），因为较少的帧，但非常大的帧大小（功能具有非常大的局部范围的结果对象）或通过从堆栈与显式分配_alloca 。
另一个引起异常的方式就是故意触及保护页，如。提领指向到该页面的指针。这可以给一个变量initializion错误发生的原因。

堆栈溢出可如果输入导致了非常深刻的嵌套层次上的有效执行路径发生。比如看到当您运行包含大量的SQL Server中的IN或NOT里面的参数IN子句的查询出现堆栈溢出。

Answer 5:

还没有返回，每一个方法调用消耗一些堆栈空间。（更多局部变量的方法消耗更多的空间。）可能会导致堆栈溢出了非常深刻的调用堆栈。

注意在内存有限（如移动设备和）系统，你没有太多的堆栈空间，并迟早会用完。

Answer 6:

简短的回答：如果有一个调用内部对象的对象，则增加1堆栈跟踪所以，如果你有嵌套在彼此的对象1000，每个调用它的内部对象，最终你会得到一个堆栈溢出。

下面是如何产生使用嵌套迭代素数的演示：

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Program p = new Program();

            IEnumerator<int> primes = p.AllPrimes().GetEnumerator();
            int numberOfPrimes = 1000;
            for (int i = 0; i <= numberOfPrimes; i++)
            {
                primes.MoveNext();
                if (i % 1000 == 0)
                {
                    Console.WriteLine(primes.Current);
                }
            }
            Console.ReadKey(true);
        }

        IEnumerable<int> FilterDivisors(IEnumerator<int> seq, int num)
        {
            while (true)
            {
                int current = seq.Current;
                if (current % num != 0)
                {
                    yield return current;
                }
                seq.MoveNext();
            }
        }

        IEnumerable<int> AllIntegers()
        {
            int i = 2;
            while (true)
            {
                yield return i++;
            }
        }

        IEnumerable<int> AllPrimes()
        {
            IEnumerator<int> nums = AllIntegers().GetEnumerator();
            while (true)
            {
                nums.MoveNext();
                int prime = nums.Current;
                yield return prime;

                // nested iterator makes a big boom     
                nums = FilterDivisors(nums, prime).GetEnumerator();
            }
        }
    }
}

有没有递归，但该计划将15万左右的素数后抛出一个堆栈溢出异常。

Answer 7:

如果你在谈论C ++与合理的标准库，我的图像，这将工作：

while (true) {
    alloca(1024 * 1024); // arbitrary - 1M per iteration.
}

在详细ALLOCA 。

Answer 8:

int main()
{
  //something on the stack
  int foo = 0;
  for (
    //pointer to an address on the stack
    int* p = &foo;
    //forever
    ;
    //ever lower on the stack (assuming that the stack grows downwards)
    --p)
  {
    //write to the stack
    *p = 42;
  }
}

Answer 9:

做一个StackOverflowException最简单的方法如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            SomeClass instance = new SomeClass();
            string name = instance.Name;
        }
    }

    public class SomeClass
    {
        public string Name
        {
            get
            {
                return Name;
            }
        }
    }
}

文章来源: Without using recursion how can a stack overflow exception be thrown?