Surcharge de Fonctions

[Fraid]

Bonjour,

 

Dans certains langages, comme le C ou le Java, nous pouvons avoir des méthodes (un peux comparables à nos fonctions) ayant le même nom mais pas le même nombres et/ou types d'arguments. (Polymorphisme)

 

En Autolisp, j'ai beau chercher, je ne vois pas d'utilisation concrète de ce concept.

Pourtant c'est possible. Exemple avec une fonction bien connue str2lst qui transforme une suite de texte séparé par un séparateur en liste.

 

(defun str2lst (str sep / pos);ici nous ne connaissons pas le séparateur d'avance
 (if (setq pos (vl-string-search sep str))
   (cons (substr str 1 pos)
         (str2lst (substr str (+ (strlen sep) pos 1)) sep)
   )
   (list str)
 )
)
(defun strtolst (str / pos sep);ici nous connaissons le séparateur d'avance
 (setq sep ";")
 (if (setq pos (vl-string-search sep str))
   (cons (substr str 1 pos)
         (strtolst (substr str (+ (strlen sep) pos 1)) sep)
   )
   (list str)
 )
)
(defun str2list (arg / pos sep str);ici les 2 sont possible
 (if (= (type arg) liste)(setq sep (cadr arg) str (car arg))(setq sep ";" str arg))
 (if (setq pos (vl-string-search sep str))
   (cons (substr str 1 pos)
         (str2lst (substr str (+ (strlen sep) pos 1)) sep)
   )
   (list str)
 )
)

 

Est ce une aberration?

[Fraid]

J'ai oublier de préciser qu'en lisp evidement on ne peut pas avoir le meme nom.

[(gile)]

Salut,

 

On ne peut pas en LISP écrire de (defun ...) surchargé, mais nombre de fonction LISP natives (probablement implémentée en C) sont surchargées avec des arguments optionnels ou en nombre indéterminé.

La solution de contournement est souvent d'avoir une liste comme argument (qui contient les "vrais" arguments). Mais ça demande de tester le contenu de la liste.

[(gile)]

Ta dernière fonction ne marche pas (même si tu renommes str2lst en str2list).

Comme tu utilises une fonction récursive les arguments des appels récursifs doivent être identiques aux argument de la fonction, et ça t'oblige à faire le test de l'argument et de le reconstruire en liste à chaque appel récursif.

Pour qu'elle fonctionne il faudrait l'écrire comme ça:

 

