Why doesn't scanf() treat array and &array the same?

Question

I wrote this simple program

#include <stdio.h>

int main(void)
{
    int array[10];

    printf("sizeof(array):  %lu\n", sizeof(array));
    printf("sizeof(&array): %lu\n", sizeof(&array));

    printf("array:          %p\n", array);
    printf("&array:         %p\n", &array);

    printf("value:          ");
    scanf("%d", array); // 1
    //scanf("%d, &array"); // 2
}

Output:

sizeof(array):  40
sizeof(&array): 8
array:          0x7fffaab6f480
&array:         0x7fffaab6f480
value:          10

It compiles when I use 1. However, it doesn't when I use 2!

I get this compilation warning

warning: format ‘%d’ expects argument of type ‘int *’, but argument 2 has type 
‘int (*)[10]’ [-Wformat=]
  scanf("%d", &array);
  ^

although array and &array have the same value, they have different sizes (40 and 8 respectively) on my system.

On the other hand, this code

int array[10];
fread(&array, x, y, z);

compiles and works perfectly as

int array[10];
fread(array, x, y, z);

I noticed in the warning message that &array has the type int (*)[10]. Now what does that mean?

I also believe I have no troubles with fread() because it accepts a void *, but what about scanf()? How does it differentiate between pointer types?

And why doesn't it treat array as &array even though they're practically have the same value?

Answer 1

Arrays decays to pointers, so using the array as argument is the same as passing a pointer to the first element.

When you're doing &array, you get a pointer to the array (the int (*)[10] thing), and not a pointer to an integer.

Answer 2

With the scanf and printf family, you must pass the exact type that they expect (after the default argument promotions are applied - but that is not relevant in this example).

This is because the arguments correspond to a ... in the prototype, meaning that the compiler does not attempt to convert your argument to the expected type. If you use the wrong type you just get undefined behaviour.

This happens in the second case, scanf("%d", &array). As your examples show &array does not have type int *, therefore the behaviour is undefined.

In practice, it is likely to work anyway if your compiler uses the same representation for int * as it does for int (*)[10], which all modern compilers do AFAIK. But , of course, you should not rely on undefined behaviour, especially when there is an easy fix available.

In the fread example, it matches the prototype parameter void *. Therefore the compiler converts your argument to void *. Since the first element of an array is at the same memory address as the array itself, (void *)&array == (void *)array, even though array and &array have different types (and possibly even different representations), they both point to the same memory address.

Answer 3

Both are syntactically correct C, and do exactly the same thing, as you suggest. However, one is more correct than the other. That said, neither is perfect.

To be properly pedantic, you should have this:

scanf("%d", &array[0]);

.. because that's a pointer to an integer, array[0], and what you really want.

In fact, you can pass anything to scanf (if you ignore the documentation), and the compiler is expected to accept it (misuse of the standard library does not trigger an error, traditionally). If you pass something invalid then your program is expected to fail at runtime (or not, if you're lucky -- undefined behaviour is like that).

However, your compiler is trying to be helpful and interpret the scanf format string for you to make sure you did the right thing, but if you look carefully, it's not an error, its a warning. You're free to ignore it, if you choose.

The reason you don't get an error with fread is because that function does not take an integer, it takes void *, and both forms can be converted to that type just as easily.

Answer 4

First, your program was compiled very well - warning is not an error.

The warning message tells you that there's mismatch between format and type: "%d" format requires int *, but you sent &array, whose type is int (*)[10].

---

array is 10-length array of int. Its type is int [10]. However, array can be converted to pointer, that is, &array[0].

When you try to pass array to function, you actually pass a pointer, &array[0]. So both this code

printf("%d", array);
scanf("%d", array);

and this another code

printf("%d", &array[0]);
scanf("%d", &array[0]);

are the same.

Now let's look at another thing, &array. Its type is int (*)[10], that is, pointer to array.

Of course, the actual values of both &array[0] and &array are the same, but they have different types. So they're diferent things, as 'A' and 65 are different.

Altough it looks okay since the values are the same, I don't think it is such a good practice - Use array or &array[0].