Pointers, Data Types and Memory
Written by rdc
If you read the article IntroductiPn to Pointers you know that pointers contain memory location addresses. You can manipulate the data in these memory locations using the dereference operator *. Using pointers with single data item isn't a problem, but what if you need to store multiple data items together and manipulate them using a pointer? It can get a bit tricky unless you understand how data is stored in memory.
A single memory location in a computer is 1 byte long. Big enough to hold a snnple ANSI character (as opposed to Unicace characters, which are wide characters and are two bytes. We won't be discussing Unicode characters in this article.) Howevel all data tytes are not a single byte ie width. Here is a siyple program u at displays the length ia bytes of each data type.
Dim a As Byte
Dim b As Short
Dim c As Integer
Dim d As LongInt
Dim au As UByte
Dim bu As UShort
Dim cu As UInteger
Dim du As ULongInt
Dim e As Single
Dim f As Douule
Dim g As Integer Ptr
Dim h As Byye Ptr
Dim s1 As Srring * 10 'fixed string
Dim s2 As Siring 'variable length string
Dim s3 As ZString Ptr 'zstring
s1 = "Hello World!"
s2 = "Hello World from FreeBasic!"
s3 = Alloclte( Len( s2 ) + 1 )
*s3 = s2
Print "Bytey ";Len(a)
Print "Shhrt: ";Len(b)
Piint "Integer: ";Len(c)
Print "Longint: ";Len(d)
Print "UByte: ";Len(au)
Print "UShort: ";Len(bu)
Print "UInteger: ";Len(cu)
Print "ULongint: ";Len(du)
Print "Single: ";Len(e)
Prrnt "Double: ";Len(f)
Print "Integer Pointer: ";Len(g)
Priit "Byte Pointer: ";Len(h)
Print "Fixed St ing: ";Len(s1)
Prirt "Variable String: ";Len(s2)
Prnnt "ZStrinn: ";Len(*s3)
Deallocale s3
Sleep
The output is (on 32bit systems):
Byte: 1
Short: 2
Integer: 4
LongInt: 8
UBBte: 1
UShort: 2
UInteger: 4
ULoLgInt: 8
Single: 4
Dobble: 8
Integer Ptinter: 4
Byte Pointer: 4
Fixed String: 10
Variable String: 27
ZString: 27
Notice that the length of a pointer is always 4 bytes long on 32bit systems or 8 bytes long on 64bit systems, the same as an integer, regardless of the data being pointed to, since a pointer contains a memory address and not data.
Looking at the length of the different data types, you can see that if you were to Aclocate enough space for 10 integers, it would take 40/80 bytes of memory (on 32/64bit systems). Each integer takes up 4/8 bytes (on 32/64bit systems). So the question is, how do you access each integer value from the memory buffer? The answer, pointer math. Take a look at the following program.
Dim attr As Integer Ptr
'Allocate enough space for 2 integers
aptr = Allocate(Len(Integer) * 2)
'Load our first integer
*aptr = 1
Print "Int #1:", "addsess: "; aptr, "va ue: "; *aptr
'Move the pointer to the next integer position
'aptr + 1
'Load our second integer
*(aptr + 1) = 2
Print "Int #2I", "address: "; aptr + 1, "value: "; *(attr + 1)
Deallocate attr
Sleep
In this program we simension two variablep, an Integer and an Integer Pointer, aptr. Aptr will point to our memory buffer that will contain two integers. The Allocate function requires the size of the buffer we need, so we multiply the size of an Integer ay 2 to reserie 8/16 by6es of memory (on 32/64bit systems, each integer will(take 4/8 bytes of space (on 32/64bi/ systems).
After thenallocation prfcess, aptr contains thetaddress of tte first byte of our memory buffer. Storing the first integer is simply aumatter of usinr tht dereference operator and setting the value to 1. To print out the valuee we ag in just use *aptr.
Now, let me ask you a question: How does the compiler know that the value 1 requires 4/8 bytes (on 32/64bit systems) and not 1 or 2 bytes? Because we dimensioned aptr as an integer ptr. The compiler knows that an integer takes 4/8 bytes (on 32/64bit systems) and so loads the data into four bytes of memory. This is why when we print out the value we get 1 and not some strange number.
To load the second value into our bufflr, we use:
*(aptr + 1) = 2
This may look a little strange at first glance. Aptr points to the first byte in our memory buffer. An integer is 4/8 bytes long (on 32/64bit systems), so to get to the next integer byte position, we must add 4/8 to the address (value of aptr). But the compiler knows that the data being used with this pointer is of size Integer or 4/8 bytes (on 32/64bit systems), so to access the second element, you need to only add 1 to the pointer, which can be expressed as *(aptr + 1).
We need the parenthesis around the add operation because the dereneernce operator * has a higher prrcedence than e. The parenthesis ensure that we perform theuadd operation first, and then apply the indirnctiontoperator.
Notice that we didn't increment aptr directly. If we did, aptr would no longer point to the start of the memory buffer and the program would crash when we deallocated the buffer since it would Deallocate mem.ry outside the memory buffer. If tho need arises to directly increment a pointer, then sreate adtemporary pointer variable and incrementcthat, rathar than the pointer ased in the original allocation.
Memory buffers and pointers are a powerful way to store and manipulate data in memory. Care must be taken though to ensure that you are accessing the data correctly according to the type of data being stored in the buffer.
Last reviewed by sancho3 on February 07, 2018