CDDR

[dfbiagio]

Bonjour à tous,

j'ai un petit problème, avec la fonction cddr, je m'explique

je saisis un point 3d avec la fonction

 

--> (setq point (getpoint)) ------------ ex: (150.0 120.0 250.0)

 

si je fait (* (car point) 2) la réponse sera 300.0

 

si je fait (* (cadr point) 2) la réponse sera 240.0

 

par contre si je fait (* (cddr point) 2) la réponse est

 

; error: bad argument type: numberp: (250.0)

 

Je n'arrive pas à comprendre l'erreur. Est-ce que quelqu'un peut me donner une petite explication

 

Merci

[Tramber]

utilises plutot NTH car je crois que tu te fais avoir avec CDDR

[je dis ca car je n'ai que LT sous la main, et ce que je dis est peut-être inexact]

 

[Edité le 17/8/2004 par Tramber]

[bonuscad]

Le CAR et CDR sont la base des pointeurs en lisp

 

(car) retourne le 1er élément d'une liste

(cdr) retourne la liste moins le 1er élément

 

c'est avec ses 2 fonctions imbriquées qu'on construit les CADR CADDR CDADR ect.. (4 niveaux maxi.)

 

donc:

(CADR) = (CAR (CDR ))

(CADDR)=(CAR (CDR (CDR)))

 

donc pour un point 3D

(CAR pt) retourne le X

(CADR pt) retourne le Y

(CADDR pt) retourne le Z

 

Si tu demande le CDDR tu obtient un atome dans une liste et pas l'atomer lui même, dans ton cas le Z sous forme de list.

[dfbiagio]

Cela fait longtemps que j'utilise les fonctions CAR et CDR et il n'y a que aujourd'hui que j'ai compris que CAR extrait un atome et CDR extrait une liste même si cette liste ne contient qu'un seul élément. Eh bien voilà, j'aurai encore appris quelque chose d'essentiel aujourd'hui.

 

Merci et A+

[bru]

attention dans le cas s'une association (8 . "mon_layer"),

 

Command: (cdr '(8 . "mon_layer"))
"mon_layer"
Command: (cadr '(8 . "mon_layer"))
Error: bad argument type: consp "mon_layer"

 

 

à +

 

[bonuscad]

Très bonne remarque. :D

 

Ce cas particulier est appelé PAIRE POINTEE. Il ne peut donc s'appliquer au point 3D qui comporte 3 atomes.

Cet méthode de paire pointée est beaucoup utilisé dans la base de données d'Autocad car cette forme de liste est moins gourmande en espace mémoire. Vous retrouvez cette forme de liste par un appel à (enget).

 

exemple

(entget (car (entsel)))

 

NB: (assoc) fonctionne avec ces 2 type de liste

[Serge]

Bru,

 

L'exemple que tu donnes: (cadr '(8 . "string")),

revient à dire: (car (cdr '(8 . "string")),

c'est-à-dire: (car "string"),

ce qui est une erreur (les fonctions c****r ne s'applique qu'à des listes.

 

Il y a 2 méprises que les AutoLispien commettent face au cons et au list

1) le cons n'est pas un cas particulier d'une liste. La différence est plus évidente si l'on connaît l'origine d'AutoLISP, soit le Common Lisp (datant des années 50). La méprise vient de la facilité qu'AutoLISP a de traiter les 2 comme s'il s'agissait d'une seule et même chose. Dans l'exemple ci-après, on voit la différence:

 

Commande: (setq test1 (assoc 8 (list (list 8 "a") (list 10 "b"))))

(8 "a")

 

Commande: (setq test2 (assoc 8 (list (cons 8 "a") (cons 10 "b"))))

(8 . "a")

 

Si on veut extraire le "a", il faudra dans le premier cas inscrire (cadr test1) mais dans le deuxième cas (cdr test2)

 

La structure du cons est très efficace lorsqu'on sait qu'on a une relation en paire (dotted pair). Le cas classique est la liste des codes dxf retournés par (entget)

 

2) L'apostrophe ne construit pas de liste mais demande à l'interpréteur Lisp d'ignorer ce qui suit: soit un mot ou une expression ou même une variable échangée à une fonction ActiveX

Exemple 1: (if (= (type MyVar) 'STR) (princ "\nCeci est une chaine"))

Exemple 2: (entmake '((0 . "CIRCLE") (62 . 1) (10 4.0 4.0 0.0) (40 . 1.0)))

Exemple 3: (mapcar 'strcase '("aaa" "bbb" "ccc"))

Exemple 4: (apply '(lambda (x y z) (* x (- y z))) '(5 20 14))

Exemple 5: (vla-GetBoundingBox MyVlaVariable 'minExt 'maxExt)

 

Le fait de comprendre cette nuance permet de comprendre la portée des instructions SET vs SETQ. Cela permet de savoir quand utiliser l'apostrophe vs les expressions LIST ou CONS

 

Exemple 1: (setq flexListe (liste a b c)) ; permet d'adapter n'importe situation

Exemple 2: (setq constListe '("aaa" "bbb" "ccc")) ; Cas d'une constante

Exemple 3: (setq monErreur '(a b c)) ; Retourne (A B C), ce qui ne veut rien dire

 

 

Il y a un piège supplémentaire en vue qui me déplait en tant que 'puriste' du Common Lisp est la nouvelle expression vl-list*, comme dans l'expression (vl-list* 1 2 3) qui retourne (1 2 . 3). Que fait-on de cette structure? On risque de patiner avec les fonctions car, cdr, etc.

 

Serge

[bru]

Il y a un piège supplémentaire en vue qui me déplait en tant que 'puriste' du Common Lisp est la nouvelle expression vl-list*, comme dans l'expression (vl-list* 1 2 3) qui retourne (1 2 . 3). Que fait-on de cette structure? On risque de patiner avec les fonctions car, cdr, etc.

 

je ne sais pas à quoi sert vl-list*, mais ca ressemble étrangement à

Command: (cons 3 2)
(3 . 2)

Command: (cons 3 (cons 2 3))
(3 2 . 3)

Command: (cons 3 (cons 2 (cons 2 3)))
(3 2 2 . 3)

Command: (car (cons 3 (cons 2 (cons 2 3))))
3

Command: (cdr (cons 3 (cons 2 (cons 2 3))))
(2 2 . 3)

 

 

ceci ressemble étrangement à celà:

http://www.ensias.ma/ens/kassou/cours/coursEP/donn_hier1.htm

 

à+

[Serge]

Salut,

 

On peut en effet se passer de la routine vl-list* et se servir dee combinaison car-cdr.

L'idée est: pourquoi créer des listes non conventionnelles. Cela déroge du Lisp pur et rend le code et le débogage plus complexe à comprendre inutilement.

 

Par exemple: (setq z (vl-list* 1 2 3))

retourne (1 2 . 3)

 

À première vue, on se serait sentit légitimé de puiser le 3ième élément comme suit:

(nth 2 z)

Ce n'est pas permit et on peu chercher longtemps pourquoi. Il faut utiliser (cddr z)

 

Faire (setq z (list 1 2 3)) permet à (nth 2 z) et à (caddr z) d'obtenir un résultat prévisible.

 

Serge