Dll et tableaux

Torp · Message par **Torp** » mer. 02/févr./2005 14:08

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

nico · Message par **nico** » mer. 02/févr./2005 17:27

il faut utiliser un autre pointeur!

courage.

Torp · Message par **Torp** » jeu. 03/févr./2005 10:21

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 ...

nico · Message par **nico** » jeu. 03/févr./2005 12:56

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.

Torp · Message par **Torp** » jeu. 03/févr./2005 13:19

Et des cieux vint la lumière... alleluya...

Quand tu veux pour d'autres exercices sur le sujet.

Torp · Message par **Torp** » jeu. 03/févr./2005 14:05

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 ?

nico · Message par **nico** » jeu. 03/févr./2005 18:09

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

nico · Message par **nico** » jeu. 03/févr./2005 20:48

; simple exercice avec les chaines

chaine.s="Pure Casic is the Cest"

; Changer la lettre C par un B
; en utilisant aucune fonction STRING

Torp · Message par **Torp** » jeu. 03/févr./2005 23:53

Et petit à petit le tuto... se fait....

lionel_om · Message par **lionel_om** » ven. 04/févr./2005 8:00

faut utiliser les PeekS et pokeS c'est ca ???

nico · Message par **nico** » ven. 04/févr./2005 12:28

Non!
il faut utiliser un pointeur qui va scruter chaque octet de la chaine.

Torp · Message par **Torp** » ven. 04/févr./2005 13:27

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...

nico · Message par **nico** » ven. 04/févr./2005 16:34

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.

nico · Message par **nico** » ven. 04/févr./2005 16:40

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()

Torp · Message par **Torp** » ven. 04/févr./2005 21:32

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