Version imprimable
Bonjour à tous,
Une question qui me turlupine bien que j'en ai pas vraiment besoin mais que, dans l'absolu, j'aurais du mettre en place.
Comment faire pour gérer une fonction récursive avec un nombre de paramètre indéfini ?
Je m'explique :
Tu vois ?Code:
2
3
4
Faut-il obligatoirement passer par la compilation dynamique ?
Bonjour,
Windev sait gérer les paramètres variables pour des cas simples. Après dans une fonction récursive je n'ai jamais testé.
Extrait de la doc :
Cette uniquement fonction permettra de supprimer par exemple les sauts de lignes et tabulation d'une chaine :Code:
2
3
4
5
6
7
8
SupprimeCaractère(ChaineANettoyer, RC, TAB)
De supprimer des caractères spéciaux :
SupprimeCaractère(ChaineANettoyer, Caract(13), Caract(10) ...)
Donc a testé dans des conditions plus complexe en espérant que PCSOFT à fait ce qu'il faut de ce côté ;)
Merci pour ta réponse.
Voici la fonction dans laquelle j'ai besoin de ça :
J'utilise cette fonction dans pour les états sur formulaire pré-imprimé... relativement statique donc je réduit la taille des typos si nécessaire.Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
J'aimerais pouvoir gérer plus de 2 champs.
Par exemple je fais ça pour les champs "monoligne" :
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Pour la récursivité faisons une procédure de calcul de factorielleCitation:
Envoyé par michel.souris
On testeCode:
2
3
4
ça affiche 5040 ce qui est bien la factorielle de 7, donc la récursivité ça marche (C'est limité en profondeur, jusqu'à 20 c'est bon, à 21 c'est abérrant)Code:
2
3
Maintenant ce que tu veux faire : une fonction récursive avec un nombre de paramètre indéfini
Ça devient bougrement tordu, donc c'est intéressant...
On va rester sur des calculs factoriels pour la récursivité mais pour corser la chose on va faire la somme des factorielles d'un nombre indéfini de paramètre :aie: ça commence à piquer les yeux... :cry:
Ce qui donne
On testeCode:
2
3
4
5
6
7
8
9
10
11
12
13
ça affiche 5160 et 45480 c'est tout bon :ccool::ccool::ccool:Code:
2
3
4
CQFD (Ce que fait Denise...)
Alors déjà chapeau car ta démonstration est très intelligible ce qui n'est pas évident avec ce genre de problème.
Si j'avais pu mettre 2 pouces (ou 3) en l'air je l'aurais fait !
Sinon ça ne répond pas entièrement à ma question... et oui je suis vraiment tordu ! je veux que le nombre de paramètre balancer à ma fonction lors de l'appel récursif soit variable... et en le repensant (grâce en partie à ta démo) je crois que je ne peux pas faire autrement que par compilation dynamique.....
A moins que le mot clé MesParamètres désigne un ensemble de variable qu'on peut exploiter mais je ne crois pas... je vais tester !
Dans votre cas, vous pouvez très bien contourner ce pb en créant un tableau ou une chaine avec séparateur contenant les paramètres.
Et donc de ne pas passer les paramètres mais le tableau de paramètres à la fonction.
Ca devrait répondre à vos attentes.Code:
2
3
4
5
6
7
8
9
Si tu regardes bien dans la PROCEDURE nFactorielleAddition(xNum,*)Citation:
Envoyé par michel.souris
Prenons le cas ou on fait la somme des factorielle de 3 nombres
Lors du 1er appel nFactorielleAddition() 3 paramètres sont passés
Après quand on est sur le 1er paramètre tous les appels récursifs de nFactorielleAddition() se font avec 1 seul paramètre (calcul de la factorielle du paramètre en cours).
Jusqu'à ce qu'on passe au paramètre suivant ainsi de suite...
On est bien dans un cas où le nombre de paramètre balancer à la fonction lors de l'appel récursif est variable...
Ceci dit je pense que l'exemple s'y prête facilement puisque faire la somme d'une factorielle ou de plusieurs ça reste une somme...
Au début j'avais juste vu ton besoin de passer un nombre variable de paramètre (pas la récursivité) et j'avais pensé comme Ry_Yo que tu pouvais contourner en passant un tableau ou un tableau de structure en paramètre. Puis d'utiliser les indirections pour récupérer les valeurs. Exactement ce que te propose Ry_Yo...
Bon déjà merci à vous deux de participer à cette réflexion...
Laurent je me suis peut être mal exprimé je voulais dire que lors de tous mes appel récursif le nombre de paramètres soient variables. Ceci étant ce que tu expliques fonctionne bien pour une addition entre les paramètres, une soustraction ou autre opérateur mathématique ! (du moins d'intuition il me semble :mouarf:)
La solution de Ry_Yo répond au besoin mais, et c'est subjectif, je la trouve pas très élégante à l'appel (ouais je suis bien casse couille)... disons que l'obligation de déclarer un tableau et de le remplir me plait pas... mais c'est un bon contournement, je le garde sous le coude !
[LECTURE OPTIONNELLE]
Si vous prenez le temps de lire mon code (j'avoue que moi aussi ça me casse les couilles de lire le code des autres, surtout sorti du contexte) il s'agit de gérer dans un état le fait que la chaine dépasse du champs sans le redimensionner...
L'idée est de basculer (autant que faire se peut) les infos dans n champs et au besoin de diminuer la police des n champs et de retenter la "bascule" d'où le besoin de récursivité.
Je dois donc passer en paramètre n champs... franchement le problème est bateau, c'est même pas pour envoyer des fusées sur la lune.... donc je comprends qu'on puisse se dire que je me prends la tête pour rien.
donc voilà si quelqu'un a une idée d'un autre moyen de faire ça (avec un appel élégant si possible), je veux bien lui piquer !
[/LECTURE OPTIONNELLE]
Je vais faire un test : compilation dynamique VS et je vous dirais... :zoubi:
PS : pas eu le temps de tester MesParamètres comme étant un ensemble de variable et j'y crois pas trop... ceci dit on y accède comme au élément d'un tableau... peut-être que c'est juste la coloration syntaxique qui change :aie:
Question tordue ça, j'aime bien les questions tordues ^^
Pas sur de bien avoir compris la demande, mais je vais répondre en fonction de ce que j'ai compris en espérant ne pas être trop à coté de la plaque.
Question : Peut t'on appeler une fonction récursive avec un nombre différents de paramètres lors de la récursivité.
qui donneCode:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Donc je dirais, toujours si j'ai bien compris, oui.Code:
2
3
4
5
6
P.S.: Le code est vraiment moche, mais le but de ce code étais juste de démontrer.
[edit]Tout compte fait, j'ai peut être rien compris, en relisant le thread, d'autres ont déjà répondu à l'identique :/ Ça m'apprendra à lire un peu mieux les sujets la prochaine fois.
Donc la subtilité, c'est que tu voudrais construire la liste des paramètres à passer par code ?
La solution à Ry_Yo me semble convenir. Si l'a manière d’appeler la fonction te "dérange", tu peux toujours créer une première fonction qui prend un nombre de paramètres variables, cette première fonction n'ayant pour but que de remettre en forme la liste variable des paramètres sous forme de chaîne avec séparateur. Cette première fonction appelant la deuxième qui effectuera le traitement.
Concernant la récursivité dans ton cas, je ne suis pas sûr que cela soit nécessaire, tu peux très bien faire une boucle qui englobe le traitement et qui prévoit une condition de sortie de boucle quand tu as obtenu le résultat voulu.
Eric, tu as raison ça n'est pas franchement nécessaire... j'aurais pu me démerder avec un booléen et while....
Ce qui va faire 3 choses à tester : le tableau, la compilation dynamique et le while...
Il n'en restera qu'un !
PS : je me doute déjà que ma solution de compilation dynamique est la pire en terme de perf....
Voici une lecture qui "fait une journée" si on traduit l'expression anglophone consacrée.
Je penche aussi pour la solution Ry_Yo.
La raison : Il manque un petit quelque chose dans l'énoncé, c'est le rôle des paramètres de la récursive... Dans le cadre de la factorielle de Laurent, tous les paramètres ont le même rôle. Dans ce cas, le premier paramètre n'a pas le même rôle que les suivants. Je pense donc plus à une boucle sur le traitement des paramètres suivants dans laquelle on 'rognera' un buffer sur la chaine initiale. la récursive n'est alors sans doute pas obligatoire.
L'idée est d'avoir la chaine source et le champ1 obligatoires. Les champs2...n seraient paramétrables. on pourra alorsboucler sur 2...n à partir du contenu restant dans le buffer qui est la copie de la chaine source que l'on va consommer.
Pour le faire dans une autre fonction cette fois récursive, il faudrait définir le cas de base pour les paramètres champs 1...n. la récursive devrait alors sauter aux yeux.
Sinon la boucle avec consommation du buffer me semble jouable.
(j'ai pas le temps pour du code mais je marque la discussion !)
Merci encore pour votre participation à tous, c'est plus qu'intéressant d'avoir votre avis !
Bon j'avoue mon cas ne justifie pas entièrement l'utilisation de la récursivité mais bon c'est ce qui m'est venu naturellement... donc je m'entête ! j'ai fais avec un while c'est vrai, ça marche aussi et c'est surement plus naturel pour la plupart des gens....
Par contre j'ai une grande nouvelle ! le mot clé MesParamètres désigne l'ensembles des valeurs et peut être "rebalancer" en paramètres ! c'est génial, ça peut servir dans différents contextes... la récursivité bien sûr mais aussi l'appel d'une fonction avec un nombre de paramètre dépendant du nombre de paramètre transmis à la fonction qui l'appelle (héhéhéhé)
Donc voilà la réponse : le mot clé MesParamètres...
Ça, personnellement je le savais, mais la question initiale n'étais pas là ^^Citation:
Envoyé par michel.souris
La question étais, toujours si j'ai bien compris : est-il possible d'appeler de manière récursive une fonction en changeant le nombre de paramètres entre chaque appel et cela en construisant la liste des paramètres par code.
Cette question ne peut être résolu, à ma connaissance, par MesParamètres, vu que l'on ne peut modifier cette structure et ajouter des paramètres à la volée, on peut juste la propager.
Quitte à vouloir, à tout prix, avoir la possibilité d'effectuer un appel récursif avec des paramètres modifiés entre chaque appel, j'aurais tendance à passer un seul paramètres contenant une structure personalisé. Une liste de chaine comme proposé par Ry_Yo ou un tableau (tableau d'objets par exemple) ou un xmlDocument (qui pourrait décrire l'ensemble des paramètres ainsi que leurs types)
Mais le fait de pouvoir propager MesParamètres est très utile, par exemple dans le cas de la surcharge d'une fonction de Windev.
Exemple :
Code:
2
3
4
5
6
désolé si je me suis mal exprimé l'objectif n'était pas de modifier le nombre de paramètre à l'appel mais de pouvoir rappeler la fonction de façon récursive avec les mêmes paramètres.
Bref j'ai ma réponse !
Je posterais les résultats des tests dès que je peux les faire... juste comme ça mais je pense pas que l'utilisation de la récursivité puisse être plus performant qu'un while...
De là l'importance à recadrer les réponses rapidement quand tu constate que les personnes n'ont pas cerner la demande ;)Citation:
Envoyé par michel.souris
Par principe, l'utilisation de la récursivité est à "bannir" quand on peut avoir une solution procédurale.
L'appel d'un fonction est coûteux en temps, empilement des paramètres, renvoi par la pile du résultat de la fonction.
De plus, le nombre d'appel récursif est toujours limité par la taille de la pile. Et sous Windev, cette limite, n'est même pas modifiable, 20 appels récursif il me semble.
En effet lors de mes tests, 20 appels récursifs ça marche, 21 ça ne marche plus...Citation:
Envoyé par DelphiManiac
On n'a pas ce problème dans une boucle...
Bon je passe ce thread en résolu.
Franchement c'est cool, vous avez bien tripper avec moi sur un problème qui n'en était pas un dans mon contexte. Vous m'avez proposé des solutions pertinentes. On a plein de solution pour nos éventuels futurs problèmes du coup.
J'ai vraiment bien aimé que vous participiez merci à tous.
Même si tout ça finira dans un WHILE s'il fallait recommencer je le ferais.
bisous et +1 pour tout le monde !
PS : au boulot j'ai pas le temps de faire le VS pis on sait tous plus ou moins le résultat :
n°1 WHILE
n°2 Récursivité avec tableau de paramètres ou passage de MesParamètres
n°3 Compilation dynamique (mon idée à la con)