Indexing through large arrays; more efficient way?

[RoGuE_StreaK]

Quick revival, I'm about to attempt to bring my old code over to the 24F so thought I'd start with the pointer method to do a speed comparison, before trying the more advanced methods.
Question - if I have say ten arrays, does it hurt to have ten different pointers, or should I use two (need two for two different PWM outputs) and redefine them on the fly? ie., is having 10x pointers no different than just having the 10x arrays, or are there more impacts?

I still have to keep track of the length of the array and where the pointer is up to, correct? ie. it doesn't know how long the array is and will keep incrementing into other data areas unless you stop it?

When the pointer reaches the end of the data (which may not be the exact end of the array), how do I reset the pointer to be back at [0] again for a replay? Is it that n_ptr (for example) is just treated as an integer, and *n_ptr is the array location, so just set n_ptr = 0?
And n_ptr-- will index backwards?

Thanks again for all the input, I'll try to get the basics working again before getting into the uber-optimisations.

[Ttelmah]

90% of this is standard in C.

There is no immediate difference between using a pointer and an array index, except if the index is a constant. CCS will 'pre-solve' accesses to a constant array index at compile time. So here arrays are more efficient.

Yes, you have to check your pointer against your maximum. The only time the that chips/compilers will do this for you, is on chips that have hardware protection for memory accesses.
Setting the index back to the address of the start of the array moves you back to the start of the array.

A physical array, involves actual memory elements to store the whole array. A pointer is only a memory address and will involve far less storage.

There are though general comments:

The key place where a pointer gains, is when you retain the pointer from loop to loop. If (for instance), you have an array that has elements x bytes long, and instead of using array[n] and array[n+1] as you move forward through the array, you have pointer, and pointer+x, the former is done by multiplying n by x, while the latter only involves a single addition. Even with the hardware multiplier, the addition is the smaller and simpler instruction.
If you have one array of pulse widths for instance, and pre-solve for the last element+1 in the array, then have pointers moving through this array, you just add the size of the element, and when the pointer reaches the element+1 location, set the pointer back to the start of the array, this is more efficient than using array indexes.

Setting a pointer to zero, would point to the first address in memory. Not the start of the array.