Pointers

A pointer is a data type which holds a memory address. While a variable accesses that memory address directly, a pointer can be thought of as a reference to that memory address.

To declare a pointer data type, add a carat prefix (^) before type. For example, in order to create a pointer to an integer, write:

^integer

In order to access data at the pointer’s memory location, add a carat after the variable name. For example, let’s declare variable p which points to a word, and then assign value 5 to the pointed memory location:

dim p as ^word
'...
p^ = 5

A pointer can be assigned to another pointer. However, note that only the address, not the value, is copied. Once you modify the data located at one pointer, the other pointer, when dereferenced, also yields modified data.

Pointers and memory spaces

Pointers can point to data in any available memory space.
Pointers can reside in any available memory space except in program (code) memory space.

dim ptr1 as ^const byte                  ' ptr1 pointer in data space pointing to a byte in code space
dim ptr2 as ^const ^volatile sfr byte rx ' ptr2 is pointer in rx space pointing to a pointer in code space pointing to volatile byte in sfr space
dim ptr3 as ^data byte code             ' error, pointers can not be placed in code space

Due to backward compatibility, pointers to program memory space can also be declared within constant declaration block (using keyword const):

program const_ptr

' constant array will be stored in program memory
const b_array as byte[5] = (1,2,3,4,5)

const ptr as ^byte     ' ptr is pointer to program memory space

main:
  ptr   = @b_array     ' ptr now points to b_array[0]
  GPIO_PORTA = ptr^
  ptr   = ptr + 3      ' ptr now points to b_array[3]
  GPIO_PORTA = ptr
end.

This leads to equality of the following declarations:

dim   ptr1 as ^const byte  ' ptr1 pointer in data space pointing to a byte in code space
const ptr1 as ^byte        ' ptr1 pointer in data space pointing to a byte in code space

Therefore, when declaring a pointer within constant declaration block, const qualifier refers to pointed object, not to pointer itself.

Notes :

Pointer to constant space (Flash memory) is allocated in RAM.
Constants of a simple type are not allocated in the Flash memory nor in RAM, but changed in the compile time, and therefore address of a such constant can not be obtained.

Function Pointers

Function pointers are allowed in mikroBasic PRO for ARM. The example shows how to define and use a function pointer:

Example:

Example demonstrates the usage of function pointers. It is shown how to declare a procedural type, a pointer to function and finally how to call a function via pointer.

program Example;

typedef TMyFunctionType = sub function (dim param1, param2 as byte, dim param3 as word) as word ' First, define the procedural type

dim MyPtr as ^TMyFunctionType  ' This is a pointer to previously defined type
dim sample as word

sub function Func1(dim p1, p2 as byte, dim p3 as word) as word ' Now, define few functions which will be pointed to. Make sure that parameters match the type definition
  result = p1 and p2 or p3
end sub

sub function Func2(dim abc, def as byte, dim ghi as word) as word  ' Another function of the same kind. Make sure that parameters match the type definition
  result =  abc * def + ghi
end sub

sub function Func3(dim first, yellow as byte, dim monday as word) as word  ' Yet another function. Make sure that parameters match the type definition
  result =  monday - yellow - first
end sub

' main program:
main:
  MyPtr = @Func1            ' MyPtr now points to Func1                                           
  Sample = MyPtr^(1, 2, 3)  ' Perform function call via pointer, call Func1, the return value is 3
  MyPtr = @Func2            ' MyPtr now points to Func2                                           
  Sample = MyPtr^(1, 2, 3)  ' Perform function call via pointer, call Func2, the return value is 5                                          
  MyPtr = @Func3            ' MyPtr now points to Func3
  Sample = MyPtr^(1, 2, 3)  ' Perform function call via pointer, call Func3, the return value is 0
end.

@ Operator

The @ operator constructs a pointer to its operand. The following rules are applied to @:

If X is a variable, @X returns a pointer to X.

Note : If variable X is of array type, the @ operator will return pointer to it's first basic element, except when the left side of the statement in which X is used is an array pointer.
In this case, the @ operator will return pointer to array, not to it's first basic element.
```
program example

dim w  as word
    ptr_b   as ^byte
    ptr_arr as ^byte[10]
    arr     as  byte[10]

main:
  ptr_b   = @arr ' @ operator will return ^byte
  w       = @arr ' @ operator will return ^byte
  ptr_arr = @arr ' @ operator will return ^byte[10]
end.
```
If F is a routine (a function or procedure), @F returns a pointer to F.

Want more examples and libraries?
Find them on