Warnings!

Now that warnings have been said (reread them) we can move on and see how can we put an arrays to the heap.

option explicit

dim i as integer
dim p as integer ptr

p = callocate(len(integer) * 10)

if p = 0 then
   print "ERROR: Out of memory!"
   sleep
   end
end if

for i=0 to 9
   p[i] = i
next

for i=0 to 9
   print *(p+i)
next

sleep
deallocate p

Notice that we allocated memory by multiplying the size of integer by ten, but true indexing ranges from 0 to 9, be aware of this! Placing UDT's to heap is done just the same way, only use len(udt) and if you want to have an array of it, multiply it by array size

Linked lists
Now that we have understood all previous, let's move on. As you saw pointers can point at UDT's, but they can also be a part of the UDT, furthermore pointer part of the UDT can point to it'own UDT -thus linked lists. All there is about these mysterious things is this that udt's point to other udt's. Let's start with simple example:

'Simple linked list example

type linkedlist
   'data that list holds
   i as integer

   'points to next node
   listnext as linkedlist ptr
   'pointe to previous node
   listprev as linkedlist ptr
end type

'the head node of the list
'and two for temporary use
dim head as linkedlist ptr
dim node as linkedlist ptr
dim temp as linkedlist ptr

for i = 1 to 10

   'allocate memory
   node = callocate(len(linkedlist))

   if node = 0 then 'see if allocation was succesful
      print "ERROR: Out of memory"
      sleep

      'because some initalisations may have
      'been successful, we need to deallocate them
      goto endlinkedlist:
      end
   end if

   node->i = i 'set our data

   'point to previously allocated node
   node->listprev = temp

   if temp = 0 then  'see if temp is 0 -if is then it is first
                     'allocation
      temp = node    'set temp to show current one
      head = temp    'also set head
      continue for
   end if

   'set next node of the previous node to be current one
   temp->listnext = node
   temp = node 'set this for next run
next

'since we save first node as head -we can use it to start reading from the list
node = head

'since final node's listnext holds 0, we can use this
'as the condition to terminate when link is over
while node
   'print out data that node holds
   print node->i;

   'save the current node -for the next demo
   temp = node

   'move to the next one
   node = node->listnext
wend

print

'since we saved in previous demo temp to
'be last active node, we can use it
node = temp

'Just like listNext of the lastnode is NULL pointer
'so is listPrev of the first noe. So again we can use this as
'terminate condition to make sure we exit the list.
while node

   'print out data that node holds
   print node->i;

   'instead of next -let's move backwards
   node = node->listprev
wend


sleep

endlinkedlist:

'again start from the head and move through
node = head
while node
   temp = node 'to avoid getting next node from already
               'deallocate node, we need to use a temp
   node = node->listnext
   deallocate (temp)
wend

• Stack - describes as First First in First out. Is pretty easy to understand and is used a lot.
  Stack

  'FreeBasic Linked-list example
  'Stack
  'By VonGodric
  OPTION explicit
  TYPE MyStack
     DATA AS STRING
     Node AS MyStack ptr
  END TYPE
  
  SUB Push (PushData AS STRING, byref Stack AS MyStack ptr)
     DIM NewNode AS MyStack ptr
     NewNode  = CAllocate(LEN(MyStack))
     NewNode->Data = PushData
     NewNode->Node = Stack
     Stack   = NewNode
  END SUB
  
  FUNCTION Pop (byref Stack AS MyStack ptr) AS STRING
     DIM OldNode AS MyStack ptr
     OldNode  = Stack
     Pop      = OldNode->Data
     Stack    = OldNode->Node
     deallocate(OldNode)
  END FUNCTION
  
  FUNCTION Top (byref Stack AS MyStack ptr) AS STRING
     Top   =  Stack->Data
  END FUNCTION
  
  FUNCTION IsEmpty (byref Stack AS MyStack ptr) AS INTEGER
     IsEmpty = Stack=0
  END FUNCTION
  
  
  '-------------------------------------------------------------------------------
  'Main code
  
  DIM test AS MyStack pointer
  DIM a    AS STRING
  
  DO
     a$=INKEY$
     IF a$>"" AND a$<>chr$(13) THEN PRINT a$; : push (a$, test)
  LOOP UNTIL a$=CHR$(13)
  
  PRINT
  
  DO WHILE NOT IsEmpty(test)
     PRINT Top (test);
     PRINT Pop (test);
  LOOP
  
  SLEEP
  
  '-------------------------------------------------------------------------------

