¿Puedes dar un ejemplo de desbordamiento de pila en C++?

Question

¿Puedes dar un ejemplo de desbordamiento de pila en C++? Aparte del caso recursivo:

void foo() { foo(); } 

Answer 1

El caso típico que no implica recursión infinita es declarar una variable automática en la pila que es demasiado grande. Por ejemplo:

int foo() 
{ 
    int array[1000000]; 

} 

Answer 2

Consulte Stack overflow - Wikipedia. Me he vinculado directamente a la sección de ejemplos.

Answer 3

void function() 
{ 
function(); 
} 

Answer 4

Este ejemplo muestra recursión no controlada. Con el tiempo, la pila espaciadas asignado a este proceso será completamente sobrescritos por los casos de bar y ret ...

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

Answer 5

seguir tratando de regresar principal hasta que la pila se agote?

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

Answer 6

recursividad infinita:

 
void infiniteFunction() 
{ 
    infiniteFunction(); 
} 

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

Answer 7

Aquí hay uno que podría ocurrir en la práctica:

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

Esto desborda la pila para el negativo x. Y, as Frank Krueger mentioned, también para demasiado grande x (pero luego se desbordará primero int).

Answer 8

Según editar :-)

void ping() 
{ 
    pong(); 
} 

void pong() 
{ 
ping(); 
} 

Además, creo que se puede obtener de desbordamiento de pila si se intenta asignar más espacio que el tamaño máximo de pila de subprocesos (1 MB por defecto en VS), así que algo como int a[100000]; debe proporcionar la excepción.

Answer 9

No puedo creer que hayamos dejado el mayor ejemplo de recursión de todos los tiempos, 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)); 
} 

En OS X 10.5.8 con 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 

Desafortunadamente, OS X informa de un "Fallo de segmentación" en lugar de un "desbordamiento de pila". Demasiado.

Answer 10

También podría obtener un desbordamiento de la pila si intenta colocar objetos grandes en la pila (valor por defecto).

Answer 11

Si desea generar un programa explícitamente no recursivo para dar lugar a un desbordamiento de pila de llamadas de función: la salida

#!/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; }" 

muestra:

$ 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; } 

Ejemplo de uso:

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

Al menos en mi sistema, la pila de llamadas eems es 174602, por lo que deberá establecer el argumento en recursion.py para que sea mayor que eso; y lleva unos minutos compilar y vincular el programa. ejemplo

Answer 12

tiempo de compilación:

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

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