Question de récursion simple

Question

Disons que nous avons une récursion simple comme.

int x(int a){ 
    if(a<10) 
    x(a+1); 
    else 
     !STOP! 
    b++; 
return b; 
} 

globaly:

int b=0; 

En principal, nous pourrions avoir quelque chose comme ceci:

int p=x(1); 

Est-il possible d'arrêter la récursion afin que le p sera de 0, ce moyen que "b ++" ne sera jamais exécuté.

Je vous serais reconnaissant si vous pouviez me dire une expression à mettre au lieu de la! STOP! Mais, je ne veux rien de pareil, je veux juste arrêter la récursion, comme casser; fait dans un moment() boucle ...:

int ok=0; 
    int x(int a){ 
     if(a<10) 
     x(a+1); 
     else 
      ok=1; 
     if(ok==0) 
     b++; 
    return b; 
    } 

S'il n'y a pas quelque chose de flou à propos de la question, il suffit de demander.

Answer 1

Pourquoi ne pas le faire?

int x(int a){ 
    if(a<10) { 
     x(a+1); 
     b++; 
    } 
    return b; 
} 

La chose est, cependant, vous modifiez une approche globale dans une routine récursive, ce qui est particulièrement threadsafe et assez bâclée. Vous renvoyez une valeur toujours ignorée sauf par l'appelant de niveau supérieur. Vous faites aussi quelque chose qui vaut mieux être fait en boucle (mais je suppose que votre cas réel est plus grand que celui-ci, ou vous êtes un étudiant).

Vous ne pouvez pas vraiment "casser" la récursion - retournant assez se déroule assez bien. En C oldey-timey vous pouvez utiliser setjmp/longjmp (et tous ses périls - en d'autres termes, NE PAS), et en C++, vous pouvez utiliser try/catch/throw, qui va également dérouler la pile.

Answer 2

Que diriez-vous de pareil?

int x(int a){ 
    if(a>0 && a<10) 
    x(a+1); 
    b++; 
    return b; 
} 

Answer 3

Que diriez-vous de revenir?

int x(int a){ 
    if(a<10) 
    x(a+1); 
    else 
     return b; 
    b++; 
return b; 
} 

Je pense que cela ressemble un peu mieux

int x(int a){ 
    if(a<10) 
    x(a+1); 
    else 
     return b; 

    return ++b; 
} 

EDIT:

Je pense que vous pouvez utiliser le mécanisme d'exception pour se détendre la pile et arriver au point de la première invocation, mais c'est sûr après avoir entré main(). Référençant b dans x, étant donné le code:

int b = 0; 
int p = x(1); 

suggère que x est utilisé pour l'initialisation d'une variable globale et peut être exécuté avant main(). Que diriez-vous d'utiliser une fonction d'aide qui entoure l'invocation de x dans un bloc try-catch et qui lance une exception à la place de | STOP |?

Answer 4

La seule chose en C++ qui va dérouler la pile comme ça est une exception. Il y a aussi setjmp()/longjmp(), mais ceux-ci ne devraient jamais être utilisés dans un programme C++. Toute autre construction peut tout au plus revenir de la fonction en cours.

Answer 5

Si vous essayez de déclarer b dans main(), et d'utiliser b dans x() alors il y a quelque chose de mal pour commencer. Au lieu de cela, rendez b dans une variable locale en le passant en paramètre à x et en renvoyant une version modifiée de b.

int x(int a, int b){ 
    if(a<10) 
     return x(a+1,b+1); 
    else 
     return b; 
} 

Answer 6

Je ne suis pas un grand fan de l'utilisation d'une exception pour le contrôle. Je ne m'attends pas à ce que vous sauviez plusieurs cycles en utilisant des exceptions au lieu des instructions if/return. Vous allez devoir tester vos conditions aux limites avant de lancer une exception.

Vous pouvez cependant simplifier un peu le problème en modifiant le type de retour de la fonction.

bool x(int a){ 
    if(ok) //Exit early before next call up? 
    return true; 
    if(a<10){ 
    if(x(a+1)) //Have we been told to exit early? 
     return true; //Yes 
    b++; //Do some work 
    if(ok) //Exit early in the next call down? 
     return true; 
    } 
    return false; //Normal Exit 
}