Fonction récursive VB.net

[invite08778547]

Bonjour , j'aimerai que vous m'aidiez à la compréhension du "comportement" d'une Fonction récursive .

Module Module1
    Dim V As Boolean = False

    Sub Main()


        gg(0)
        Console.Read()

    End Sub
    Private Sub gg(ByVal tu As Int16)



        While Not V

            If tu = 10 Then
                V = True
            Else
                tu += 1

                Console.WriteLine(tu)

                gg(tu)

                Console.WriteLine(tu)

            End If

        End While




    End Sub
End Module

Pour commencer je tiens à dire que ce code sert juste d'exemple au problème , pour éviter tous messages inutile du styles "Que la récursivité n'est pas nécessaire pour ce code " tout ça tout ça ,et de bien vouloir exécuter le programme pas-à-pas avant de répondre

Ce que je ne comprends pas , c'est pourquoi la Fonction "gg" fait une sorte de marche arrière tout en mettant les anciennes valeurs du (ou des paramètres) paramètre "tu" jusqu’à à arriver à la valeur initial pour ensuite se terminer. Parce-que d’après ce que j'ai appris normalement la fonction devrait ce terminer, hors là , la fonction ne se termine pas tout de suite pour pouvoir décrémenter le paramètre "tu" et se terminer.

merci
-----

[Ikhar84]

Salut.
J'ai pas compris grand chose à la question, est celle là :
La variable tu initialisée à 0, affichée est incrementée jusqu'à 10 puis décrementée jusqu'à 0 avant de quitter la boucle ?
Est bien la question ?

Je ne vois pas ce qui pose problème? À part que nulle part tu n'est décrementée, mais semble l'être car tu n'utilise pas le retour de la fonction récursive, mais qu'après son appel c'est la valeur courante de tu, donc celle d'avant l'appel recursif, et la nouvelle incrémentation...
Comme entre les deux affichages successifs, il y a la recursivité et donc de nouveaux affichages avec des valeurs successivement incrementé, on a l'impression de compter, puis de décompter quand la récursivité est terminée et que l'on reprend les fils d'execution avant chaque appel récursif.

Je ne sais si j'ai été clair, mais il n'y a pas mieux que "déplier" les appels pour comprendre... si c'était cela la question...


Attention, tes avertissements risquent de décourager d'autres intervenants...

Pour commencer je tiens à dire que ce code sert juste d'exemple au problème , pour éviter tous messages inutile du styles "Que la récursivité n'est pas nécessaire pour ce code " tout ça tout ça ,et de bien vouloir exécuter le programme pas-à-pas avant de répondre

Note: ce serait plus amusant de faire appel à la fonction avec 11 (ou plus) comme valeur de paramètre

[invite08778547]

Salut,

La variable tu initialisée à 0, affichée est incrementée jusqu'à 10

oui ça c'est "moi" qui incrémente avec "+= 1"

puis décrementée jusqu'à 0 avant de quitter la boucle ?

oui c'est justement ça je ne comprends pas, enfin plutôt pourquoi c'est la fonction qui effectue cette manœuvre
parce-que une fois arriver à 10 comment la fonction "gg" se "souvient" des valeurs anciennes ?

il y a la recursivité et donc de nouveaux affichages avec des valeurs successivement incrementé, on a l'impression de compter, puis de décompter quand la récursivité est terminée et que l'on reprend les fils d'execution avant chaque appel récursif.

Donc pour toi c'est normal que la fonction fait un retour en arrière avec les différentes valeurs passé(anciennes), pour pouvoir exécuter ce qui n'a pas été exécuter ?
comme j'ai posé la question plus haut , dans ce cas comment le Sub peut se souvenir des anciennes valeurs ?

[Tryss2]

Le plus simple, c'est encore de dérouler "Pas-à-pas" l’exécution du programme.

Je change la valeur max de tu à 3 (au lieu de 10) pour ne pas que ce soit trop long :

Private Sub gg(ByVal tu As Int16)
        While Not V
            If tu = 3 Then
                V = True
            Else
                tu += 1
                Console.WriteLine(tu)
                gg(tu)
                Console.WriteLine(tu)
            End If
        End While

La fonction gg ne se rappelle pas des anciennes valeurs.

