Puede dar un ejemplo de desbordamiento de pila en C++? Otros que el caso recursivo:

void foo() { foo(); }
  • Usted me quiere implementar el conjunto de stackoverflow sitio web en C++ en mi respuesta? Wow… 🙂
  • @dicroce:lol +1 🙂
  • ¿Por qué no recursividad infinita una respuesta aceptable?
  • debido a que es un caso trivial
  • Por qué no es un caso trivial de una respuesta aceptable?
  • El de arriba no se rebase en un decente compilador. Sin pila, no hay ninguna operación, ni nada de nada.

12 Comentarios

  1. 17

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

    int foo()
    {
        int array[1000000];
    
    }
  2. 7
    void function()
    {
     function();
    }
    • +1 limpio y sencillo. Esto es TODO que usted necesita para hacer estallar la pila.
    • Podemos hacer que sea más corto? Sí, se puede! void _(){_();} … es casi como Perl 😉
    • La diferencia es que, en el Perl de la tierra, es más probable que usted va a soplar su de la pila antes de Perl hace.
    • Dado que esta función no tiene argumentos, declara nada, y no devuelve nada, me pregunto si un smart optimizador de simple podría convertir esto en un bucle infinito, en cuyo caso, no sería el golpe de la pila…
  3. 5

    Aquí está uno que podría suceder en la práctica:

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

    Se desborda la pila para el negativo x. Y, como Frank Krueger mencionado, también para demasiado grande x (pero entonces int desbordaría primera).

  4. 3

    Tratando de mantener la devolución de principal hasta que la pila se agote?

    int main(int argc, char **argv)
    {
        return main(argc, argv);
    }
    • No es legal llamada main() en C++.
    • Sé que no se formatea correctamente, pero no hay advertencias con -Wall incluso para esto más adecuado programa: <code>int main(int argc, char **argv) { if (argc == 0){return 0;} else {std::cout << argc << std::endl; return principal(0, argv);} } </código de>
    • Me refiero a que es raro que g++ no da advertencias cuando llame principal; usted es de hecho correcta (por lo que he visto) que la norma no permite llamar a main.
    • Rushakoff: g++ dará un error si se compila con la -pedantic bandera, aunque en mi caso, me da un poco de error incorrecto de ISO C++ forbids taking address of function '::main'
  5. 3

    Como por edición 🙂

    void ping()
    {
      pong();
    }
    
    void pong()
    {
    ping();
    }

    También, yo creo que se puede obtener de desbordamiento de pila si intenta asignar más espacio de rosca máxima tamaño de la pila ( 1 MB por defecto en VS), algo así como int a[100000]; debe prever la excepción.

    • llame a ellos y ping pong lol bueno
    • sí, con un gracioso nombre!
  6. 3

    Tiempo de compilación ejemplo:

    template <int N>
    struct Factorial {
        enum { value = N * Factorial<N - 1>::value };
    };
    
    //...
    {
        int overflow = Factorial<10>::value;
    }
  7. 2

    No puedo creer que nos dejó el más grande ejemplo de recursividad 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

    Por desgracia, OS X informes de un «segmentation fault» en lugar de «desbordamiento de Pila». Demasiado malo.

  8. 1

    Este ejemplo muestra descontrolado de la recursividad. Finalmente, la pila espaciados asignado para este proceso será reemplazada por completo por las instancias de bar y ret…

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

    Si quieres generar un explícitamente no-recursiva programa a resultado en un desbordamiento de pila por el de las llamadas de función:

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

    Ejemplo de salida:

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

    El ejemplo de uso:

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

    Al menos en mi sistema, la pila de llamadas parece ser 174602, así que usted necesitará para establecer el argumento recursion.py a ser más que eso; y se tarda un par de minutos para compilar y enlazar el programa.

  10. 0

    También se puede obtener de un desbordamiento de la pila si se intenta colocar objetos grandes en la pila (por valor).

Dejar respuesta

Please enter your comment!
Please enter your name here