Declaring types

Types can contain regular variables such as floating point values, integers and strings. They can also contain arrays and other types. This section of the documentation provides several examples showing the different ways in which types can be declared.

The program that follows defines and uses a type named myType.

type myType
	a as integer
	b as float
	c as string
endtype


data as myType


data.a = 1
data.b = 1.23
data.c = "hello"


do
	print ( data.a )
	print ( data.b )
	print ( data.c )
	

	sync ( )
loop

The type declaration for myType contains three variables named a, b and c. a is declared as an integer, b is declared as a floating point value and finally c is declared as a string. A variable named data is declared that is of type myType. This is followed by three lines that assign values to the contents of data. Then there's the loop that continually prints out the values within data

The next program shows how a type can contain an array.

type myType
	a as string [ 4 ]
	b as integer [ 4 ]
endtype


data as myType


data.a [ 1 ] = "a"
data.a [ 2 ] = "b"
data.a [ 3 ] = "c"
data.a [ 4 ] = "d"


for i = 1 to 4
	data.b [ i ] = i * 5
next i


do
	for i = 1 to 4
		print ( data.a [ i ] + " " + str ( data.b [ i ] ) )
	next i
	

	sync ( )
loop

A string array named a is declared within the type declaration along with an integer array named b. The way they are declared is just the same as when dealing with regular arrays, except these arrays are contained within myType. This is followed by a few lines that assign values to the arrays within data. Then the loop simply prints out the contents of data.a and data.b

Types can also contain other types, as displayed in this program.

type myTypeA
	score as integer
	names as string [ 4 ]
endtype


type myTypeB
	sub as myTypeA
	value as float
endtype


data as myTypeB


data.sub.score = 1
data.sub.names [ 1 ] = "a"
data.sub.names [ 2 ] = "b"
data.sub.names [ 3 ] = "c"
data.sub.names [ 4 ] = "d"
data.value = 1.45


do
	print ( data.sub.score )
	

	for i = 1 to 4
		print ( data.sub.names [ i ] )
	next i
	

	print ( data.value )
	

	sync ( )
loop

The type myTypeA is declared, which is then followed by the declaration for myTypeB. This type declares a variable sub that uses the type myTypeA. The next few lines beneath this show how to access a type within a type.

The final program shows how you can have an array of a type.

type playerType
	score as integer
	name as string
endtype


players as playerType [ 3 ]


players [ 1 ].score = -1000
players [ 1 ].name = "lee"
players [ 2 ].score = 100
players [ 2 ].name = "paul"
players [ 3 ].score = 500
players [ 3 ].name = "rick"


do
	for i = 1 to players.length
		print ( players [ i ].name + " = " + str ( players [ i ].score ) )
	next i
	

	sync ( )
loop

To specify that a variable using a type is going to be an array just add on the opening bracket, the size of the array and lastly the closing bracket, just like you would do with a regular floating point, string or integer array.

The variable players is treated like a regular array, so it's possible to use the likes of length and sort with it, as shown in the for loop that iterates from 1 to the size or length of the array.