What's the difference between char ** and char (*)[100] in C?

Question

I have a string located in an array of chars, and I want to parse it and increment the pointer. So I created a func that gets a (char **) as an argument, and when I pass &str there's an error - so I declared a pointer to this array, and passed &p - and it worked.

Now I'm wondering why it didn't work with the array.

For example:

void func(char **str);

int main()
{
    char str[100] = {'\0'};
    char *p = str;
    func(&str);  // vs func(&p); 
}

the error is:

test2.c:194:29: error: passing argument 1 of ‘PrintVariables’ from incompatible pointer type [-Wincompatible-pointer-types]
  194 |       size = PrintVariables(&line, size);
      |                             ^~~~~
      |                             |
      |                             char (*)[100]
  

I'm trying to understand the difference between char ** and char (*)[100], because obviously these are different types, and I don't understand why and what is the use case for each.

Answer 1

char ** is a pointer to a pointer to char; char (*)[100] is a pointer to an array of 100 elements of char. The parentheses are needed because char *[100] would be an array of 100 pointers to char.

In your code, str is of type char [100]. In the statement char *p = str;, str first automatically decays to type char * and then gets assigned to p (also of type char *). Hence &p is of type char **.

Note that writing func((char **)&str); (in order to please func) would be problematic:

1. &str is of type char (*)[100]. That is, it is a pointer to char [100] (array [100] of char), and it is as large as the address of an object of type char [100] needs to be. This is standardly the same as sizeof(void *), and in most cases all pointers have this size, but according to the standard, this doesn't absolutely have to be the case. Here specifically, pointers to char [100] and pointers to char * needn't be compatible. Hence, casting char (*)[100] to char ** doesn't necessarily work.
2. str is char-aligned (1-aligned), while anything of type char * has stronger pointer-based alignment requirements (say, 4 or 8) [credit to Petr Skocik]. Hence, &str can be any address, while an address of type char ** would need to be divisible by 4 or 8. Therefore, casting &str to char ** is a non-starter. Conceptually, such a cast implies that the result can be dereferenced twice.
   • After the initial dereferencing of &str, we get str, which (being of type char [100]) is a 1-aligned object and decays to &str[0] (the address of the first char in str). Further dereferencing gives us the bare initial char str[0].
   • But for the hypothetical expression (char **)&str (and assuming alignment wasn't an issue for this cast), initial dereferencing would give us *(char **)&str, which would point to the beginning of the string (char [100]) but nominally be of type char *. For further dereferencing, we would need to interpret the 4 or 8 bytes starting from that address as the address of another char, which is unlikely to succeed and semantically not what we want anyway. (Because char * is not an array type, there is no decay to another pointer (pointing to the same address) that lets us dereference things further, like we could do repeatedly for a multidimensional array.)

Two methods work:

• Using p and func(&p); (from your code) works fine.
• An alternative [credit to Petr Skocik], is to use a compound literal, (char *){str}, in the function call func( &(char *){str} );. Even though (char *){str} looks like a cast, it is not; it is an anonymous object of type char * initialized to str. It is legal to take the address of a compound literal. That is, this is like using an anonymous kind of p.

Compound literals are described in section 6.5.2.5 of the C17 standard draft. They exist since C99.