Domanda

Quindi stavo giocando con alcuni esperimenti di pensiero in cui ho immaginato cosa sarebbe successo quando due funzioni sono diventate reciprocamente ricorsive. Uno di questi era cosa se entrambe le funzioni potessero potenzialmente cadere in un ciclo infinito.

A tal fine, ho pensato a questo semplice esempio:

#include <iostream>
#include <cstdlib>

int foo(int x);
int bar(int x);


int foo(int x)
{
    return bar(x + 1);
}

int bar(int x)
{
    return foo(x - 1);
}

int main(int argc, char **argv)
{
    if (argc > 1)
        std::cout << "The value is: " << foo(atoi(argv[1])) << std::endl;

    return 0;
}

È interessante notare che questo in realtà stamperà assolutamente nulla se lo compili con G ++. Compilalo con qualsiasi interruttore -o e cade in un ciclo infinito.

Pensieri? Questo è potenzialmente un bug del compilatore o è prevedibile? Penserei che nel caso di -o ottimizzazioni, si renderebbe conto che Foo (x) e bar (x) ritornano solo x.

Non mi aspettavo che "ottimizza in realtà la chiamata e ignorasse completamente la stampa" Il valore è "per l'input standard.

Modifica: ho compilato questo come solo G ++ Source.cpp (-O1/2/3), sotto Cygwin usando GCC 4.5.0. Le versioni -ox in realtà si aggirano infinitamente senza traboccare lo stack.

Nessuna soluzione corretta

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top