PureBasic

Si j'ai bien tout compris, les pointeurs déclarés dans Pure Basic sont de type void et ne sont donc pas typé, mais on peut voir certains exemples de code dans l'aide qui utilise des pointeurs typés.

Alors est-ce que ça un sens?

Mais si, tu as des pointeurs typés!

Code : Tout sélectionner


Structure MaStruc
  a.l
  b.l
EndStructure

truc.MaStruc

*ptr.MaStruc=@truc  ;<- déclaration d'un pointeur typé

*ptr\a=199

Debug truc\a

filperj a raison.

Un pointeur à la base stock une adresse.
Si tu veux connaitre le contenue de cette adresse, tu dois typer le pointeur pour qu'il sache quoi te rendre (Long, word, byte...)

Oui tu as raison, je voulais parler des pointeurs non associés à une structure.

Comme cet exemple dans l'aide:

Code : Tout sélectionner

  ; An example which is only for advanced users 
  NewList numbers.w() 

  AddElement(numbers()) 
  numbers() = 5 
  AddElement(numbers()) 
  numbers() = 8 

  *element.w = FirstElement(numbers()) 
  If *element 
    MessageRequester("Information", "First element value is "+Str(PeekW(*element+8)), #PB_MessageRequester_OK) 
  Else 
    MessageRequester("Information", "List is empty", #PB_MessageRequester_OK) 
  EndIf

*element.w (ici le type Word n'est pas pris en compte par le compilateur car *element peut pointer vers n'importe quel type de variable)

Je pense qu'ici le pointeur est de type void et ne devrait pas être typé bien que ce ne soit pas pris en compte par le compilateur, on ne devrait pas l'écrire ainsi qu'en penses-tu?

C'est vrai qu'en PB on peut faire pointer n'importequel pointeur sur n'importequoi, le compilo s'en fout complètement...
En fait, le type du pointeur défini seulement la façon dont sera manipulée la mémoire pointée, le reste est sous l'entière responsabilité du programmeur.

Sinon, c'est vrai que "*ptr.w" n'a pas de sens. "*ptr.WORD" serai plus correct.

L’exemple que tu donnes n’a rien de contradictoire.

*element pointe une adresse

A partir de cette adresse tu peux lire un Long, un Word ou autre.
Ainsi tu pourras toujours ecrire PeekL(*element) meme si *element est de type Word (*element.w)
En fait pour moi *element\w est équivalent à PeekW(*element)

Tiens un bout de mon prog qui illustre la lecture d'une valeur à une adresse donnée

Code : Tout sélectionner

Structure MultiTypes
  StructureUnion
    b.b 
    w.w 
    l.l
  EndStructureUnion
EndStructure

Procedure.l GetValue(*adress.MultiTypes, Type.b);/ Return the value at the adress according to type format
  Select Type
    Case  #Byte
      ProcedureReturn *adress\b
    Case #Word
      ProcedureReturn *adress\w
    Case #Long
      ProcedureReturn *adress\l
  EndSelect
EndProcedure

Procedure SetValue(*adress.MultiTypes,Type.b,val.l);/ Set the value vat at the adress according to type format 
  Select Type
    Case  #Byte
      *adress\b = val
    Case #Word
      *adress\w = val
    Case #Long
      *adress\l = val
  EndSelect
EndProcedure

Ok, grace a filperj je viens de comprendre ce qui te tracassais nico.
Effectivement *element.w n'a pas vraiment de sens et c'est bien *element.WORD qu'il faut comprendre...

Il est à noter qu'en Pure Basic le pointeur s'incrémente toujours d'un octet quel que soit son type ce qui n'est pas vrai en langage C par exemple.

Tiens, un peu dans le meme genre, j’avais noté ceci :
L’adresse de l’élement courant d’une liste chaine MyList() peut etre obtenue
Soit par
a = @MyList()
soit directement par
a = MyList()

Il me semble de @MyList() est la plus correcte et pourtant…

Code : Tout sélectionner

Structure MyStructure
  field1.l
  field2.l
  field3.l
  field4.l
EndStructure

NewList MyList.MyStructure()


AddElement(MyList())
MyList()\field1 = 1
MyList()\field2 = 1
MyList()\field3 = 1
MyList()\field4 = 1

a = @MyList()
b = MyList()

Debug a
Debug b

nico a écrit :Il est à noter qu'en Pure Basic le pointeur s'incrémente toujours d'un octet quel que soit son type ce qui n'est pas vrai en langage C par exemple.

Je ne comprend pas ce que tu veux dire Nico

Code : Tout sélectionner

; Je précise que je ne programme pas en C
; mais c'est le langage de référence.

Test.l=$11223344

*Pointeur.WORD = @Test

Debug *Pointeur\w       ; = $3344

; Ici il faut incrémenter le pointeur de deux octets
; pour lire la valeur Word suivante.
; Le type du pointeur n'est pas pris en compte,
; alors qu'en C, en ajoutant 1, le pointeur s'incrémente
; de la longueur de son type déclaré.

*Pointeur = *Pointeur + 2

Debug *Pointeur\w       ; = $1122

PureBasic

Les pointeurs.

Les pointeurs.