>> me serve de la récursivité....
>> nombre de branches ainsi que la profondeur variable de chacune ... je ne
>> vois pas comment autrement faire que de passer par la récursivité…. Il y
>> environnements ou j’ai fait du développement.
>>> Bonjour,
>>>
>>> Merci Greg..
>>> en mode itératif dans une même séquence je ne vois pas comment
>>> faire...peut être une procédure appelante qui met dans un tableau les
>>> répertoires courants, les balaye un par un en appelant une fonction avec
>>> comme paramètre le tableau courant passé en référence, l'indice à
>>> traiter du tableau courant passé en valeur qui traite les fichiers du
>>> répertoire indicé et qui ajoute dans le tableau passé en référence les
>>> nouveaux répertoires trouvés. Ce tableau à l'origine possède une
>>> dimension supplémentaire pour ne plus à avoir à traiter les répertoires
>>> déjà balayés..
>>>
>>> Maintenant, hormis le cas d'utilisation de Eddy qui jongle avec les
>>> objets de VFP, je ne vois pas dans une application le besoin de balayer
>>> des répertoires dont on ne connait pas d'avance ni le nom du dossier
>>> principal, ni la structure des noms de dossiers et fichiers..D'autant
>>> que je me doute qu'une telle opération doit être couteuse en temps
>>> machine..
>>>
>>> Je suis obtus et pragmatique, mais la récursivité couplée a vos
>>> explications au demeurant brillantes et compréhensibles, me semble
>>> rester un phénomène théorique (dans des applications ou VFP va donner
>>> pleinement sa mesure a savoir le traitement des données d'une base de
>>> données à des fins de gestions) et ne me laisse entrevoir aucune
>>> utilisation utile dans mes programmes..
>>>
>>> Amicalement
>>> G.L.S
>>> "Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de
>>> news:iagsmk$76c$1@news.niouzes.net...
>>>> Tiens, Gilles,
>>>>
>>>> Je te donne le code pour parcourir des repertoires de maniere
>>>> recursive. Il est assez simple
>>>>
>>>> Petit excersice : donne-moi le code pour le faire - et dans la meme
>>>> sequence - en mode iteratif ?
>>>>
>>>>
>>>> ?AdirRecursive('d:\tmp')
>>>>
>>>> function AdirRecursive(folder)
>>>>
>>>> local aa[1], i, n, mounted, filename
>>>>
>>>> n = adir(aa, addbs(m.folder) + '*.*', 'AHRDS', 1)
>>>> mounted = !( (m.n >= 2) and (aa[1,1]=='.') and (aa[2,1] == '..') )
>>>>
>>>> for i = iif(m.mounted, 1, 3) to m.n
>>>> filename = addbs(m.folder) + m.aa[m.i, 1]
>>>> ?m.filename
>>>> if( 'D' $ m.aa[m.i, 5] )
>>>> =AdirRecursive(m.filename)
>>>> endif
>>>> endfor
>>>>
>>>> endfunc
>>>>
>>>>
>>>>
>>>> Gregory
>>>> __
>>>> "G.L.S" wrote in message news:iagqhb$5qn$1@news.niouzes.net...
>>>>
>>>> Merci Greg..
>>>>
>>>> Donc je retiens hormis la brillante démonstration que cela ne sert pas
>>>> à
>>>> grand chose de pratique dans nos applications VFP sauf à améliorer
>>>> ponctuellement la lisibilité de quelques cas d'écritures..
>>>>
>>>> Amicalement
>>>> G.L.S.
>>>> "Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de
>>>> news:iagntr$3vj$1@news.niouzes.net...
>>>>> >surtout dans quelles situations concrètes sous VFP ou
>>>>> autres langages de dév. on est obligé de s'en servir..
>>>>>
>>>>>
>>>>> On n'est jamais obligé de s'en servir, mais cela a un avantage d'etre
>>>>> plus clair
>>>>>
>>>>> En vfp on est parfois limite du au niveau des 'DO' et dans ce cas il
>>>>> faut emploer une methode iterative
>>>>>
>>>>>
>>>>>
>>>>> Gregory
>>>>> __
>>>>> "G.L.S" wrote in message news:iagjgr$120$1@news.niouzes.net...
>>>>>
>>>>> Bonjour,
>>>>>
>>>>> Je rebondis sur les dires de Marc..
>>>>>
>>>>> Perso je ne sais pas ce que c'est que la récursivité (bien que le mot
>>>>> ne me
>>>>> soit pas étranger) et surtout dans quelles situations concrètes sous
>>>>> VFP ou
>>>>> autres langages de dév. on est obligé de s'en servir..
>>>>>
>>>>> Cordialement
>>>>> G.L.S
>>>>> "Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de
>>>>> news:iagieb$9b$1@news.niouzes.net...
>>>>>> >le vin aurait été banni au profit de
>>>>>> Oui, Marc, mais puisque je m'adressais a un Francais, je me disais
>>>>>> que le vin, il comprendrait mieux
>>>>>>
>>>>>>> J'espère bien de ta part un exposé sur la récursivité dans VFP ...
>>>>>> Qu'entends-tu par cela ? Quels points sont obscurs ?
>>>>>>
>>>>>> Gregory
>>>>>> __
>>>>>> "Marc Thivolle" wrote in message
>>>>>> news:iaf9o5$2fh5$1@news.niouzes.net...
>>>>>>
>>>>>> A part que je suis d'accord avec tes remarques techniques, je pensais
>>>>>> que
>>>>>> venant de ta part le vin aurait été banni au profit de le bière et du
>>>>>> whisky
>>>>>> (ce qu'on peut être méchant à 22h00 !).
>>>>>>
>>>>>> Tout cela en toute amitié.
>>>>>>
>>>>>> J'espère bien de ta part un exposé sur la récursivité dans VFP ...
>>>>>> car
>>>>>> j'avoue que certains comportements de notre langage préféré me
>>>>>> semblent bien
>>>>>> étranges.
>>>>>>
>>>>>> Marc de la Bastille
>>>>>>
>>>>>>
>>>>>> "Gregory Adam" a écrit dans le message de groupe de discussion :
>>>>>> iaedah$1rv7$1@news.niouzes.net...
>>>>>>
>>>>>> Luc,
>>>>>>
>>>>>> Les stack et les queue - c'est comme le vin - il faut apprendre a
>>>>>> apprecier
>>>>>>
>>>>>> Sans doute que ton code recursif peut etre converti en non-recursif -
>>>>>> avec
>>>>>> ou sans stack/queue
>>>>>>
>>>>>> Faudrait voir le code pour avoir une idee
>>>>>>
>>>>>> Mais - duplication du code - j'eviterais
>>>>>>
>>>>>>
>>>>>> Gregory
>>>>>> __
>>>>>> "luc Gilot" wrote in message news:iaebjt$1qp4$1@news.niouzes.net...
>>>>>>
>>>>>> Merci Grégory
>>>>>>
>>>>>> Bon, je connaissais bien stacks et queu, mais je ne voyais pas le
>>>>>> rapport.
>>>>>> Je ne le vois toujours pas d'ailleurs, mais j'ai fini par contourner
>>>>>> le
>>>>>> problème en créant une pseudo-récursivité à l'intérieur de la
>>>>>> fonction
>>>>>> récursive, par duplication du code (10 fois, ce qui me permet de
>>>>>> diviser par
>>>>>> 10 la profondeur des appels de fonctions). Ce n'est pas très élégant
>>>>>> mais ca
>>>>>> a l'air de fonctionner...
>>>>>>
>>>>>> Luc
>>>>>>
>>>>>> "Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de
>>>>>> news:
>>>>>> iae7n8$1nv8$1@news.niouzes.net...
>>>>>>> Stack/Queue = pile ou on peut sauver son contexte pour le recharger
>>>>>>> apres
>>>>>>>
>>>>>>> Stack = LIFO
http://en.wikipedia.org/wiki/Stack_(data_structure)
>>>>>>> Queue = FIFO
http://en.wikipedia.org/wiki/Queue_(data_structure)
>>>>>>>
>>>>>>> Stack: operations:
>>>>>>> - Push(xx)
>>>>>>> - Pop(@m.xx) or Pop()
>>>>>>>
>>>>>>> Queue: operations
>>>>>>> - Enqueue(item)
>>>>>>> - Dequeue(@m.item)
>>>>>>>
>>>>>>> Une implementation simple des deux
>>>>>>>
>>>>>>> local stackObj
>>>>>>>
>>>>>>> stackObj = createObject('Stack')
>>>>>>> ?m.stackObj.Push(1)
>>>>>>> ?m.stackObj.Push(2)
>>>>>>> ?m.stackObj.Push(3)
>>>>>>> ?m.stackObj.Push(4)
>>>>>>>
>>>>>>> local x
>>>>>>> ?m.stackObj.Pop(@m.x)
>>>>>>> ?x && 4
>>>>>>>
>>>>>>> ?m.stackObj.Pop(@m.x)
>>>>>>> ?x && 3
>>>>>>>
>>>>>>> ?m.stackObj.Pop(@m.x)
>>>>>>> ?x && 2
>>>>>>>
>>>>>>> ?m.stackObj.Pop(@m.x)
>>>>>>> ?x && 1
>>>>>>>
>>>>>>> meme excersice avec Queue
>>>>>>>
>>>>>>>
>>>>>>> local queueObj
>>>>>>> queueObj = createObject('Queue')
>>>>>>> ?m.queueObj.Enqueue(1)
>>>>>>> ?m.queueObj.Enqueue(2)
>>>>>>> ?m.queueObj.Enqueue(3)
>>>>>>> ?m.queueObj.Enqueue(4)
>>>>>>>
>>>>>>> ?m.queueObj.Dequeue(@m.x)
>>>>>>> ?x && 1
>>>>>>>
>>>>>>> ?m.queueObj.Dequeue(@m.x)
>>>>>>> ?x && 2
>>>>>>>
>>>>>>> ?m.queueObj.Dequeue(@m.x)
>>>>>>> ?x && 3
>>>>>>>
>>>>>>> ?m.queueObj.Dequeue(@m.x)
>>>>>>> ?x && 4
>>>>>>>
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>> define class Stack as CollectionBase
>>>>>>>
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> function Push(v)
>>>>>>> =m.this.Add(m.v)
>>>>>>> endfunc
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> function Pop(v)
>>>>>>>
>>>>>>> if( empty(m.this.Count) )
>>>>>>> return FALSE
>>>>>>> endif
>>>>>>> v = m.this.Item(m.this.Count)
>>>>>>> =m.this.Remove(m.this.Count)
>>>>>>>
>>>>>>> endfunc
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> function Peek(v)
>>>>>>>
>>>>>>> if( empty(m.this.Count) )
>>>>>>> return FALSE
>>>>>>> endif
>>>>>>> v = m.this.Item(m.this.Count)
>>>>>>>
>>>>>>> endfunc
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> enddefine
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>>
>>>>>>>
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>> define class Queue as CollectionBase
>>>>>>>
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> function EnQueue(v)
>>>>>>> =m.this.Add(m.v)
>>>>>>> endfunc
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> function DeQueue(v)
>>>>>>>
>>>>>>> if( empty(m.this.Count) )
>>>>>>> return FALSE
>>>>>>> endif
>>>>>>> v = m.this.Item(1)
>>>>>>> =m.this.Remove(1)
>>>>>>>
>>>>>>> endfunc
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> function Peek(v)
>>>>>>>
>>>>>>> if( empty(m.this.Count) )
>>>>>>> return FALSE
>>>>>>> endif
>>>>>>> v = m.this.Item(1)
>>>>>>>
>>>>>>> endfunc
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> enddefine
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>>
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>> define class CollectionBase as Collection
>>>>>>>
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> function Clear()
>>>>>>>
>>>>>>> =m.this.Remove(-1)
>>>>>>>
>>>>>>> endfunc
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> function Empty()
>>>>>>>
>>>>>>> return empty(m.this.Count)
>>>>>>>
>>>>>>> endfunc
>>>>>>> *-------------------------------------------------------------------------------
>>>>>>> enddefine
>>>>>>>
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>> *===============================================================================
>>>>>>>
>>>>>>> Gregory
>>>>>>> __
>>>>>>> "luc Gilot" wrote in message news:iae653$1mri$1@news.niouzes.net...
>>>>>>>
>>>>>>> Merci pour vos réponses.
>>>>>>>
>>>>>>> * Changer le nb de variables ne change rien (non plus que de
>>>>>>> diminuer la
>>>>>>> longueur de leurs noms ou de celui de la fonction récursive : il
>>>>>>> fallait
>>>>>>> quand même essayer...)
>>>>>>>
>>>>>>> * Grégory qu'est-ce qu'un stack ou queue ?
>>>>>>>
>>>>>>> Luc
>>>>>>>
>>>>>>> "luc Gilot" <luc.gilot@limoog.net> a écrit dans le message de news:
>>>>>>> iae0jb$1ivi$1@news.niouzes.net...
>>>>>>>> Bonjour
>>>>>>>>
>>>>>>>> Je dois écrire un programme très récursif (environ 2000 niveaux de
>>>>>>>> profondeur).
>>>>>>>> Un premier réglage de STACKSIZE = ... dans config.fpw m'a permis
>>>>>>>> d'éviter le message "Trop de DO imbriqués" à une profondeur de 119.
>>>>>>>> J'arrive maintenant à une profondeur de 437 avec un message "Espace
>>>>>>>> pile insiffisant"
>>>>>>>>
>>>>>>>> Comment augmenter la taille de la pile, ou faire en sorte qu'elle
>>>>>>>> se remplisse moins vite (à part en ne faisant plus de récursivité!)
>>>>>>>> ?
>>>>>>>>
>>>>>>>> Luc