array -- foo, &foo and &foo[0]

[George2]

Hello everyone,


I think if we define foo as char array, for example,

char foo [32];

then foo, &foo and &foo[0] should be the same, right?

For example, the following 3 statements are the same,

strcpy (foo, goo);
strcpy (&foo, goo);
strcpy (&foo[0], goo);

Any comments?

I am very interested in how C treats foo and &foo and make them the same?


thanks in advance,
George

[MacGyver]

In terms of the how the computer hardware sees it, yes they are all the same, since they all resolve to the same address.

In C, however, there is a distinction between arrays and pointers. This distinction is more theoretical but applies for matching of datatypes in certain expressions and passing of data around to functions.

The value of all three expressions will be the same, however, in this case. The first is the array name and will be resolved as a pointer to the first element. The second one is the address of the array, which is resolved as a pointer to the first element. The last one is explicitly a pointer to the first element.

[George2]

I want to confirm with you that you think the three items are the same, MacGyver?

In terms of the how the computer hardware sees it, yes they are all the same, since they all resolve to the same address.

In C, however, there is a distinction between arrays and pointers. This distinction is more theoretical but applies for matching of datatypes in certain expressions and passing of data around to functions.

The value of all three expressions will be the same, however, in this case. The first is the array name and will be resolved as a pointer to the first element. The second one is the address of the array, which is resolved as a pointer to the first element. The last one is explicitly a pointer to the first element.

regards,
George

[iMalc]

The second one is not the same as the others. It is of type char (*)[32], i.e. it is a pointer-pointer, and is not the same as the other two, which are just direct pointers.

Proof: This compiles just fine:

if (foo == &foo[0]) {}

but this doesn't:

if (&foo == &foo[0]) {}

[maxorator]

If foo is declared as an array, not as a pointer, then they are the same. But if foo is declared as a pointer, then the second is the address of the pointer (pointer to the pointer). Proof of concept:

#include <stdio.h>

int main(int argc, char *argv[]){
    char* pointer=(char*)malloc(4);
    char array[4];
    printf("pointer = &#37;d, &pointer = %d, &pointer[0] = %d\n",pointer,&pointer,&pointer[0]);
    printf("array = %d, &array = %d, &array[0] = %d\n",array,&array,&array[0]);
    free(pointer);
    getchar();
    return 0;
}

Sample output:

pointer = 4007032, &pointer = 2293620, &pointer[0] = 4007032
array = 2293616, &array = 2293616, &array[0] = 2293616

[MacGyver]

I want to confirm with you that you think the three items are the same, MacGyver?

If you mean, "Do they all refer to the same address?" then yes.

If you mean, "Will my C compiler allow me to interchange those notations at will?" No. In terms of the type of the variable behind each notation, one or more might be different.

Experiment a bit with this stuff. It may be hard to find cases earlier on where the notation matters, but you'll probably start to notice it when you get into multidimensional arrays and passing them around into functions and such.

[dwks]

Err, maxorator? return is a keyword too, you know. Or did you only highlight data types like int?

I am very interested in how C treats foo and &foo and make them the same?

The only case in which your statement is true is when you're talking about function pointers, but that's another kettle of fish.

foo is the same as &foo[0] for any array, however. Or any pointer. Using pointer syntax, it's the same as &(*(foo + 0)), which is the same as &*foo, which is the same as foo when *foo is valid; i.e., it doesn't work for ints.

[robwhit]

    printf("pointer = %p, &pointer = %p, &pointer[0] = %p\n", (void*)pointer, (void*)&pointer, (void*)&pointer[0]);
    printf("array = %p, &array = %p, &array[0] = %p\n", (void*)array, (void*)&array, (void*)&array[0]);

[Dave Evans]

I am very interested in how C treats foo and &foo and make them the same?

It has been pointed out that these two items will have same value, however they are not the same.


For an array of "anything":

The name of the array used by itself (no [] brackets) is taken to be a const pointer to "anything", whose value is the address of the first element of the array.

Therefore if "foo" is an array of char, "foo" and "&foo[0]" are treated the same way: foo is a pointer to char, &foo[0] is a pointer to char. The notation for foo and &foo[0] is interchangeable.

However, if foo is an array of, say, 100 chars, then &foo is a pointer to an array of 100 chars. That is not the same as a pointer to char.

Consider the following:

#include <stdio.h>

int main()
{
    char foo[100];
    char *p1;
    char *p2;
    char *p3;
    char (*p4)[100]; /* a pointer to an array of 100 chars */

    p1 = foo;
    p2 = &foo[0];
    p3 = &foo;
    p4 = &foo;

    printf("p1 = &#37;p, p1+1 = %p\n", (void *)p1, (void *)(p1+1));
    printf("p2 = %p, p2+1 = %p\n", (void *)p2, (void *)(p2+1));
    printf("p3 = %p, p3+1 = %p\n", (void *)p3, (void *)(p3+1));
    printf("p4 = %p, p4+1 = %p\n", (void *)p4, (void *)(p4+1));

    return 0;
}

Now, with gcc, the assignment statement for p3 is flagged with a "warning: assignment from incompatible pointer type". Since it's only a warning, an executable is generated.

The output is:

p1 = 0xbfa160c0, p1+1 = 0xbfa160c1
p2 = 0xbfa160c0, p2+1 = 0xbfa160c1
p3 = 0xbfa160c0, p3+1 = 0xbfa160c1
p4 = 0xbfa160c0, p4+1 = 0xbfa16124

So, used this way, we can see that, indeed, the value of the value of the address of the array is equal to the value of the address of the first element of the array. (What else would it be?)

However---look at the result of pointer arithmetic for p4. The value of p4+1 is 100 (decimal) larger than the value of p4.

One further note:

If you try to compile this program with g++, the compiler flags the assignment statement for p3 with " error: cannot convert ‘char (*)[100]’ to ‘char*’ in assignment." and no executable is created. In other words, C++ is a little more picky about what it lets you do with pointers. (Requires an explicit reinterpret_cast. That's a good thing, right?) Removing the assignment and print statements for p3 results in a clean compile with gcc as well as with g++, and, of course, the results are the same.


Bottom line: Sloppy or unknowing C programmers who use "&foo" instead of "foo" or "&foo[0]" may actually get something that does what they want it to do (for example, strcpy() works the same), but why would you do such a thing, knowing what this simple example tells us? Namely that they are not the same, and, depending on how you use them, you could get different results.

D

[iMalc]

Yeah sorry, I was actually using a C++ compiler.

Nice summary Dave.