Can you give an example of stack overflow in C++?

Can you give an example of stack overflow in C++? Other than the re开发者_如何学编程cursive case:

void foo() { foo(); }

The typical case that does not involve infinite recursion is declaring an automatic variable on the stack that is too large. For example:

int foo()
{
    int array[1000000];

}

Please see Stack overflow - Wikipedia. I have linked directly to the examples section.

void function()
{
 function();
}

Here's one that might happen in practice:

int factorial(int x) {
  return x == 0 ? 1 : x * factorial(x-1);
}

This overflows the stack for negative x. And, as Frank Krueger mentioned, also for too large x (but then int would overflow first).

Keep trying to return main until the stack runs out?

int main(int argc, char **argv)
{
    return main(argc, argv);
}

As per edit :-)

void ping()
{
  pong();
}

void pong()
{
ping();
}

Also, I believe you can get stack overflow if you try to allocate more space than maximum thread stack size ( 1MB by default in VS), so something like int a[100000]; should provide the exception.

Compile-time example:

template <int N>
struct Factorial {
    enum { value = N * Factorial<N - 1>::value };
};

// ...
{
    int overflow = Factorial<10>::value;
}

I can't believe we left off the greatest recursion example of all time, factorial!

#include <stdio.h>

double fact(double n) {
    if (n <= 0) return 1;
    else return n * fact(n - 1);
}

int main() {
    printf("fact(5) = %g\n", fact(5));
    printf("fact(10) = %g\n", fact(10));
    printf("fact(100) = %g\n", fact(100));
    printf("fact(1000) = %g\n", fact(1000));
    printf("fact(1000000) = %g\n", fact(1000000));
}

On OS X 10.5.8 with GCC 4.0.1:

$ gcc f.c -o f && ./f
fact(5) = 120
fact(10) = 3.6288e+06
fact(100) = 9.33262e+157
fact(1000) = inf
Segmentation fault

Unfortunately, OS X reports a "Segmentation fault" instead of a "Stack overflow". Too bad.

This example shows uncontrolled recursion. Eventually, the stack spaced allocated to this process will be completely overwritten by instances of bar and ret...

int foo( int bar )
{
    int ret = foo( 42 );
    return ret;
}

If you want to generate an explicitly non-recursive program to result in a stack overflow by function calls:

#!/usr/bin/env python
import sys

print "void func" + sys.argv[1] + "() { }"
for i in xrange(int(sys.argv[1])-1, -1, -1):
    print "void func" + str(i) + "() { func" + str(i+1) + "(); }"
print "int main() { func0(); return 0; }"

Sample output:

$ python recursion.py 5
void func5() { }
void func4() { func5(); }
void func3() { func4(); }
void func2() { func3(); }
void func1() { func2(); }
void func0() { func1(); }
int main() { func0(); return 0; }

Sample usage:

$ python recursion.py 250000 | g++ -x c++ - && ./a.out

At least on my system, the call stack seems to be 174602, so you'll need to set the argument to recursion.py to be larger than that; and it takes a few minutes to compile and link the program.

Infinite recursion:

void infiniteFunction()
{
    infiniteFunction();
}

int main()
{
    infiniteFunction();
    return 0;
}

You could also get a stack overflow if you try to put large objects on the stack (by-value).