• Queue describes as first in last out:
  Queue

  'FreeBasic Linked List example
  'Queue
  'By VonGodric
  OPTION explicit
  TYPE MyQueue
     DATA AS STRING
     Node AS MyQueue ptr
  END TYPE
  
  TYPE Queue
     Rear  AS MyQueue ptr
     Front AS MyQueue ptr
  END TYPE
  
  FUNCTION Initalise(QueuePtr AS Queue ptr) AS INTEGER
     QueuePtr->Front         = callocate(LEN(MyQueue))
     IF QueuePtr->Front      = 0 THEN Initalise = 0 : EXIT FUNCTION
     QueuePtr->Rear          = QueuePtr->Front
     QueuePtr->Front->Node   = 0
     Initalise=-1
  END FUNCTION
  
  FUNCTION Join (Queue AS Queue ptr, QData AS STRING) AS INTEGER
     DIM NewNode AS MyQueue Ptr
     NewNode=callocate(LEN(MyQueue))
     IF NewNode = 0 THEN Join = 0 : EXIT FUNCTION
     NewNode->Data = QData
     NewNode->Node = 0
     Queue->Rear->Node = NewNode
     Queue->Rear       = NewNode
     Join = -1
  END FUNCTION
  
  FUNCTION leave(QueuePtr AS Queue ptr) AS STRING
     DIM OldNode AS MyQueue ptr
     OldNode = QueuePtr->Front->Node
     leave = OldNode->data
     IF (QueuePtr->Front->Node->Node = 0) THEN
        QueuePtr->Rear = QueuePtr->Front
     ELSE
        QueuePtr->Front->Node = QueuePtr->Front->Node->Node
     END IF
     deallocate(OldNode)
  END FUNCTION
  
  FUNCTION IsEmpty (QueuePtr AS Queue ptr) AS INTEGER
      IsEmpty =  (QueuePtr->Front = QueuePtr->Rear)
  END FUNCTION
  
  '-------------------------------------------------------------------------------
  'Main code
  DIM test AS Queue
  IF NOT Initalise(@test) THEN END
  
  DIM a    AS STRING
  DO
     a$=INKEY$
     IF a$>"" AND a$<>chr$(13) THEN PRINT a$; : Join (@test, a$)
  LOOP UNTIL a$=CHR$(13)
  PRINT
  DO WHILE NOT IsEmpty(@test)
     PRINT Leave (@test);
  LOOP
  
  SLEEP
  '-------------------------------------------------------------------------------

• Circular queue - sry no example, but the example I made with numbers -previously, is pretty close to it. While Stack and Queue presented here are one directional (nodes don't have info about previous nodes) then circular's lists have both directional ways. Als end is connected with the front forming a cycle that never ends. It reaches the end and just jumps to first one. Like weekdays, after every sunday cames monday.

Pointers and functions/subs
So far We've been through a lot and there's very little left to describe -although it is a matter on what could be possible to write heavy nooks. First We'll look at pointers in the functions/subs argument lists.

Very similar actually to defining any other pointer -you just put a pointer, and pass the pointer or address with @.

sub test (byval i as integer ptr)
   print *i
end sub

dim i as integer
i=10
test ( @i )
sleep

sub test (byref i as integer)
   i = 10
end sub

dim i as integer
print i
test i
print i
sleep

However more interesting part ( and very useful ) is pointers to subs/functions themselves. Yes, it is possible!. Here's small example:

sub sub1 ( i as integer )
   print "hello from sub1"
   print "you passed value: "; i
end sub

sub sub2 ( i as integer )
   print "hello from sub2"
   print "you passed value: "; i
end sub

dim test as sub (i as integer = 10)
test = @sub1
test ( 6 )
test ( )

test = @sub2

test ( 1001 )
test ( )

sleep

function func2 ( i as integer ) as integer
   func2 = i * i
end function

function func1 ( byval tocall as function, byval value as integer )
   dim i as function ( i as integer ) as integer
   i = tocall
   func1 =  i ( value )
end function

dim s as function ( byval tocall as function(i as integer), byval value as integer ) as integer
s=@func1

print s(@func2, 10)

sleep

option explicit
dim i as integer
dim ip1 as integer ptr
dim ip2 as integer ptr ptr

ip1 = @i
ip2 = @ip1
**ip2 = 157
print i, *ip1, **ip2
print @ip1, *ip2
ip2 = @i
*ip2 = 751
print i, *ip2
sleep

Typeless Pointers
Sometimes we do not really know or need to either, the type of the pointer in our program, let's say like when passing to the function/sub as an argument, we may be dealing with different types in it. For that in FB is ANY ptr. Here's example:

option explicit
sub test (byval p as any ptr, byval t as integer)

   dim i as integer  ptr
   dim b as byte     ptr
   dim s as string   ptr
   dim d as double   ptr

   i = p
   b = p
   s = p
   d = p

   select case t
   case 1
      print *i
   case 2
      print *b
   case 3
      print *s
   case 4
      print *d
   end select

end sub

dim i as integer
dim b as byte
dim s as string
dim d as double

i = 10001
b = 127
s = "Hello world!"
d = 2005.0208

test @i, 1
test @b, 2
test @s, 3
test @d, 4
sleep

Conclusion
Well that's pretty mutch it for this tutorial. I hope you liked it and found something useful or new for yourself. One more thing however, throughout this tutorial I used @ symbol to obtain and address of smth, however these functions maybe used as well: