Page 2 sur 3
Publié : mer. 02/févr./2005 14:08
par Torp
Désolé je viens d'y passer ma pause de midi et 2h. mais je vois pas...
je pense qu'il faut passer par une une structure mais j'arrive pas à retomber sur mes pattes...
PS: Ne me donne pas la soluce mais plutot un indice... histoire que j'y passe encore 2 heures
Publié : mer. 02/févr./2005 17:27
par nico
il faut utiliser un autre pointeur!
courage.
Publié : jeu. 03/févr./2005 10:21
par Torp
Bon ca y est j'y suis arrivé ... ca m'a fait un peu fumer le cerveau :
Code : Tout sélectionner
Ma_variable=123
*pointeur1:*pointeur2:*pointeur3
*pointeur1=@*pointeur2
*pointeur2=@*pointeur3
*pointeur3=@Ma_variable
Structure test
Valeur.l
EndStructure
*pointeur.test=*pointeur1
Debug *pointeur\Valeur
*npointeur.test=*pointeur\Valeur
Debug *npointeur\Valeur
*pointeur.test=*npointeur\Valeur
Debug *pointeur.test\Valeur
Contrairement à la méthode avec les "PEEKL", j'y suis plus arrivé par tatonnement et multiples essais, que par logique... J'aimerai bien avoir une explication de texte pas à pas, afin de dissiper la brume ...
Publié : jeu. 03/févr./2005 12:56
par nico
Code : Tout sélectionner
Ma_variable=123
*pointeur1:*pointeur2:*pointeur3
*pointeur1=@*pointeur2
*pointeur2=@*pointeur3
*pointeur3=@Ma_variable
Structure test
valeur.l
EndStructure
; Un pointeur fait référence à une variable (ou autre)
; il se sert de l'adresse de cette variable pour
; créer cette référence.
; Un pointeur ne contient pas de données
; mais pointe vers la variable (via l'adresse qu'il contient)
; dont il peut manipuler la ou les données.
; je crée un nouveau pointeur de type long *Pointeur.test
; ou *Pointeur.LONG qui est déjà déclaré
*Pointeur.test=*pointeur1 ; ici le Pointeur pointe vers la même référence que *pointeur1
; donc *Pointeur et *pointeur1 font référence à la même adresse qui est celle de pointeur2
; car un pointeur ne peut et ne doit contenir qu'une adresse qui sert de référence
; ici *Pointeur\valeur permet de lire(ou d'écrire) le contenu de la variable pointée
Debug *Pointeur\valeur
; et comme le contenu de *pointeur2 est une adresse, je lis une adresse
; cette adresse correpond bien entendu à l'emplacement mémoire du pointeur3
; je me sert du pointeur créé pour pointer cette fois-ci vers le pointeur2
*Pointeur.test=*Pointeur\valeur ;contient le contenu de pointeur2 qui est l'adresse du pointeur3
; donc *pointeur=adresse pointeur3
; Maintenant la valeur pointée par le pointeur contient l'adresse de la variable recherchée
*Pointeur.test=*Pointeur\valeur ;contient le contenu de pointeur3 qui est l'adresse de la variable
Debug *Pointeur.test\valeur ; lecture de la valeur pointée par le pointeur
; et comme ici le pointeur contient l'adresse de la variable, je peux en lire le contenu.
J'espère que c'est clair et que j'ai pas écrit de bêtise car je suis pressé par le temps.
Publié : jeu. 03/févr./2005 13:19
par Torp
Et des cieux vint la lumière... alleluya...
Quand tu veux pour d'autres exercices sur le sujet.
Publié : jeu. 03/févr./2005 14:05
par Torp
De mon côté j'ai trouvé ce code sur le forum anglais. Je trouve cet exemple super instructif, pour le traitement de plusieurs Listes Chainées avec une seule procedure (Par rapport à l'original, j'ai juste rajouté la procedure AJOUT, pour essayer... et ca marche!). Par contre ce que je ne comprends, c'est pourquoi la boucle FOREACH n'affiche rien (c'est aussi un ajout de ma part).
Code : Tout sélectionner
Structure LinkedString
*Next.LinkedString
*Previous.LinkedString
value.s
EndStructure
NewList Hello1.LinkedString()
NewList Hello2.LinkedString()
*ptr.LinkedString
Procedure PrintListContents(*ptr.LinkedString)
Repeat
If *ptr
Debug *ptr\value
EndIf
*ptr=*ptr\Next
Until *ptr=0
EndProcedure
Procedure ajout(*ptr.LinkedString)
*ptr\value = "Nouvel Element"
EndProcedure
*ptr=AddElement(Hello1())
*ptr\value = "GoodDay1"
*ptr=AddElement(Hello2())
*ptr\value = "Bonjour2"
*ptr=AddElement(Hello1())
ajout(*ptr)
*ptr=AddElement(Hello2())
ajout(*ptr)
PrintListContents(FirstElement(Hello1()))
PrintListContents(FirstElement(Hello2()))
ForEach Hello1()
Debug Hello1()\value
Next
Bizarre ou pas bizarre ?
Publié : jeu. 03/févr./2005 18:09
par nico
L'erreur vient de l'exemple et pas de toi.
Quand on déclare une structure avec une LinkedList, PB rajoute à cette structure deux pointeurs *Next et *Previous donc en fait la valeur Value de la structure du pointeur pointe vers *next de la structure hello1().
Code : Tout sélectionner
Structure LinkedString
*Next.LinkedString
*Previous.LinkedString
value.s
EndStructure
NewList Hello1.LinkedString()
NewList Hello2.LinkedString()
*ptr.LinkedString
*ptr=AddElement(Hello1())
*ptr\value = "GoodDay1"
; ce qui donne en réalité
;*ptr\value = Hello1\Next
Debug PeekS(Hello1()\Next); affiche "GoodDay1"
Debug "----------------"
Debug Hello1()\value ;n'affiche rien
Là c'est correct:
Code : Tout sélectionner
Structure LinkedString2
value.s
EndStructure
Structure LinkedString
*Next.LinkedString
*Previous.LinkedString
value.s
EndStructure
NewList Hello1.LinkedString2()
NewList Hello2.LinkedString2()
*ptr.LinkedString
Procedure PrintListContents(*ptr.LinkedString)
Repeat
If *ptr
Debug *ptr\value
EndIf
*ptr=*ptr\Next
Until *ptr=0
EndProcedure
Procedure ajout(*ptr.LinkedString)
*ptr\value = "Nouvel Element"
EndProcedure
*ptr=AddElement(Hello1())
*ptr\value = "GoodDay1"
*ptr=AddElement(Hello2())
*ptr\value = "Bonjour2"
*ptr=AddElement(Hello1())
ajout(*ptr)
*ptr=AddElement(Hello2())
ajout(*ptr)
PrintListContents(FirstElement(Hello1()))
PrintListContents(FirstElement(Hello2()))
Debug "-----------------"
ForEach Hello1()
Debug Hello1()\value
Next
Publié : jeu. 03/févr./2005 20:48
par nico
; simple exercice avec les chaines
chaine.s="Pure Casic is the Cest"
; Changer la lettre C par un B
; en utilisant aucune fonction STRING
Publié : jeu. 03/févr./2005 23:53
par Torp
Et petit à petit le tuto... se fait....
Publié : ven. 04/févr./2005 8:00
par lionel_om
faut utiliser les PeekS et pokeS c'est ca ???
Publié : ven. 04/févr./2005 12:28
par nico
Non!
il faut utiliser un pointeur qui va scruter chaque octet de la chaine.
Publié : ven. 04/févr./2005 13:27
par Torp
Code : Tout sélectionner
; simple exercice avec les chaines
chaine.s="Pure Casic is the Cest"
; Changer la lettre C par un B
; en utilisant aucune fonction STRING
Structure Liste
Valeur.b
EndStructure
*pointeur.Liste=@chaine
*pointeur+5 ;position du "C" de Casis à partir du début de la chaine
*pointeur\Valeur=66 ;valeur Ascii du B
*pointeur+13 ;position du C de "Cest" à partir de la position précédente
*pointeur\Valeur=66 ;valeur Ascii du B
Debug chaine
Ca j'ai bien intégrer
Par contre j'ai pas pigé ta correction du code que j'ai posté (celui sur les où le Foreach ne fonctionnait pas).
En fait on définit une liste : NewList Hello1.LinkedString2()
puis un pointeur : *ptr.LinkedString
et le fait de travailler avec le pointeur, ca modifie les valeur de Hello1... Il y a un fonctionnement que j'ai toujours pas compris. Suis un peu à la masse peut être...
Publié : ven. 04/févr./2005 16:34
par nico
En traitant le problème d'une façon générale, ça donne ça:
Code : Tout sélectionner
*Pointeur.BYTE=@chaine
For a=1 To Len(chaine)
If *Pointeur\b=$43
*Pointeur\b=$42
EndIf
*Pointeur=*Pointeur+1
Next a
Debug chaine
Sinon pour le problème de Linkedlist:
si tu déclares cette structure:
structure Element
valeur.l
endstructure
et que tu fais:
NewList test.Element()
eh bien en réalité Pb modifie ta structure en interne comme ceci:
structure Element
*Next.Element
*Previous.Element
valeur.l
endstructure
La structure n'est changée que pour la LinkedList
Par contre si tu affectes ta structure au pointeur, elle n'est pas modifiée.
Donc au final tu n'as pas la même structure pour le pointeur et pour la LinkedList comme on pourrait le croire; il y a un décalage de 8 octets car la LinkedList à deux éléments (deux pointeurs) supplémentaires en début de structure.
Cette façon de procédé est utilisée pour ne pas perturbée le débutant et aussi, on est sûr que les deux pointeurs seront déclarés correctement pour que la liste chainée fonctionne.
Publié : ven. 04/févr./2005 16:40
par nico
Code : Tout sélectionner
; Second exercice avec les chaines
chaine.s="Pure Basic is the Best"
chaine1.s=Space(Len(chaine))
; Il faut que: chaine1 = "tseB eht si cisaB eruP"
; soit la chaine inversée de la première chaine
; traité le problème d'une façon générale
; aucune fonction STRING ne devra être utilisée
; à part la fonction len()
Publié : ven. 04/févr./2005 21:32
par Torp
Voili Voilou :
Code : Tout sélectionner
; Second exercice avec les chaines
chaine.s="Pure Basic is the Best"
chaine1.s=Space(Len(chaine))
; Il faut que: chaine1 = "tseB eht si cisaB eruP"
; soit la chaine inversée de la première chaine
; traité le problème d'une façon générale
; aucune fonction STRING ne devra être utilisée
; à part la fonction len()
Structure Liste
Valeur.b
EndStructure
*pointeur1.Liste=@chaine
*pointeur2.Liste=@chaine1
*pointeur1+Len(chaine)-1
For i=1 To Len(chaine)
*pointeur2\Valeur=*pointeur1\Valeur
*pointeur2+1
*pointeur1-1
Next
Debug chaine1