Sams Teach Yourself Arduino Programming in 24 Hours (2015)

---

You may see that the Arduino placed the variables in sequence within the memory area. (There should be enough separation between each location to hold the number of bytes required for each data type: 2 bytes for the integer value, and 4 bytes for the floating-point value.)

Working with Pointers

Now that you’ve seen the basics of how the reference and dereference operators work, let’s take a look at how to use them in sketches. This section walks through the details of how to use pointers in sketches.

Retrieving Data Using a Pointer

Once you have a memory location stored in a pointer variable, you can use that information to extract the value stored at that location. You just use the dereference operator to do that:

int test1 = 10;
int *ptr = &test1;
int test2 = *ptr;

The ptr pointer variable contains the memory address for the test1 variable. To retrieve the value stored at that memory location, just use the dereference operator on the ptr variable. The test2 assignment statement assigns the value stored in the memory address pointed to by the ptrpointer variable to the test2 variable. The test2 variable will now have to value 10.

Storing Data Using a Pointer

Likewise, you can assign a value to a memory location using the dereference operator:

int test1 = 100;
int *ptr = &test1;
*ptr = 200;

The ptr pointer variable points to the memory location used to store the test1 variable value. When you assign a value to the dereferenced memory location, this places the value into the memory location. After this code runs, the test1 variable will contain the value of 200.

Using Special Types of Pointers

You can run into a couple of special situations when using pointers. This section walks through two situations that might seem odd but that can come in handy when using pointers in your Arduino sketches.

Null Pointers

When you declare a pointer but don’t initialize it to a specific memory location, the pointer may or may not have an initial value assigned to it by the Arduino. That can cause issues in your sketch if you’re not careful. One way to avoid that is to declare a null pointer. A null pointer is set to a value of 0, which doesn’t represent a valid location in memory. You do that using the special NULL label in C:

int *ptr1 = NULL;

The NULL value assigns a value of 0 to the pointer ptr1 as the initial value.

One benefit of initializing an empty pointer to the NULL value is that it allows you to easily check to see whether a pointer is in use or not in your sketch code by using an if-then condition check:

if (ptr1) {
// pointer in use
} else {
// pointer is NULL
}

If the pointer has a NULL value assigned to it, it returns a false value from the if-then condition check.

Void Pointers

Another pointer trick that can come in handy is to use the void data type when declaring a pointer:

void *ptr1 = NULL;

This is called a void pointer. Because there isn’t a data type associated with the pointer, you can use the same pointer variable for storing the memory address of different data type variables:

int test1 = 10;
float test2 = 3.14159;
char[] test3 = "This is a character array string";
void *ptr = NULL;
ptr = &test1;
Serial.print(ptr, HEX);
ptr = &test2;
Serial.print(ptr, HEX);
ptr = &test3;
Serial.print(ptr, HEX);

You can use the void data type to represent a pointer if you’re not sure of the specific data type of the data you need to point to. However, that does limit what you can do with the pointer somewhat. When the Arduino knows the data type that the pointer points to, you can use that information to perform some fancy data manipulation. The next section shows how to do that.

Pointer Arithmetic

One popular use of pointers in the C programming language is manipulating values stored in an array variable. If you remember from Hour 7, “Programming Loops,” array variables store multiple data values sequentially in memory, with each individual data value referenced using an index value. For example:

int test[5] = {10, 20, 30, 40, 50};
Serial.println(test[0]);

You reference a specific data value stored in the array variable using the index value between the square brackets. The index values start at 0, and go to the end of the array data values.

Because pointer variables point to locations in memory, you can use a pointer to point to the location of the start of the array variable in memory:

int *ptr = &test[0];

This line uses the dereference operator to return the memory location where the Arduino stores the first data value in the test array.

Now here’s where the data type for the pointer comes into play. If you increment the ptr value by one, the Arduino actually makes it point to the next data element in memory for that data type. Thus, if you do this:

ptr++;

The ptr variable will now point to the memory location where the test[1] array variable value is stored.

Now here’s the really cool part. The pointer arithmetic works for any data type you use. If you create an array of float values and create a pointer to it

float test2[] = {1.23, 4.56, 7.89};
float *ptr2 = &test2[0];

the pointer arithmetic increments the pointer to the next floating-point number in the array, based on the size of the float data type. So, when you use the statement

ptr2++;

the Arduino skips to the next float value stored in the test2 array.

This feature allows you to iterate through an array of any data type without using an array index value. Let’s go through an example of doing that in an Arduino sketch.