Pointer syntax in a function

You can transform a traditional, index-based iteration into one using only pointer arithmetic like this:

T array[N];

// traditional:

for (size_t i = 0; i != N; ++i)
{
    foo(array[i]);
}

// using pointer arithmetic

for (T * p = array; p != array + N; ++p)
{
    foo(*p);
}

The pointer T * p = array is obtained via the decay of an array name to a pointer to its first element. The connection between the two forms is the fundamental identity array[i] == *(array + i).

int *ptr, i;
int array[20];

ptr  = &i;        // make sure ptr points somewhere valid
ptr  = array;     // put the address of array[0] in the variable ptr
*ptr = array;     // put the address of array[0] into the location ptr points to
ptr  = array[0];  // put the integer in array[0] into the variable ptr
*ptr = array[0];  // put the integer in array[0] into the location ptr points to.

Let's look at your suggested code:

*ptr = array

Remember that here, * is the indirection operator. It returns the object at the memory location to which the pointer points. Also, in this context array is converted to a pointer. So the above line assigns a pointer (i.e. a memory address) to the object ptr points to. This can only be valid if ptr points to a pointer. However, ptr points to an int instead.

On the other hand ptr = array is correct because assigns ptr to point to the first element in the array.

Assuming that you have code like below.

int x=10;

Here x is a variable that holds a value 10. The variable x is nothing but a label to some memory address.

        x
    +-------+
    |  10   |    4050 which is x
    +-------+

So value 10 is stored in 4050. Its always hard to remember memory address. So you make it easy by naming it and using that name.Here x is nothing but a label to memory address 4050.

int *x_ptr;

Here x_ptr is a pointer variable that can store memory address of any integer variable.

   +-------+
   |  GBV  |   5000 which is x_ptr
   +-------+

Here x_ptr is a label for address 5000. Initially the variable will contain Garbage Value(GBV).

x_ptr = &x;  

The above statement stores address of x in x_ptr.

   +-------+
   |  4050 |   5000
   +-------+
 x_ptr = &x = 4050
 printf("%u",x_ptr); // 4050
 printf("%d", *x_ptr); // 10

 *x_ptr = *(4050) = valueAt(4050) =  10  

Let us now discuss about your code.

int *ptr;

+-------+
|  GBV  |   6000 which is ptr
+-------+

int array[4] = {1,2,3,4};

+-----------+
|     1     |    7824 which is array+0 or array[0]
+-----------+
|     2     |    7828 which is array+1 or array[1]
+-----------+
|     3     |    7832 which is array+2 or array[2]
+-----------+
|     4     |    7836 which is array+3 or array[3]
+-----------+

Here array = 7824

int *arrayEnd = array + n; 

Incrementation with memory location will increase no of bytes based on the data type.

array+0 = 7824 + 0 = 7824
array+1 = 7824 + 1(4 bytes in case of integer) = 7824 + 4 = 7828
when n=4
    arrayEnd = 7824 + 16 =  7840
+-------+
|  7840 |   6010 which is arrayEnd
+-------+

for (ptr = array; ptr < arrayEnd; ++ptr)
   sum += *ptr;

Here ptr is initialized with array's base address(7824). So 7824 will be stored in memory 6000.

  6000             6000    
+-------+        +-------+
|  GBV  |   =>   | 7824  |   6000 which is ptr
+-------+        +-------+

so now ptr = 7824

For Loop
+-------+--------------+-------------+    
|  ptr  |   *ptr       | sum + =*ptr |  // 7824 < 7840
+-------+--------------+-------------+
|  7824 | *(7824) = 1  |  sum += 1   |  // 7828 < 7840
+-------+--------------+-------------+
|  7828 | *(7828) = 2  |  sum += 2   |  // 7832 < 7840
+-------+--------------+-------------+
|  7832 | *(7832) = 3  |  sum += 3   |  // 7836 < 7840
+-------+--------------+-------------+
|  7836 | *(7836) = 4  |  sum += 4   |  // 7840 !< 7840 so loop terminates
+-------+--------------+-------------+ 

Why ptr = array instead of *ptr = array?

valueAt(*) has to be used when you have to store some value in the memory address.

ptr= array; //initializing base address of array to ptr.

  6000             6000    
+-------+        +-------+
|  GBV  |   =>   | 7824  |   6000 which is ptr
+-------+        +-------+

*ptr = array; // ptr already has a address pointed to, and you store array's base address inside that memory location.

  6000     
+-------+  
|  GBV  |    *ptr= *(GBV) = Unknown = array  // No guarantee that GBV is a proper memory address
+-------+  

if ptr already has some proper memory address say 1000, then it is like

  6000     
+-------+  
| 1000  |    *ptr= *(1000) = valueAt(1000) = array 
+-------+  

which makes

  1000     
+-------+  
| 7824  |    
+-------+ 

Simple example with multi pointers.

#include<stdio.h>
int main()
{
    int x=10;
    int *y=&x;
    int **z=&y;
    printf("%d --> %d --> %d",x,*y,**z); 
    return 0;
}

OUTPUT:
   10 --> 10 --> 10

Notice the asterisk meaning is different in definiton. when you write:

int *arrayEnd = array + n;

it is actualy the same as:

int *arrayEnd;
arrayEnd = array + n;

In both cases you initialize the address of the pointer and not the value referenced by the pointer

Also note that when you define an array the array name can be considered as the first memory location of the array while the number in brackets is its offset i.e. the next two lines are the same:

ptr = array;
ptr = &array[0];

and also the next two lines:

array[2] = 5;
*(array+2) = 5;

Funny fact about the last example is that it can explain you can sometimes write: 2[array] instead of array[2] as *(2+array) is the same as *(array+2)

So when you write:

int *ptr;
int array[4] = {1,2,3,4};
int *arrayEnd = array + n;

for (ptr = array; ptr < arrayEnd; ++ptr)
    sum += *ptr;

return sum;

the third line placed the memory address of the last array element in a variable called arrayEnd

the for loop is running from the first array location to the last array location

the sum adds the array elements