question regarding the *p and the p inside the for loop - c++

Question

I have two question about the following code, in particular the int sum(const int *begin, const int *end) function. The thing that I don't understand is why is it that we assign p as a pointer to an immutable constant i.e. begin. But then we also have ++p in the for loop inside sum()? Why is it that it is ++p but not ++*p? And why is it that is is p!=end but not *p!= end?
I was reading that: "In const int *p, *p (content pointed-to) is constant, but p is not constant."
I don't quite understand the difference between the usages of *p and p in this function.
My second question is: What is the reason of declaring const in: const int *p = begin in the for loop of int sum(...)? Is it because in the signature of int sum(...), there is this const being declared for: const int *p = begin ? I.e. is it because begin is being declared as something that is immutable - so that's why in the for loop, we have to declare begin is an immutable constant pointed to by the pointer *p?
/* Function to compute the sum of a range of an array (SumArrayRange.cpp) */
#include <iostream>
using namespace std;
// Function prototype
int sum(const int *begin, const int *end);
// Test Driver
int main() {
int a[] = {8, 4, 5, 3, 2, 1, 4, 8};
cout << sum(a, a+8) << endl; // a[0] to a[7]
cout << sum(a+2, a+5) << endl; // a[2] to a[4]
cout << sum(&a[2], &a[5]) << endl; // a[2] to a[4]
}
// Function definition
// Return the sum of the given array of the range from
// begin to end, exclude end.
int sum(const int *begin, const int *end) {
int sum = 0;
for (const int *p = begin; p != end; ++p) {
sum += *p;
}
return sum;
}

Answer 1

As a reminder, the table of const and pointers:
int * p -- Pointer to a mutable (read/write) location. Pointer and target data may be modified.
int const * p -- Pointer to read only location. The data at the location constant, read-only.
int * const p -- Constant pointer to read/write location. Pointer can't be changed, but data at location may be changed.
int const * const p -- Constant pointer to constant data. Neither pointer nor data may be changed.
In the declaration:
int sum(const int *begin, const int *end);
The pointers are mutable pointers to constant data. The pointers may be modified, but they point to constant (read-only) data.
Edit 1: Incrementing a pointer
Let's assign a pointer, p, the value of 0x12.
Integers will be 4 bytes in length:
+---+
p -> | 1 | 0x12
+---+
| 2 | 0x13
+---+
| 3 | 0x14
+---+
| 4 | 0x15
+---+
| 0 | 0x16
+---+
| 6 | 0x17
+---+
| 1 | 0x18
+---+
| 9 | 0x19
+---+
The integer at *p == 1234 (provided Big Endian layout).
Incrementing p will produce the address: 0x12 + 1 * sizeof(int), or
0x12 + 1 * (4) == 0x16.
+---+
p -> | 1 | 0x12
+---+
| 2 | 0x13
+---+
| 3 | 0x14
+---+
| 4 | 0x15
+---+
p + 1 -> | 0 | 0x16
+---+
| 6 | 0x17
+---+
| 1 | 0x18
+---+
| 9 | 0x19
+---+
Edit 2: Alignment
There is an issue of alignment at this perspective.
Let's assume the processor is 32-bits. It has an internal register (word) size of 32 bits (4 octets). The processor is defined to fetch 32-bits out of memory.
Let us store integers at addresses 4, 8, 12 and 16. The binary representation of those addresses:
0000 0100 -- 4
0000 1000 -- 8
0000 1100 -- 12
0001 0000 -- 16
As you can see, the rightmost 2 bits are always zero. The processor designer's don't need to implement the 2 rightmost address lines (thus saving money and real estate space). In this processor, fetches at address evenly divisible by 4 are most efficient (1 fetch). They are aligned to a 4-byte boundary.