const char **name VS char *name[] - c

Question

I know this topic was already discussed several times and I think I basically know the difference between arrays and pointer but I am interested in how arrays are exactly stored in mem.
for example:
const char **name = {{'a',0},{'b',0},{'c',0},0};
printf("Char: %c\n", name[0][0]); // This does not work
but if its declared like this:
const char *name[] = {"a","b","c"};
printf("Char: %c\n", name[0][0]); // Works well
everything works out fine.

Answer 1

When you define a variable like
char const* str = "abc";
char const** name = &str;
it looks something like this:
+---+ +---+ +---+---+---+---+
| *-+---->| *-+--->| a | b | c | 0 |
+---+ +---+ +---+---+---+---+
When you define a variable using the form
char const* name[] = { "a", "b", "c" };
You have an array of pointers. This looks something like that:
+---+ +---+---+
| *-+---->| a | 0 |
+---+ +---+---+
| *-+---->| b | 0 |
+---+ +---+---+
| *-+---->| c | 0 |
+---+ +---+---+
What may be confusing is that when you pass this array somewhere, it decays into a pointer and you got this:
+---+ +---+ +---+---+
| *-+---->| *-+---->| a | 0 |
+---+ +---+ +---+---+
| *-+---->| b | 0 |
+---+ +---+---+
| *-+---->| c | 0 |
+---+ +---+---+
That is, you get a pointer to the first element of the array. Incrementing this pointer moves on to the next element of the array.

Answer 2

A string literal converts implicitly to char const*.
The curly braces initializer doesn't.
Not relevant to your example, but worth knowing: up till and including C++03 a string literal could also implicitly convert to char* (no const), for compatibility with old C, but happily in C++11 this unsafe conversion was finally removed.

Answer 3

The reason the first snippet does not work is that the compiler re-interprets the sequence of characters as the value of a pointer, and then ignores the rest of the initializers. In order for the snippet to work, you need to tell the compiler that you are declaring an array, and that the elements of that array are arrays themselves, like this:
const char *name[] = {(char[]){'a',0},(char[]){'b',0},(char[]){'c',0},0};
With this modification in place, your program works and produces the desired output (link to ideone).

Answer 4

Your first example declares a pointer to a pointer to char. The second declares an array of pointers to char. The difference is that there's one more layer of indirection in the first one. It's a bit hard to describe without a drawing.
In a fake assembly style,
char **name = {{'a',0},{'b',0},{'c',0},0};
would translate to something like:
t1: .byte 'a', 0
.align somewhere; possibly somewhere convenient
t2: .byte 'b', 0
.align
t3: .byte 'c', 0
.align
t4: .dword t1, t2, t3, 0
name: .dword t4
while the second one,
char *name[] = {"a","b","c"};
might generate the same code for t1, t2, and t3, but then would do
name: .dword t1, t2, t3
Does that make sense?

Answer 5

Arrays are stored in memory as a contiguous sequence of objects, where the type of that object is the base type of the array. So, in the case of your array:
const char *name[] = {"a","b","c"};
The base type of the array is const char * and the size of the array is 3 (because your initialiser has three elements). It would look like this in memory:
| const char * | const char * | const char * |
Note that the elements of the array are pointers - the actual strings aren't stored in the array. Each one of those strings is a string literal, which is an array of char. In this case, they're all arrays of two chars, so somewhere else in memory you have three unnamed arrays:
| 'a' | 0 |
| 'b' | 0 |
| 'c' | 0 |
The initialiser sets the three elements of your name array to point to the initial elements of these three unnamed arrays. name[0] points to the 'a', name[1] points to the 'b' and name[2] points to the 'c'.

Answer 6

You have to look at what happens when you declare a variable, and where the memory to store the data for the variable goes.
First, what does it mean to simply write:
char x = 42;
you get enough bytes to hold a char on the stack, and those bytes are set to the value 42.
Secondly, what happens when you declare an array:
char x[] = "hello";
you get 6 bytes on the stack, and they are set to the characters h, e, l, l, o, and the value zero.
Now what happens if you declare a character pointer:
const char* x = "hello";
The bytes for "hello" are stored somewhere in static memory, and you get enough bytes to hold a pointer on the stack, and its value is set to the address of the first byte of that static memory that holds the value of the string.
So now what happens when you declare it as in your second example? You get three separate strings stored in static memory, "a", "b", and "c". Then on the stack you get an array of three pointers, each set to the memory location of those three strings.
So what is your first example trying to do? It looks like you want a pointer to an array of pointers, but the question is where will this array of pointers go? This is like my pointer example above, where something should be allocated in static memory. However, it just happens that you cannot declare a two dimensional array in static memory using brace initialisation like that. So you could do what you want by declaring the array as a variable outside of the function:
const char* name_pointers[] = {"a", "b", "c"};
then inside the function:
const char** name = name_pointers;