PureBasic Forums - English

Code: Select all

test1(@x.f3,@z.f3)

Code: Select all

test1(*x, *z)

Code: Select all

test(@k.f3,@j.f3)

Code: Select all

test(k, j)

Code: Select all

; firste we make a variable of POINT type ( a structure with x.l and y.l)
; this one gets it's own memory area reserved, and you can't change that.
Variable.POINT

; let's fill that one with some values:
Variable\x = 100
Variable\y = 625

; Now the '@' thing simply gives you the address, where the Variable is in memory
; let's have a look at that:
Debug @Variable

; at this address, there is now actually stored the X Value, and 4 bytes behind it, the
; y value of the Structure, you can see that with PeekL()
Debug PeekL(@Variable)
Debug PeekL(@Variable + 4)  ; 4 bytes after the X Value, because they are long.

; now, that is not the most comfortable way, to access the data, if we only know
; the address of it, there is a much better one.
; That is what the '*' is for. 

; We define a pointer to that Variable. We make it of the same type, so we can easily
; access the data inside.
*Pointer.POINT

; Now we have the pointer, but it points to nothing. To change the address, the pointer
; points to, we just write it like this:
*Pointer = @Variable

; Note, that you don't write any Members of the Structure here, this way, you can change
; the address of the pointer. As you can see, it points to the same address as the VAriable now:
Debug *Pointer

; Now, to access the data, we simply add the Member of the Structure we want to access. If
; a member is added, you get the Value that is stored in Memory, and not the Address itself anymore.
; See here:
Debug *Pointer\x
Debug *Pointer\y

; The Data can also be modified like that:
*Pointer\x = 22
*Pointer\y = 302

; As the pointer doesn't have it's own memory area, but just points to the one of the
; Variable, we actually changed the Values of the VAriable with the pointer here.
; see here;
Debug Variable\x
Debug Variable\y

Code: Select all

; We use the POINT structure again for explanation.
; Let's assume, we want to give a POINT Structure to a Procedure, how do we do that?
; Well, just the same, as I allready eyplained:
; give the address of the Variable with the Structure to the Procedure, and
; in the procedure, define a pointer, that can access this Variable later

; First, we make the procedure:

Procedure Test(*Pointer.POINT)
  ; The pointer get's defined, if the procedure is called, and is automatically
  ; set to the address we pass, when we call the procedure.
  
  ; Now we can access the data:
  Debug *Pointer\x
  Debug *Pointer\y
  
  ; Note: as this pointer actually points to the Variable in the main program, if we
  ; make changes here, they will be made on that Variable.
  ; This is not a bad thing, as it also allows some tricks, you just need to know that
  ; it works that way, to not make any hard to find mistakes.
  
  *Pointer\x = 5
  *Pointer\y * 1000

EndProcedure

; Now we make a VAriable of that Type:
Variable.POINT

; set some values
Variable\x = 120
Variable\y = 10

; now we call the procedure:
; here we need the address of the Variable, so the Pointer in the procedure will be set to this
; one.
Test(@Variable)

; now see the changed Values:
Debug Variable\x
Debug Variable\y