Dereferencing array pointer in a function

How do you deference a pointer to an array to get the value stored in it?

You use the * operator, as for every pointer. (Oh, and pay attention to operator precedence!)

void foo(int (*arr)[5])
{
    printf("%d\n", (*arr)[0]);
}

int main()
{
    int arr[5] = { 0, 1, 2, 3, 4 };
    foo(&arr);
    return 0;
}

Your code would have generated a diagnostic about an incompatible type being passed to the function. For example, GCC complains:

prog.c: In function 'main':
prog.c:9: warning: passing argument 1 of 'testFunction' from incompatible pointer type

You should pay attention to all diagnostics issued by your compiler, and make sure you understand them, and take the appropriate measures to address them. For this particular one, if you intend to pass in a pointer to an array, you need to write your function to accept such a thing. Then, when you dereference the pointer, you have an array. So, you access it like one.

void testFunction(int (*test)[10]){
  printf("%d", (*test)[1]);
}

The [] has higher precedence that *, so the parentheses are required both for the function parameter argument, and for accessing the value in the printf(). When the pointer to int[10] is derferenced, the resulting value is the address of the first element of the array test defined in main. The [] operation then access the 2nd element of the array, and you get the value you expected.

You may be more convinced that your use of int **test is wrong for a pointer to an array if you note that the assertion below will always be true:

int test[10];
assert(&test == (void *)test);

As the compiler warning indicates, a pointer to a pointer to int is not the same as a pointer to an int[10]. The type being pointed to determines the type that results from a dereference.

So:

int test[10] = { [1] = 5 };
testFunction(&test);

This passes the address of test to testFunction. The address of a variable corresponds to its location in memory. This is not so different for an array, but the location in memory for an array variable is the address of its first element. So, the address returned by &test above is the same address returned by test alone.

This gives a disastrous consequence when you treat this pointer value as a pointer to a pointer to int in your testFunction. First, note that you ignore proper operator precedence, so the first dereference is:

test[1]

Since you declare the test parameter to be a pointer to a pointer to int, this increments the address in test by sizeof(int *) and treats the result as an int *. Then, you dereference again:

*test[1]

This now takes the value of test[1] and dereferences it again in an attempt to get an int. However, the address returned by test[1] has no relationship with the array test defined in main, and you are accessing a totally nonsensical memory location.

Even if you paid attention to the precedence with your pointer to pointer to int parameter type, a similar problem would have resulted.

(*test)[1]

Now, the pointer to int[10] is treated as a pointer to pointer to int is derferenced first. This results in the first sizeof(int **) bytes of the test array in main to be treated as a pointer to int. This is already a nonsensical value at this point, but the array dereference now increments this value by sizeof(int) bytes and dereferences that value in an attempt to obtain an int.

The other user gave an example of how it is usually done already, but if you insist on passing an int ** then because of operator precedence the syntax would be like:

void testFunction(int **test){
  printf("%d", (*test)[1]);
}

int main()
{   int test[10];
    test[1] = 5;

    int *testptr= &test[0];  // or int *testptr= test;
    testFunction(&testptr);  // this passes an int **
    return 0;
}

But in c the name of an array is a pointer to the array elements, so int *ptrtest and ptrtest[1] is more commonly used.