const char ** x和const char * x []如何相似？

Question

I have a hard time understanding or finding a simple explanation of what const char** x is and how to use it?

I kind of understand that char* x[] is an array of char pointers.

One explanation for the char** x I found says that "they are variable pointers to an array of variable pointers to const chars ".

I am confused. Is x an array of pointers or just one pointer that points to an array of pointers?

Answer 1

If I wrote T *x , you'd understand that, I assume? x is simply a pointer to an object of type T . And that object may be the first element in an array of T . Whereas T x[10] really is an array of 10 T .

In your case, T is const char * . So x is a pointer to a const char * .

Answer 2

[] it mostly a shortcut for declaring arrays of thing, and not really a type. It is used when declaring the elements of the array, or specifying how many "slots" that array have.

But C don't handle entire arrays as if it was one single thing, so the resultant variable you get from that operation is a char * pointer pointing to the first element of that array, so that char x[] and char *x is somewhat implied of being the same type.

When declaring char x[] = "string"; , for instance, x is a variable of type char * that points to the first element of the array, x[0] which value is 's' .

You can reapply the concept to a matrix or an array of arrays, which is the same as a pointer to a collecion of pointers.

So while char *x may be a string, char **x may be a list of strings.

Answer 3

for every type you use * it is a pointer to that type. it might point to one element or to the first element (at the first time you assign it) of a sequence of elements on the memory. with a pointer you can use pointer arithmetik for example x++ to navigate to the next element, you can also use the index operator x[1] on it. pointer arithmetik cannot be applied to a const pointer, witch is obvious since you declared it to be constant.

for every type you use [] it is an array. with an array you cannot use pointer arithmetik, only the the [] operator lets you access the elements of an array.

you can say that a const pointer is similar the an array when it comes to accessing element.

Use array when you know at compile time what size it should have. these will reside on the stack.

Use pointers when you have to allocate memory at runtime or you wich to use pointer arithmetik. memory allocated at runtime resides on the heap.

here a lecture that might help you understand better.

I hope i didn't tell any mistakes, it's been a while since i used C the last time :/

Answer 4

Here's one example:

char ch;
char *pch = &ch;
char **ppch = &pch;

In this case, no array is involved.

There is one variable that holds a character ( ch ).

Then there is one variable that holds a pointer ( pch ). This is simply an address of a location in memory that holds data. But the compiler and the programmer are also interested in the type of the value that is stored in that location (for example, to know how many bytes it takes, or which operations are allowed on that value). So the pointer has a type that is related to the type of the value it's pointing to. In this case, pch is pointing to a character value, so the type is char * .

And then there's another variable that holds a pointer ( ppch ). Again it's just an address of a location in memory, but this time the value that is stored in that location is a pointer. So there are two pointers involved, ppch and the pointer it's pointing to. Both pointers have a type. ppch is a char ** - pointer to a pointer to char. The value it's pointing to is a char * - pointer to a character.

A pointer can point to a single value, but in some cases it's also useful if there is a sequence of values with the same type (an array). In that case, the pointer can point to any of the values in the sequence, and using pointer arithmetic it can be changed to point to other values in the same sequence.

So just like char * is a pointer that can point to a character, it can also point to any value in a sequence of a characters, and in many cases it's useful if it points to the first value in the sequence.

char ** points to a char * value, which again can be a single value or one of many in a sequence of values (and more specifically, the first in the sequence).

This is NOT the same as char *array[] which is the actual sequence of pointers. The difference is important:

char *pointers[5];
char **pp;

Here, char *pointers[5] is an array of 5 pointers. It's the actual sequence. sizeof(pointers) is 5 times the size of a single pointer.

But pp is just a pointer - it's a variable that holds a single pointer, and sizeof(pp) is the size of a single pointer. As it's a pointer to pointer, it can also point to the first element of pointers (or to any other char * value, including other elements of pointers ).

Now there's only the question of const . This only affects the type that it appears with (this is a bit confusing, because C allows different orders, and const char is the same as char const ). So const char **pp is a non-const pointer (meaning the pointer can change) to a non-const pointer (so that pointer can also change) to a const char (meaning that the value of the character cannot be modified by pp ).

So pp itself can be changed by the program - it can point to different pointers. The pointer that it's pointing to can also change - it can point to different characters. But the characters themselves cannot be changed using pp .

For a reasonable example, we need a few const char pointers, and a few characters to point to. The easiest way to get those is to use arrays:

char seq1[5] = { 'a', 'b', 'c', 'd', 'e' };
char seq2[3] = { 'x', 'y', 'z' };
const char *p1;
const char *p2;
const char **pp;

p1 = &seq1[0]; /* valid, same as p1 = seq1 */
p1 = &seq1[3]; /* valid */
*p1 = 's';  /* invalid - the character that p1 points to cannot be changed by p1 */
p2 = seq2;  /* valid */
pp = &p1;  /* valid */
*pp = &seq1[2];  /* valid - pp is a non-const pointer, so the value it points to can change */
pp = &p2;  /* valid - pp itself is non-const */
**pp = 't';  /* invalid - same as *(*pp) which is *p2 which is const when accessed by pp */

Note that the meaning of const is not that the value cannot ever change, but that it cannot be changed by the const variable (or the const pointer). The following example should clarify:

char ch;
char *pch = &ch;
const char *cpch = &ch;

ch = 'a';  /* fine - ch is not const */
*pch = 'b';  /* fine - pch does not point to a const value */
*cpch = 'c';  /* invalid - cpch points to a const value */