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]
  PORTA = ptr^
  ptr   = ptr + 3      ' ptr now points to b_array[3]
  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.

  Note :

• 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.

@ 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.

Related topics: Pointer Arithmetic

Want more examples and libraries? 
Find them on