Quand on appelle gg(3), la fonction retourne sans rien faire

Quand on appelle gg(2), la fonction affiche 3, appelle gg(3), puis affiche de nouveau 3

Quand on appelle gg(1), la fonction affiche 2, appelle gg(2), affiche 2, affiche 3, appelle gg(3) puis affiche de nouveau 3

Quand on appelle gg(0), la fonction affiche 1, appelle gg(1), affiche 1, affiche 2, appelle gg(2), affiche 2, affiche 3, appelle gg(3) puis affiche de nouveau 3


Le code va donc faire les appels de fonctions suivants :

gg(0)
   Affiche 1
   gg(1)
      Affiche 2
      gg(2)
          Affiche 3
          gg(3)
             --
          Affiche 3
      Affiche 2
      Affiche 3
      gg(3)
          --
      Affiche 3
   Affiche 1
   Affiche 2
   gg(2)
       Affiche 3
       gg(3)
          --
       Affiche 3
   Affiche 2
   Affiche 3
   gg(3)
       --
   Affiche 3

Les nombres qui vont s'afficher seront donc, dans l'ordre 1,2,3,3,2,3,3,1,2,3,3,2,3,3

[A voir en vidéo sur Futura]

[invite08778547]

Quand on appelle gg(0), la fonction affiche 1, appelle gg(1), affiche 1, affiche 2, appelle gg(2), affiche 2, affiche 3, appelle gg(3) puis affiche de nouveau 3

Je comprends votre raisonnement , vous vous pensez que les instructions se poursuit après l'appel de la fonction dans elle-même

Sauf que pour moi ça ne se passe pas comme ça...

comme je l'ai mentionné à ma question, exécutez bien le code pour que vous puissiez bien voir de quoi je parle

voici ce que le code produit pour moi

[Ikhar84]

Je ne vois vraiment pas ce qui bloque.
Pour moi c'est vraiment le résultat attendu, avec l'exemple de 3:

    'Avec un max de 3 et un premier appel de gg(-1):
    Affiche(0)
    gg(1)
          Affiche(1)
          gg(2)
                Affiche(2)
                     gg(3)
                      Affiche(3)
                     Retour
                Affiche(2)
          Affiche(1)
    Affiche(0)

0
1
2
3
2
1
0

[Ikhar84]

Désolé pour le double post, mais gg(3) ne fait que "remonter" la chaine des appels, il n'affiche rien effectivement...

Note: il faudrait vraiment augmenter au moins légerement le délai d'édition des posts... afin d'éviter de dire des bêtises... d'autant que j'ai appuyé involontairement sur le bouton "envoyer le message" (smartphone)... le boulet...

Edit: d'ailleurs on n'a nul part l'affichage d'un 0 non plus, désolé...

[invite08778547]

mais gg(3) ne fait que "remonter" la chaine des appels

c'est justement ça que ne je ne sais pas .
pourquoi une sous-procédure (Sub) remonte les appels , c'est une fonctionnalité des fonction (Sub) ?

Edit: d'ailleurs on n'a nul part l'affichage d'un 0 non plus, désolé...

Tqt j'avais compris d'ailleurs 3 ne s'affiche pas qu'une seul fois mais deux

[Ikhar84]

Je ne sais pas quel niveau de détail tu veux pour l'expliquation, mais le dépliage de l'execution me semble bien clair non ?

On parle de "fil d'execution" quand on execute de façon séquentielle les instructions les unes à la suite des autres.

Mais l'appel à une fonction, procédure, méthode (etc...) n'est pas une simple instruction mais fait appel à des mecanismes complexes:
- Le fil d'execution courant est sauvegardé et mis en pause, avec toutes ses variables (on parle de contexte mémoire par exemple);
- les instructions de la fonction appelée prennent la place du fil d'execution courant, et deviennent donc le nouveau fil d'execution courant
- la fonction appelée se termine (d'une façon ou d'une autre);
- on revient dans la fonction principale qui avait été sauvegardée, et qui redevient le fil d'execution courant, jusqu'à ce que elle même se termine et rend la main à celle qui l'a appelé.

Bien sûr j'utilise le terme "fil d'execution" de façon schematique pour bien montrer la continuité de l'execution des instructions de façon séquentielle.

