Printable View
Hi all
I am a little confused about multidimensional arrays. Please look at this
Can you explain to me, why multidimensional arrays with characters must be defined like the above method? Why can't I just writeCode:char mda[][10] = {"one", "two", "three"};
i.e. char (mda[])[] = {...}, so an array, where each element is an array?Code:char mda[][] = {"one", "two", "three"},
When you index into a multi-dimensional array the compiler can't simply infer the offset into the data - it needs to know the dimensions a priori in order to calculate it. For example, let's say you want the character at mda[ 3 ][ 5 ]. The compiler has to know the distance between mda[ 2 ] and mda[ 3 ] before it can generate the offset. Without specifying the second dimension (eg: columns) this is essentially impossible. Consider now if you had declared it as char mda[][11]. When you ask for mda[ 3 ][ 5 ] the compiler calculates ( 3 * 11 ) + 5 and adds this to the base address of mda to locate the character.
Incidentally, you can declare an array of pointers if you don't want to fuss with the second dimension:
Just keep in mind that assigning a pointer to a string literal means that the data is read-only. If you need to write to the data, you'll need to allocate some memory to each pointer.Code:char const* mda[] = {"one", "two", "three"};
Thank you for replying. May I ask how you got to "( 3 * 11 ) + 5"?
Multidimensional arrays are laid out in order in memory, starting with [0][0], then [0][1], then [0][2], ..., [0][11], [1][0], [1][1], and so on. So every step in the first dimension is actually 11 steps (for your specific case) total to get through the entire row.
Ok, in that case it should be ( 3 * 11 ) + 6, and not + 5, right?
By the way, is a 1D-array a row of a column in C?
A row.
No? You don't have to move any to get to the first element, because, well, that's where you already are.Quote:
Originally Posted by Niels_M
No, arrays use 0-based indexes, so + 6 would set it to the past the element by 1.Quote:
Originally Posted by Niels_M
I see. Thanks.
When I pass a multidimensional array as a function parameter, then it is the address of the first element in the multidimensional array which is passed. In this case, this address points to an array (a row) as well.
So when we write e.g. f ( int (*a)[5]), then this means that *a is an integer pointer, which points to an array (a row) containing 5 integers (five colums)?
If the above is correct, then why is it that is it equivalent of writing f ( int a[][5])?
int (* a )[ 5 ] is a pointer to an array of an array of 5 elements (no, I am not repeating myself there!), if that makes sense. Had you declared it without parenthesis, it would have been an array of pointers to integers.Quote:
Originally Posted by Niels_M
But why is it that the compiler allows for the decleration f ( int a[][5] )? Is it because the compiler interprets the "a[]"-part as (*a)?Quote:
Originally Posted by Sebastiani
Yes. Consider a single-dimension array:
Now you could pass it to either of these functions:Code:double values[16];
So the functions essentially have the same signature.Code:void foo( double* data, size_t length )
{ }
void bar( double data[ ], size_t length )
{ }
Thank you. I have one last question, and it is related to the above.
The following is not permitted in C
since {1,2,3} is an initializer list, and *test is a pointer. In C we know that when a function is called, the copies of the arguments are made as if by assignment. In post #9 I wroteCode:int *test = {1,2,3} // not permitted
where *a points to an array with 5 integer elements. Thus we are actually writingCode:f ( int (*a)[5])
int (*a)[5] = {1,2,3,4,5}.
Now, how can this paradox be explained?
We do no such thing, so no paradox hereQuote:
Originally Posted by Niels_M
I know that, but we know (as I wrote) that when a function is called, the copies of the arguments are made as if by assignment. So essentially what we have isQuote:
Originally Posted by vart
Code:int (*a)[5] = {1,2,3,4,5}.
that's not the assignment operator, that's just the syntax of initialization.
Could you elaborate on that, please? I'm not quite following you.
Initialize:Quote:
Originally Posted by Niels_M
Assign:Code:int bob[] = {2,3,4};
The first makes sense, the second does not -- assignment can only happen element by element, not to the array-as-a-whole. Arrays are passed to function by pointer -- so your array[5][11] is passed as a pointer to an array of arrays of size 11, and we can assign a pointer value to a pointer variable no problem:Code:int bob[3];
bob = {2,3,4};
Indexing on ptr will work the same as indexing on array.Code:int array[5][11];
int (*ptr)[11]; //a pointer to array(s) of 11 integers;
ptr = array; //wonderful
here's the BNF for declarations in N1256 (C99 + TC1 + TC2 + TC3):Quote:
Originally Posted by Niels_M
there's a = character there, but it's not the assignment operator. it's just a = character.Code:declaration:
declaration-specifiers init-declarator-listopt ;
declaration-specifiers:
storage-class-specifier declaration-specifiersopt
type-specifier declaration-specifiersopt
type-qualifier declaration-specifiersopt
function-specifier declaration-specifiersopt
init-declarator-list:
init-declarator
init-declarator-list ,init-declarator
init-declarator:
declarator
declarator =initializer
Ok, so in C, when we have the follwing code
then when "testfnc" is called, the variable "b" is transfered to "testfnc" byCode:void testfnc(int a)
{
printf("%d", a);
}
int main()
{
int b = 5;
testfnc(b);
return 0;
}
and NOTCode:int a;
a=b;
?Code:int a=b;
I would say that the (formal) parameter a is initialised to be a copy of the (actual) argument b. There is no assignment involved, at least not in the way that has been mentioned in this thread.Quote:
Originally Posted by Niels_M
In the context of C (and not C++ classes) the two examples are essentially identical (compiler implementation details aside, at least). Some memory is set aside for the variable and then the data is copied to that address. Simple as that. As to why you can't assign to an array what you can initialize it with, well, that's just the way C works. And just to be clear, in this case:
The array is not copied, just a pointer to it.Code:void f(int (*a)[5])
Ok, the example was poorly chosen. In the case with arrays as parameters, then the difference is clear, just like in post #18.Quote:
Originally Posted by Sebastiani
Right.
hmm so you're right. I thought it was copied as if by assignment like the op said, but it seems it's only *converted* as if by assignment. it doesn't say how it's copied.Quote:
Originally Posted by laserlight
Copied, converted - what's the distinction being made there?
I have a final question. We have the following code
Here "test" will point at "one", and "test+1" will point at "two".Code:int main()
{
char* test[4] = {"one", "two"};
return 0;
}
When I write "*test", then I access the string "one", thus "*(*test+1)" will give us the value 'n'.
When I say "access", then what is it that we are doing? I think it has to do with pointers to pointers, but I cannot see how.
More accurately, test is an array of pointers to char, not a pointer. test+1 is a pointer, and it points to a pointer to the first character of "two".Quote:
Originally Posted by Niels_M
In the expression *test, test is converted to a pointer to its first element, i.e., a pointer to a pointer to char. Hence, *test is a pointer to a char, in particular, a pointer to the first character of "one". Hence, (*test+1) is a pointer to the second character of "one", thus *(*test+1) results in the value of the second character of "one", i.e., 'n'.Quote:
Originally Posted by Niels_M
By the way, since string literals should not be modified, you should declare test to be an array of const char* instead.
copying is making a duplicate value of another value. converting is taking a value of type A and giving a value of type B. I guess.Quote:
Originally Posted by Sebastiani
Maybe this will make it more clear:Quote:
Originally Posted by Niels_M
Code:int main( void )
{
typedef size_t*
address;
char const
* one = "one",
* two = "two",
* array[ ] =
{
one,
two
};
cout << "Address of '&array[ 0 ]': " << address( array ) << endl;
cout << "Address of '&array[ 1 ]': " << address( array + 1 ) << endl;
cout << "Address of 'one': " << address( one ) << endl;
cout << "Address of 'two': " << address( two ) << endl;
cout << "Value of 'array[ 0 ]': " << address( array[ 0 ] ) << endl;
cout << "Value of 'array[ 1 ]': " << address( array[ 1 ] ) << endl;
return 0;
}
Yes, but isn't that basically saying the same thing? I'm not trying to be difficult here - I just don't see any difference, really.Quote:
Originally Posted by robwhit
the way I see it, copying doesn't imply a change of types, and conversion does. also, linguistically, I'd guess that conversion suggests in-place conversion, but it doesn't really work like that in C... if you're only talking about temporary values, you might see it that way.
Right, but then how is int->int a conversion?
it's not, afaik.
Ok, so we're basically talking about specific wording in the standard, then - correct? If so, you'll have to forgive my ignorance - I'm a software engineer, not a language expert. :p
I'm just going by my understanding... I'm no expert either... I'm wrong fairly regularly. ;)
Well that clears it up. :D
lol I walked into that one.
Hi
I have a final question (I've said that quite a few times, but hopefully I will mean it this time!).
We have
The address "array" is the address if the first array in "array[5][11]". How is this stored in memory?Code:int array[2][2] { {1,2}, {3,4} };
int (*ptr)[2];
ptr = array;
I mean, it is not like with string literals, since it is an initializer. So how does it work?
The array here has nothing to do with either 5 or 11. You have space for four integers, and that space has been filled with the integers 1, 2, 3, and 4. (Just like with the previous two-dimensional array, the values are stored in order across and then down: [0][0], then [0][1], then [1][0], then [1][1].)
Uf, the [5][11] was an error - it should of course have been [2][2].
But how can an array have an address as a whole? It must have one, since it is passed to ptr.
Every object has an address, which is where it is stored. An array is no different -- it has four constituent objects, yes, but the array itself lives somewhere and that is its address. So array and array[0] and array[0][0] share the same address, because they all start at the same place.Quote:
Originally Posted by Niels_M
If I use
then what is the difference between asd+1 and *(asd+1)? The first is the address of the {3,4,5}-array, and *(asd+1) "accesses" the array or what?Code:int asd[2][3]={{1,2,5},{3,4,6}};
When you declare an array of any dimension, the compiler sets aside a block of contiguous bytes, and uses the array name as a reference to the first element. So for example:
The compiler allocates 3 * 4 * sizeof( size_t ) bytes on the stack, and since the array name is an reference to the first element, then ( ( size_t* )data ) == &data[ 0 ][ 0 ]. And because we're dealing with an array of arrays, ( ( size_t* )( data + 1 ) ) == &data[ 1 ][ 0 ]. Maybe this will make it more clear:Code:size_t
data[ 3 ][ 4 ];
Code:#include <stdio.h>
#include <stdlib.h>
int main( void )
{
size_t
data[ 3 ][ 4 ] =
{
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 }
},
size_in_bytes = sizeof( data ),
number_of_elements = size_in_bytes / sizeof( size_t ),
rows = size_in_bytes / sizeof( data[ 0 ] ),
columns = number_of_elements / rows,
row,
column;
printf( "size_in_bytes: %d \n", size_in_bytes );
printf( "number_of_elements: %d \n", number_of_elements );
printf( "rows: %d \n", rows );
printf( "columns: %d \n", columns );
printf( "address of data: %x \n", ( size_t* )data );
printf( "address of data + 1: %x \n", ( size_t* )( data + 1 ) );
for( row = 0; row < rows; ++row )
{
for( column = 0; column < columns; ++column )
{
printf
(
"<%x> data[ %d ][ %d ] = %d \n",
&data[ row ][ column ],
row,
column,
data[ row ][ column ]
);
}
}
return 0;
}
I am still unclear about it. I am used to that data+1 is the address of element #2, and that *(data+1) is the value.
In this case, *(data+1) is the same address as data+1. I cannot see why.
Right, well this is a two-dimensional array, so the second 'element' is an array, namely the one that starts at &data[ 1 ][ 0 ]. So then ( data + 2 ) == &data[ 2 ][ 0 ], and so on.Quote:
Originally Posted by Niels_M
(asd+1) points to the 2nd element of asd ie asd[1] itself an arrayQuote:
Originally Posted by Niels_M
*(asd+1) points to the first element of the array asd[1] ie asd[1][0]Code:(asd+1) = &asd[1];
Code:*(asd+1) = &asd[1][0];
%p is the correct format for pointers, and it expects a void pointer. Alternatively, cast to unsigned, and continue to use %x.Quote:
Originally Posted by Sebastiani
Using the wrong format specifiers for printf is undefined behavior.
That is what I meant by "accessing" the array. But OK, I guess this is just how it is with 2D-arrays.Quote:
Originally Posted by itCbitC
I just thought there was a logical explanation like there is with string literals, i.e. that in, then test[0] points to the first character in the string literal "hi" etc..Code:*test[] = {"hi", "mi"}
I think the difference here (if there is a difference here, which I'm not entirely convinced thiere is) is that in your test array the strings hi and mi live god knows where -- the values in the array are pointers to somewhere else, while in a 2D array there are no pointers involved anywhere (excepting the conversion of the name of the array to a pointer when used by itself). So your test array might store 0x403000 and 0x403003, while if you didQuote:
Originally Posted by Niels_M
your test2 array will store 'h', 'i', 0, 'm', 'i', 0 -- no pointers anywhere. (Now test2[1], by itself, is the name of an array, so it will be converted to the address of the beginning of the second "row" of your array.)Code:char test2[2][3] = {"hi", "mi"};
EDIT: Or perhaps you're misunderstanding "second element". test2[1] is the second element of the test2 array -- which is to say, it is the second row/string/whatever you want to call it. It is not the second character stored, which is the second element of the first element of the array.
Not sure what you mean by the above statement :confused:Quote:
Originally Posted by Niels_M
Yep there is a logical explanation but there is a big difference here. test[] is an array of pointers to string literals, whose each element is a pointer to an array of characters. Alternatively each element of test can point to a single character but that is a huge waste of memory. It is like having an array of characters with a pointer to each of its element - utterly wasteful.Quote:
Originally Posted by Niels_M
A 2D array (or any multidimensional array) in C is really a 1D array. So even tho' asd[2][3] is a 2D array, it helps to think in terms of rows and columns but inside the machine it is laid out as one big row of storage cells.
The same is true for 2D arrays; asd[0] points to the first integer of the array asd[0]Quote:
Originally Posted by Niels_M
Code:asd[0] = &asd[0][0]; /* points to the number 1 */
Ok, I think I understand it now. We haveQuote:
Originally Posted by tabstop
Here (testarr+1) is the address of "everybody", and thus *(testarr+1) is the "name" of the array, and thus the address of the first element. Thus *(*(testarr+1)+1) gives us a 'v'.Code:char testarr[][25] ) {"thanks", "everybody"}