(defun str2list (arg / pos sep str);ici les 2 sont possible
 (if (= (type arg) 'LIST)
   (setq sep (cdr arg)
         str (car arg)
   )
   (setq sep ";"
         str arg
   )
 )
 (if (setq pos (vl-string-search sep str))
   (cons (substr str 1 pos)
         (str2list (cons (substr str (+ (strlen sep) pos 1)) sep))
   )
   (list str)
 )
)

 

En général, dans ce genre de cas, on utilise une fonction récursive auxiliaire ce qui permet de définir les arguments dans la fonction principale.

 

(defun str2list (arg / aux)
 (defun aux (str sep / pos)
   (if (setq pos (vl-string-search sep str))
     (cons (substr str 1 pos)
           (aux (substr str (+ (strlen sep) pos 1)) sep)
     )
     (list str)
   )
 )
 (if (listp arg)
   (aux (car arg) (cadr arg))
   (aux arg ";")
 )
)

[Fraid]

Oups, pas pris bon exemple (ou plutôt si du coup), pas fait attention quelle était récursive, autant pour moi.

 

Et terrible le coup de la fonction auxiliaire pour les récursives.

 

Cela faisait un petit moment que je voulais poser la question, mais je n'osais pas..

Comme quoi il n'y a jamais de questions bêtes.

 

En tout cas j'avais bien vu que de passer une liste en argument était une façon de "polymorphiser" une fonction. Cela va me permettre d'en réduire le nombre dans mon fatras.

[(gile)]

En tout cas j'avais bien vu que de passer une liste en argument était une façon de "polymorphiser" une fonction. Cela va me permettre d'en réduire le nombre dans mon fatras.

 

Personnellement je ne suis pas trop favorable à ça en LISP, les surcharges de méthode avec des langages fortement et statiquement typés c'est robuste et ça n'a pas de coût, avec un langage faiblement et dynamiquement typé comme le LISP, je trouve l'artifice de la liste en argument un peu lourdingue et moins fiable.

[Fraid]

C'est claire que je vais utiliser cela au compte goûte.

 

C'est pour des petites fonctions de mise à la charte, et j'en ai pas tant que cela qui s'y prête.

Après, avec nos PC de maintenant, on ne vois pas trop la différence.

 

Le fait que les variables et les fonctions (arguments et retours) ne soient pas typés d'avance en Lisp, je trouve cela plutôt pratique, mais demande plus de rigueur et de contrôle.

[VDH-Bruno]

On ne peut pas en LISP écrire de (defun ...) surchargé, mais nombre de fonction LISP natives (probablement implémentée en C) sont surchargées avec des arguments optionnels ou en nombre indéterminé.

La solution de contournement est souvent d'avoir une liste comme argument (qui contient les "vrais" arguments). Mais ça demande de tester le contenu de la liste.

 

 

Bonjour

 

Juste pour compléter, ce qui vient d'être dit est vraie pour le lisp embarqué dans AutoCAD et ses clones, mais dans la plus part des langages de la famille lisp: Clisp, Le_lisp etc... On peut surcharger en lisp ses propres fonctions lisp avec des arguments optionnels ou en nombre indéterminé. ;)

 

A+ Bruno

[DenisHen]

Personnellement je ne suis pas trop favorable à ça en LISP, les surcharges de méthode avec des langages fortement et statiquement typés c'est robuste et ça n'a pas de coût, avec un langage faiblement et dynamiquement typé comme le LISP, je trouve l'artifice de la liste en argument un peu lourdingue et moins fiable.

J'avoue ne pas avoir tout compris... N'est-ce pas le but de "ste2lst" et "lst2str" ?

 

Ou alors mon niveau est plus bas que je ne pensais... Qui n'est déjà pas très haut... ;)

 

Bon week-end...

 

Denis...

[(gile)]

J'avoue ne pas avoir tout compris... N'est-ce pas le but de "ste2lst" et "lst2str" ?

 

Ou alors mon niveau est plus bas que je ne pensais... Qui n'est déjà pas très haut... ;)

 

Bon week-end...

 

Denis...

 

Ce qu'on appelle "surcharge de fonction" (ou surcharge de méthode) dans d'autres environnements, c'est la possibilité de définir plusieurs fonctions (méthodes) de même nom mais avec des arguments différents en type ou en nombre (ou des types de retour différents).

 

Par exemple, la fonction AutoLISP atan est dite "surchargée" parce qu'elle accepter soit un seul argument ; soit deux argument.

 

Sachant que la tangente d'un angle est égale au sinus de l'angle divisé par le cosinus de l'angle.

(atan -1) retourne -0.785398 (tangente de 135° ou de 315°)

(atan -1 1) retourne -0.785398 (tangente de 315°)

(atan 1 -1) retourne 2.35619 (tangente de 135°)

[DenisHen]

Salut (gile), et merci de m'éclaircir sur ce point...

 

Mais (atan en lisp, c'est la tangente, et non, l'arc tangente ?

 

Donc, une fonction "surchargée" est une fonction qui peut recevoir un ou plusieurs arguments...

 

Alors ça et vos chalenges sur la récursivité (merci aussi à Patrick_35)... Je suis descendu au niveaux -12 dans ma "novicité"... :(

 

Merci... <_<

 

Maintenant, je vais déprimer pendant le week-end... ;)

[(gile)]

Oui, atan renvoie l'arc tangent, autrement dit l'angle dont la tangente est égale à -1 (135° ou 315°) qu'on peut aussi exprimer comme l'angle dont le sinus est -0.707 et le cosinus 0.707 (soit 315°) ou comme l'angle dont le sinus est 0.707 et le cosinus -0.707 (soit 135°).

Plus généralement, la surcharge de la fonction atan qui ne prend qu'un argument ne permet renvoie toujours le résultat entre -90° et 90° (zone des cosinus positifs) alors que la surcharge qui prend 2 arguments permet de déterminer précisément le quadrant de l'angle.

 

Concernant la surcharge de méthode, tu peux voir ici.

[DenisHen]

Concernant la surcharge de méthode, tu peux voir ici.

Ok, j'ai décroché... Désolé... Ce n'est pas de mon piètre niveau..