Comment parsingr un code source récursif manuellement?

Par exemple, j’ai mis au point une technique d’parsing manuelle du code source itératif, comme suit:

int fact(int n) { int f = 0; int i = 0; if (n<=1) { return 1; } f = 1; i = 2; for (i=2; i<=n ; i++) { f *= i; } return f; } --------------------------- if new-f --------------------------- --------------------------- ---------------------------

Pour chaque ‘i’, je peux parsingr et calculer manuellement les valeurs de old-f et new-f et remplir le tableau pour voir si la routine fonctionne correctement.

Mais comment puis-je parsingr les routines récursives à la main?

 int fact(int number) { int temp; if(number <= 1) return 1; temp = number * fact(number - 1); return temp; }

Comme la récursivité stocke des valeurs sur la stack, vous devez l’parsingr dans les deux sens.

La première passe est: faites la récursivité jusqu’à ce que la condition de terminaison soit atteinte.

2ème passage: collecte les valeurs jusqu’à ce que la stack soit vide.

 1st down 2nd up --------------------------------- n = 6 tmp = 6 * 120 = 720 <- result n = 5 tmp = 5 * 24 = 120 n = 4 tmp = 4 * 6 = 24 n = 3 tmp = 3 * 2 = 6 n = 2 tmp = 2 * 1 = 2 n = 1 end

Vous pouvez utiliser un débogueur pour cela sans changer les codes d’origine ni en écrire de nouveaux. 1. Définissez un point d’arrêt à l’adresse de la fonction nommée fait 2. Exécutez le débogueur. Chaque fois que vous vous êtes arrêté au point d’arrêt, vous pouvez extraire la valeur du numéro de paramètre et la valeur renvoyée.

Lorsqu’il s’agit de fonctions récursives, la manière d’exprimer efficacement ce que la fonction est en train de faire est de la considérer comme une fonction mathématique et de simplifier l’application de la fonction. Bien que cela ne vous dise pas vraiment l’état interne de la fonction (dans ce cas, la valeur de temp ), cela vous donne un très bon moyen de décrire la fonction.

Par exemple factoriel, nous pouvons définir un fait comme étant:

 fact(x) = 1 when x <= 1 fact(x) = x * fact(x - 1) otherwise

Maintenant, quand vous voulez exprimer son fonctionnement, vous choisissez un petit nombre de départ (disons 6) et ...

 fact(6) = 6 * fact(5) = 6 * 5 * fact(4) = 6 * 5 * 4 * fact(3)

etc.

De cette façon, vous parsingz la structure de la fonction plutôt que sa mise en œuvre. Cela n’est pas très utile pour le débogage (du moins dans un langage non fonctionnel). Mais c'est merveilleux pour les commentaires, la documentation et la communication.