Question about multidimensional arrays of strings
 

Hi,

I'd just like to know if the following two declarations to create an array of strings are equivalent to each other.


From my understanding, strings1 is an array of 5 pointers-to-char and strings2 is an array of 5 arrays of 21 char elements. In both cases, I see that they can both hold strings but strings2 can only hold a string with a max size of 20 characters whereas strings1 can hold variable length strings using dynamic memory allocation. I guess the better question is, can strings2 be equivalently expressed as strings1 and vice-versa?

Sorry if this sounds like such a noob question but my understanding on creating arrays of strings is kind of fuzzy.

>I guess the better question is, can strings2 be equivalently expressed as strings1 and vice-versa?
This is a subtle area of the language, but yes, strings2 can be equivalently expressed as strings1 and vice-versa.

This is another form of the old question about equivalence of pointers and arrays.

Although the language treats pointers and arrays as equivalent in some contexts (i.e. one can be used where the other one can) they are not exactly the same thing.

In the example;

char *strings1[5]; declares an array of five pointers. Those pointers are uninitialised, and it is necessary to make them point at something valid before they can be used.

char strings2[5][21]; is a two dimensional array of characters. strings2[i] (for i in the range [0, 4]) is a one-dimensional array of 21 characters. strings2[i], when used in an expression, is also a char * pointer.

The following expands on the example, with a few possible usages and comments about what happens;

If both are essentially equivalent. Isn't there still a limitation on strings2[5][21] where each one dimensional array should only be 20 characters long since the max element is 21? However *strings1[5] imposes no limitation on the length of the string since it's a point to another memory location.

Also is the following code correct?

[code]
int main(void)
{
char *strings1[5];
char strings2[5][21];

strings1[0] = "Hello"; //this will assign the beginning address of the Hello string to the first element?

strings2[0] = "Hello"; //invalid because strings2[0] is an array?
}

They are only equivalent in some contexts.

To understand what I mean with the underlined bit, consider the "strcpy(strings2[3], "Hello");" from my previous post.

The line "strcpy(strings2[3], "Hello");" actually passes two pointers to strcpy. Now, what does strcpy() do?

Two (notional) implementations are;
or
Apart from any errors I've inserted in the process of typing, these two versions given the same end result. However, the first version takes the pointers given, manipulates the characters being pointed to, and increments the pointers. In this way, the first version implicitly assumes that the pointers correspond to arrays. The second version explicitly treats the arguments as if they are arrays.

A hybrid version (which is also equivalent) is;
That is a side effect of declaring strings2 as a two-dimensional array as you have. The basic principle is that an n-dimensional array is an array of (n-1)-dimensional arrays. The so-called equivalence of arrays and pointers means that the name of an array can be used in some contexts where a pointer is expected, and that pointer notation can be used to access elements of an array. An equivalent (if backward) statement of this is that a pointer can often be treated as if it is an array.

strings2[i] is, according to your declaration, an array of char. "Hello" is also a (const) array of char. strcpy() accepts a pointer to char as first argument, and a const pointer to char as second argument. When you use strings2[i] in code after the declaration (eg in my previous example, a call to strcpy) those arrays may be implicitly manipulated as if they are pointers.

The declaration of string1 does not even require that the elements of string1 are strings at all. A pointer is allowed to point at anything. There is nothing preventing strings1[i] from pointing at a single char (which may not even be part of a string), and nothing preventing it pointing at the first element of a string of arbitrary size.

That depends on what you mean by "correct". The first assignment is valid but also dubious as "Hello" is actually a const string (which is why some compilers will issue a warning in this case). The second assignment will not compile, as the compiler has enough information to know strings2[0] is an array, and arrays cannot be reassigned.

Things get more interesting if you subsequently try to manipulate strings1[0], as "Hello" is implicitly const (i.e. it should not be modified).

As an exercise, try to explain why this code yields undefined behaviour;

Just to point out that if you declare an array like above, the array has 21 elements, not 20. From 0-20, including the 0 are all elements. Sorry if Grumpy already mentioned that.

You're right, it has 21 elements but only 20 can be used to store the string characters in this example which was what I was referring to.

Thanks for your time Grumpy. In your last example, strings[0] stores a pointer to "Hello" first. But I guess it's also a constant string (still not sure what the rules governing this are) which means strings[0] is not modifiable after that point?

Not quite. strings1[0] can be modified (in the sense that it can be reassigned to point at something else). The problem with assigning it to a string literal is that the string literal cannot be modified without invoking undefined behaviour.

So;

Alright, thanks for your help guys! Greatly appreciated.