Si tu veux plus d'info, il faur rechercher du côté des piles et notamment les contextes d'execution, en C ou C++ en programmation système.
.Net est un peu particulier car s'executant à travers un framework sur une machine virtuelle, le principe est le même mais les infos rares, car pas dédiés à la prog système...

Edit:
Dans ton prochain post, essaies vraiment de "déplier" l'execution de ton code, tu verras que ce sera plus clair...

[invite08778547]

-Le fil d'execution courant est sauvegardé et mis en pause, avec toutes ses variables
- Le fil d'execution courant est sauvegardé et mis en pause, avec toutes ses variables (on parle de contexte mémoire par exemple);
- les instructions de la fonction appelée prennent la place du fil d'execution courant, et deviennent donc le nouveau fil d'execution courant
- la fonction appelée se termine (d'une façon ou d'une autre);
- on revient dans la fonction principale qui avait été sauvegardée, et qui redevient le fil d'execution courant, jusqu'à ce que elle même se termine et rend la main à celle qui l'a appelé.

Donc quand t'on fais appel de la fonction dans elle-même une sauvegarde est faite et ce pour chaque appel qu'on peux faire, pour qu'on puisse ensuite remonter les appels avec les "anciens" paramètres et pouvoir exécuter les instructions qui n'ont pas pu ce faire lors d'un appel ? mais la sauvegarde elle est gardée ou ?

Dans ton prochain post, essaies vraiment de "déplier" l'execution de ton code, tu verras que ce sera plus clair...

tu parles d’exécuter pas-à-pas ? si oui, je l'ai déjà fait et c'est pour ça que je pose la question parce-que j'ai vu nulle-part une explication sur ça, et sans explication j'avais compris le pourquoi mais pas le comment

[bisou10]

Le résultat c'est qu'on va faire 1 -> 10 et 10 -> 1, à cause du double Console.Writeline avant puis apres gg().

Comprendre: on ne "termine" pas la fonction a chaque appel de gg(x).
C'est à dire que chaque appel à gg() dans le While va repartir au debut de ta fonction. Arrivé à V=true, le dernier appel se termine normalement, et tous les appels se terminent en cascade.

Techniquement il y a sauvegarde du contexte dans le heap ou la pile, comme tout appel de fonction.

Et en VB.net ce sont des méthodes, orienté objet oblige.

[Ikhar84]

Je crois que je viens de comprendre ton trouble à la lumière de l'intervention de bisou10...

À chaque appel de gg() on ne relance pas la même fonction à son début mais on en execute une nouvelle "instance" totalement indépendante...
C'est comme si on executait une toute nouvelle fonction (fonction au sens large)...

Ensuite c'est la magie de la pile qui opère...

[invite08778547]

Ok merci je vois plus clair maintenant

ce que j’arriver pas à comprendre c'était comment la fonction faisait pour remonter les appels pour faire le reste (en l’occurrence le deuxième affichage) , j'avais pas pensé à la Pile ...

PS: y'a t'il un statut pour dire que le sujet est résolu ?

[invite08778547]

À chaque appel de gg() on ne relance pas la même fonction à son début mais on en execute une nouvelle "instance" totalement indépendante...
C'est comme si on executait une toute nouvelle fonction (fonction au sens large)...

Tout est plus clair maintenant

merci à vous

[bisou10]

Mais quelle pile ? la fonction ne "remonte" pas, elle continue son execution de manière logique: on parle simplement de terminer une fonction, (ou une sub, car tu as l'air de penser que c'est radicalement différent) (pour info Sub - Subroutine - veut dire "sous programme").

La pile ce n'est pas un truc que tu manipules, c'est automagique.

[invite08778547]

Je me suis peut-être mal exprimer, mais effectivement oui , c'est ce que je voulais dire

Sinon à t'il un statut pour dire que c'est résolu ?

[pm42]

Sinon à t'il un statut pour dire que c'est résolu ?

Non. On arrête de répondre et c'est tout. Ce qui fait que parfois, quelqu'un déterre une discussion qui a 10 ans et la reprend.

[Ikhar84]

Comme le dit pm42, on laisse le fil s'enfoncer dans les profondeurs du forum, jusqu'à ce que, en 2026, quelqu'un le deterre par un hors sujet et qu'un modo le ferme...