Simple dynamic UDT-subarrays

[ReneMiner]

This is a very simple tutorial script at beginner level

How to append different length dynamic subarrays to some udt
using heap-memory and virtual variables or layovers.


It is meant for fixed size-elements of any type - so no dynamic string-arrays.
(but with a little effort you can create a DWord-array to store pointers for each "string")

This example stores some different sized arrays of Long-variables and shows how to access them again.
To clearify that this Long is just a placeholder for any fixed-size variable or udt it's aliased as "someType"

uses only built-in functions but needs 1.9.8 for the Redim-fix on virtual variables.

#MINVERSION 1.9.8.0
Uses "Console"
 
' this just to make the example better readeable:
Alias Long As someType
 
 
Type t_Type           ' whatever udt, don't care
                      ' it's just an example-type
  
' myArray() As someType is sadly not possible
' but we can help it...
 
  pArray      As DWord ' here node a dynamic array of some type
                       ' "pArray As DWord" here equals pointer of "myArray() As someType" 
                       
End Type
 
Dim foo(3) As t_Type  ' have an array of t_Type...
                      ' but ".myArray()" shall be something different to each,
                      ' maybe an array of someType in this example
                      ' each different number of elements
   
Function TBMain()
  Dim i, j   As Long  ' some counters
   
  PrintL $CRLF & "different length sub-arrays example:" & $CRLF
  
' -- creating the data:
   
' a virtual array  As datatype  At (    now allocated space       ) and fill in data
 
  Local myArray(5) As someType  At HEAP_Alloc(5 * SizeOf(someType)) Value = 1,2,3,4,5 
   
' store pointer in foo(1).pArray using GetAt
 
  foo(1).pArray = GetAt(myArray)
 
' done with foo(1)...  
   
 
' now re-use myArray() for the next members of foo and  
 
' redim it new size At now allocated space...
 
  ReDim myArray(7)  At HEAP_Alloc(7* SizeOf(someType)) 
     
   
' VarPtr to FIRST element of myArray equals GetAT
     
  foo(2).pArray = VarPtr(myArray(1))  
   
   
' fill in some data
   
  Array Assign myArray = -1,-2,-3,-4,-5,-6,-7
   
 
   
' finally do the same to foo(3).pArray but another way:
    
' store pointer of allocated space for 8 elements of someType
 
  foo(3).pArray = HEAP_Alloc(8 * SizeOf(someType))
   
' Redim myArray(8) At allocated space 
 
  ReDim myArray(8) At foo(3).pArray
   
' fill in members data one by one this time:
 
  For i = 1 To UBound(myArray)
    myArray(i) = i * i
  Next 
   
 
' -- retrieving the data:
   
' go through all of foo()       
 
  For i = 1 To UBound(foo) 
   
    PrintL "foo(" & i & ").myArray :"
     
' place virtual array in correct size upon allocated heap:
 
    ReDim myArray(HEAP_Size(foo(i).pArray)/SizeOf(someType)) At foo(i).pArray   
     
' now can access it:
 
    PrintL Str$(UBound(myArray)) & " elements:"
     
' print out each array-member:
 
    For j = 1 To UBound(myArray)
      Print myArray(j) & $TAB
    Next       
     
    PrintL $CRLF & "--------------------------" & $CRLF
  Next
 
   
    PrintL "-------------------------> key to continue"
  WaitKey
  PrintL


' now how is this dynamic?
 
' want to add 1 more element to foo(1)-array...
 
  foo(1).pArray = HEAP_Realloc(foo(1).pArray, HEAP_Size(foo(1).pArray) + SizeOf(someType) * 1 )
 
'check:
  ReDim myArray(HEAP_Size(foo(1).pArray)/SizeOf(someType)) At foo(1).pArray   
 
' set new value to last element of "foo(1).myArray()"
  myArray(UBound(myArray)) = 123
 
' see if the old ones are still there:
  For j = 1 To UBound(myArray)
    Print myArray(j) & $TAB
  Next      
  PrintL
   
  PrintL $CRLF & "-------------------------> key to end"
  WaitKey
 
End Function
 
' allocated heap gets freed by thinBasic if script ends