Difference between char array and pointer to char array

Question

While reviewing my code I realized I had placed an extra & while passing a char array to strcpy and missed the resulting warning; regardless, everything worked as expected. I then reproduced the behavior in this example:

#include <string.h>
#include <stdio.h>

void main() {
    char test1[32] = {0};
    char test2[32] = {0};

    strcpy(test1, "Test 1\n");
    strcpy(&test2, "Test 2\n");

    printf(test1);
    printf(test2);
    printf("%i %i\n", test2, &test2);
}

Here I copy a string to the address of test2 and the compiler complains accordingly:

main.c: In function ‘main’:
main.c:9:12: warning: passing argument 1 of ‘strcpy’ from incompatible pointer type [-Wincompatible-pointer-types]
    9 |     strcpy(&test2, "Test 2\n");
      |            ^~~~~~
      |            |
      |            char (*)[32]
In file included from main.c:1:
/usr/include/string.h:125:39: note: expected ‘char * restrict’ but argument is of type ‘char (*)[32]’
  125 | extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
      |                      ~~~~~~~~~~~~~~~~~^~~~~~

However the code is still compiled and the result seems to ignore the second level of indirection. Even when printing the address &test2 it is the same as simply test2.

./a.out 
Test 1
Test 2
-1990876288 -1990876288

I must admit this is a part of the C language that completely escapes me. Why is the & operand seemingly ignored when targeting an array?

The & is not ignored but as the compiler says it points to a different type char (*)[32]. However, the actual address is the same, in this case, but if char test2[32] were a function argument, it would not be. An array decays to a pointer to its first element anyway, but in this case taking the address would be the location of the function argument, not the array itself. — Weather Vane
– Weather Vane, Commented Mar 13, 2021 at 14:39

Eric Postpischil · Accepted Answer · 2021-03-13 14:53:34Z

The first byte of the first element in the array is at the same place as the first byte of the array, because they are the same byte.

Most C implementations use the memory address, or some representation of it, of the first byte of an object as a pointer to the object. The array contains its elements, and there is no padding: The first element of the array starts where the array starts. So the first byte in the first element is the first byte in the array. So they have the same memory address.

There is a rule in C that converting a pointer to an object to a char * produces a pointer to the first byte of an object (C 2018 6.3.2.3 7). So, given an array a, (char *) &a[0] is a pointer to the first byte of the first element, and (char *) &a is a pointer to the first byte of the array. These are the same byte, so (char *) &a[0] == (char *) &a.

However, &a[0] and &a have different types. If you attempt to compare them directly with &a[0] == &a, the compiler should issue a warning that the types do not match.

If you pass &a as an argument to a routine that expects &a[0], it will often work in most modern C implementations because they use plain memory addresses as pointers, so &a is represented with the same bits (a memory address) as &a[0], so the receiving routine gets the value it expected even though you passed a pointer of the wrong type. However, the behavior of your program will not be defined by the C standard, since you have violated the rules. This was more of a problem in older C implementations when memory models were not simple flat address spaces, and different types of pointers may have had different representations.

Adrian Mole · Accepted Answer · 2021-03-13 14:53:12Z

Your code works in this case because, once the pointer argument (with or without the extra &) gets to the strcpy function, it is interpreted as a simple char* value. Thus, any pointer arithmetic (such as the likely increments) performed in that function will be correct.

However, there are cases where using a pointer-to-char and pointer-to-array-of-char will yield significantly different results. Pointer arithmetic is such a case: if p is a char* variable, then ++p will add the size of a char (i.e. 1) to the address stored in p; however, if q is an array of char* pointers, then ++q will add the size of a pointer to the address in q. And, if r is the address of an array of character strings, then ++r will add the size of the entire array to the address stored in r.

So, it's good that the compiler warns you about that extra &. Be very careful about addressing (no pun intended) such issues, if ever your compiler warns you about them.

chux · Accepted Answer · 2021-03-13 15:48:35Z

1

Why is the & operand seemingly ignored when targeting an array?

The conversion of char (*)[32] to char * is UB.

Is is not ignored by the compiler, hence the warning.

The compiler emitted code did convert the pointer from one type to the other in a common fashion resulting in acceptable behavior. Still remains UB.

Best if the programmer does not ignore the warning.

answered Mar 13, 2021 at 15:48

community wiki

chux

Collectives™ on Stack Overflow

Difference between char array and pointer to char array

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related