Why is char*p[10] considered char** p by the compiler?

Question

I've been fiddling around to see if there's any way to retain information about an array's length automatically when passed into a function (see my other question here: Why is this array size "workaround" giving me a warning?), but my question is more about a warning that gcc is giving that doesn't make sense to me.

According to this website (EDIT: I misread the website), char *p[10] declares a pointer to a 10-wide array of chars. But when I tried to pass in a pointer to an array into a function, I got this error message from the compiler:

Here is the rest of the program:

I know that when an array is passed into a function, it decays into a pointer (losing information about its length), but it seems that the declaration itself is decaying. What's going on here?

EDIT: When I replace the char *p[10] with char (*p)[10], it doesn't give the warning anymore, and more importantly, it displays the proper array length: 10. I guess my questions are 1) Why do the parentheses change things? and 2) Is this a well-known workaround or am I relying on some behavior of the compiler that isn't guaranteed? (i.e. that array length info can be passed by indirectly passing in a pointer to it?)

Answer 1

In fact char *p[10] is an array, of length 10, of pointers to char. You are looking for char (*p)[10]. That is a pointer to an array, of length 10, of char.

You might find http://cdecl.org/ a useful resource to help you test your understanding of declarations.

Regarding the discussion surrounding dynamic arrays, you are going to have to accept that once you allocate an array dynamically, the system provides no means for you to recover the length of the array. It is your responsibility to remember that information.

Answer 2

The subject of your question has been answered already but I wanted to address the heart of it, which is "can I encode the length of an array in its type?" Which is in fact what a pointer-to-array does. The real question is whether you can actually gain any brevity or safety from this. Consider that in each scope where you have a declaration of your type, the length still needs to be known a-priori. To show you what I mean let's generalize your example slightly by making 10 a compile-time constant N.

#define N 10

size_t arraylength(char (*arrayp)[N]) {
    return sizeof(*arrayp);
}

int main(void) {
    char array[N];
    assert( arraylength(&array) == N ); //always true
}

So far so good. We didn't have to pass the length of array anywhere. But it's easy to see that anywhere the expression sizeof(*arrayp) is used, we also could have written N. And any place we declare a char(*)[ ], the bracketed length must come from somewhere.

So what if N isn't a compile time constant, and array is either a VLA or a pointer-to-array from malloc? We can still write and call arraysize, but it looks like this:

size_t arraylength(size_t N, char (*arrayp)[N]) {
    return sizeof(*arrayp);
}

int main(void) {
    size_t N = length_from_somewhere();
    char array[N];
    assert( arraylength(sizeof(array), &array) == N );
}

In defining arraysize N must still be visible before the declaration of arrayp. In either case, we can't avoid having N visible outside of the declaration of arrayp. In fact, we didn't gain anything over writing arraysize(size_t N, char* array) and passing array directly (which is a bit silly given the purpose of this function.) Both times arraylength could have equally been written return N;

Which isn't to say that array pointers are useless as parameters to functions -- in the opposite situation, when you want to enforce a length, they can provide type checking to make sure somefunc(char (*)[10]); receives a pointer to an array that is really (sans shady casting) 10 elements long, which is stronger than what a construct like [static 10] provides.

Also keep in mind that all of the length measurements above depend on the underlying type being char where length == size. For any larger type, taking the length requires the usual arithmetic e.g.

sizeof(*arrayp)/sizeof((*arrayp)[0])

Answer 3

In C, arrays decay to pointers to their first elements on most uses. In particular, what a function receives is always just a pointer to the first element, the size of the array is not passed with it.

Get a good text on C and read up on arrays.

Answer 4

I've been fiddling around to see if there's any way to retain information about an array's length automatically when passed into a function

The problem is so annoying that lots of programmers would love to have an answer. Unfortunately, this is not possible.

It seems that the declaration itself is decaying

Pointer to an array is not the same as a pointer to a pointer; that is why you are getting an error.

There is no decaying going on in your code, because you are not passing an array in your code sample: instead, you are trying to pass a pointer to an array &p. The pointer to an array of characters is not compatible to the expected type of the function, which is char**. Array size from the declaration is ignored.

Answer 5

You need to keep in mind two things:
1. Arrays are not pointers.
2. Array names decays to pointers (in most cases) when passed as arguments to functions.

So, when you declare

int a[10];  // a is an array of 10 ints
int *b;     // b is a pointer to int  

both of a and b are of different types. Former is of type int [10] while latter is of type int *.

In case of function parameter

void foo1 (int a[10]); // Actually you are not passing entire array 
void foo2 (int a[]);   // And that's why you can omit the first dimension.
void foo3 (int *a);    // and the compiler interprets the above two third  

ain all of the above function declarations is of same data type int *.

Now in your case

unsigned long arraySize(char *p[10]);  

you can declare it as

unsigned long arraySize(char *p[]);  

and hence

unsigned long arraySize(char **p);  

All are equivalent.

char *p[10] char *p[] and char **p all are exactly equivalent but when they are declared as parameter of a function otherwise char *p[10] (an array of 10 pointers to char) and char **p (a pointer to pointer to char)are entirely of different type.

Suggested reading: C-FAQ: 6. Arrays and Pointers explains this in detailed.

Answer 6

Array name itself is a constant pointer. for example int arr[10]={0}; arr contains the address of arr[0]. hence arr equals&arr[0] . when u pass the arraysize(&p) , you are actually passing a double pointer . The correct format to pass a array pointer would be arraysize(&p[0]) or arraysizeof(p)

Note Array name is constant pointer , you cant change its value . int arr[10]; arr++; is invalid.

In your case you cant find a size of an array in function by passing the array name . it would return size of pointer(4 or 8 depends on your processor . The method is to pass the size along with the array func(array_name , array_size);