After building and running your code, you should see the following results in the UART1 Output window:
(Note: Your results may be different)

Code Analysis

(NOTE: Line numbers correspond to those in the provided solution file.)

Lines 12-14
Here, three variables are created for you:

• int x, an ordinary integer, which is initialized with a value of 5. This variable will be assigned a location in RAM.
• int y[10], an array of integers, initialized with values from 0 to 9. This variable will be assigned to a series of 10 sequential locations in RAM.
• int *p, a pointer to an integer. The variable p will be assigned an address in RAM, and at that address, it will store the address of whatever variable it points to. p is not initialized, so for the moment, it has a value of NULL (i.e. its value is zero).

Line 30
A local variable (local to main() ) is declared. We will use this variable as a counter in the for loop below.

Line 37
STEP 1:
Here, you were instructed to assign the address of x to the pointer to p. This is done by setting the variable p, equal to the address of x, using the address of ‘&’ operator:

p = &x;

Because we are writing the address of a variable into the pointer, we simply use the variable p, since that is where the address will be stored (no * is used in this case). In other words, the address of x is stored at the address of p.

Lines 44-48
STEP 2:
Here you were instructed to complete the printf() functions, based on the text description in their control strings.
(1) To complete this line, we need to refer to the address of the variable x, this is done just like we did on line 59 by using the address of operator:

printf(“The variable x is located at the address 0x%X\n”, &x);

(2) For this line, we need to refer to the value of the variable x. This is done by simply using the variable x by itself:

printf(“The value of x is 0x%X\n”, x);

(3) Now, we are going to work with the pointer variable. The intention of this line is to print out the address of the pointer variable p itself. This can be done the same way as we referred to the address of x:

printf(“The pointer p is located at address 0x%X\n”, &p);

(4) Next, we need to print out the value contained in p. This is the address of the object that p points to. To refer to a pointer’s value, you just use the pointer variable by itself, just like we did for x:

printf(“The value of p is 0x%X\n”, p);

(5) Finally, we are asked to print the value pointed to by p. To do this, we need to use the dereference operator ‘*’ with the pointer p (the control string provided a hint):

printf(“The value pointed to by *p is 0x%X\n”, *p);

The dereference operator allows us to retrieve whatever value is at the location that p is pointing to.

Line 55
STEP 3:
On this line, you were instructed to write the value 10 to the location pointed to by p. To do this, we need to use the dereference operator as we did in the last part of the previous step:

*p = 10;

Line 60
STEP 3:
Here, we reassign the pointer to point to the first element of the array y[]. We can do this because the only requirement for p is that it points to an integer. Since the elements of y[] are all integers, it is just as valid to have p point to one of y[]’s elements as it is to have it point to x.

Line 71
STEP 4:
We are now inside the for loop, where we will go through every element of the array y[] and print out its value. Instead of using the loop counter as the array index and using normal array notation to do this, we are going to use a pointer to iterate through each element of the array. This is a great illustration of the fact that arrays are merely simplified notation for pointers. Our first task is to increment the value that p points to. Due to operator precedence rules, we need to use parentheses to make this work properly:

(*p)++;

This syntax means that we first dereference the pointer, then perform the increment, so that the item pointed to by p is what gets acted on by the increment operator.

Line 72
STEP 4:
This line simply prints out the value contained in the array element that is currently pointed to by p. Note the use of the *p as the item in the argument list.

Line 78
STEP 5:
Now, we need to increment the pointer itself. To do this, we simply operate on the pointer variable itself:

p++;

Because of the way the compiler handles pointer arithmetic, this operation may or may not increment the value in p by 1. In this particular situation, where the 16-bit PIC^® MCUs have byte addressable data memory, the value in p will actually be incremented by 2 since integer type variables occupy two bytes.