 We saw earlier that when you pass an array to a function, that passes the array's address. No ampersand is needed here, because arrays are handled specially. It's possible to use a pointer as the parameter of the function. This will store the address of the array in a pointer. And it can then be used exactly as if it were an array. However, C programmers prefer to use pointers as pointers. Let's get the function out of the way, and use a simplified version with the array and the pointer. Right now, p is a pointer to integer, and it points to element 0 of the array. If you add 1 to the pointer, that will point it to the next element in the array, and adding 2 to the pointer points to the third element in the array. Remember, these are pointers, and in order to access the array elements, you need to dereference them. Here's a table of the correspondences between the array notation and the pointer notation. When you use pointers, you have to add to the pointer to make the pointer refer to the element you want, and then you dereference it. Now let's generalize this table by adding 0 to the pointer to access the first element in the array. And we can now rewrite the sum of array elements function by adding to the pointer, because pointers and arrays are so closely related. There are many ways to rewrite this function that sums the elements of the array. Here's an approach similar to the one that the book uses. They use an array as the parameter and start with the results set to 0. Then, create a pointer to integer called pLimit that points 1 past the end of the array. This will be used to limit our iteration. It will be the array plus the number of items. Now we're going to run a for loop. We'll have a pointer to integer. We'll start it at the beginning of the array, continue as long as the pointer is less than that limit that we established in the preceding line, and increment the iteration pointer by 1 as the end of loop action. The body of the loop sets the new value of result to the preceding value of the result plus the value that we get by dereferencing the pointer. Once the loop is complete, we return the result. Let's build and run, and there's our answer. The book notes the pointers are a more efficient way to do this calculation, which involves iterating through array elements one after another. I wrote a program with four different approaches to summing the array, and called each function a million times with an array of 1,000 random integers. Here are the results, and indeed pointer notation is significantly faster than array notation. And that's why you should use pointers when iterating through an array.