2

This question may seems quite duplicated; however, I indeed have had a serious survey on this site and still cannot quite understand.

    char str[] = "test";
    printf("%p\n", str);
    printf("%p\n", &str);

I know str itself is a pointer which points to the starting location that stores "t". Therefore I expect that printf("%p\n", str); shows this address (say 000000FFE94FFC34). Next, I wish to know in my OS, at what memory location that stores the exact information 000000FFE94FFC34. (i.e. the address of str itself.)

However, the output of the third line is the same as the previous one. It seems quite a weird behavior. And how can I figure out the address of str itself? I guess this can be achieved by using another new pointer that points to the pointer I want, i.e. char **super_pointer = str; but I think it is an unnecessarily complicated way.

Vlad from Moscow
  • 301,070
  • 26
  • 186
  • 335
Eric
  • 185
  • 7

2 Answers2

3

Lets draw it out with the pointers added, to hopefully make it simpler to understand:

+--------+--------+--------+--------+--------+
| str[0] | str[1] | str[2] | str[3] | str[4] |
+--------+--------+--------+--------+--------+
^
|
&str[0]
|
&str

As you can see the pointer to the first element (&str[0] which is what plain str decays to) points to the same location as the array itself (&str).

But (and it's an important but): The type are very different!

The type of &str[0] is char *.

The type of &str is char (*)[5].

On another note you say that

... str itself is a pointer...

This is wrong. str itself is the array, which can decay to a pointer to its first element.

Some programmer dude
  • 400,186
  • 35
  • 402
  • 621
  • Can I print the memory location where the OS stores the "address" of `&str[0]` or `&str`? – Eric Oct 09 '21 at 06:35
  • @Eric The expression `&str` results in an *rvalue* which doesn't have to be stored anywhere. `str` and `str[0]` are stored in memory, the results of expressions isn't. – Some programmer dude Oct 09 '21 at 07:14
  • @Someprogrammerdude such a common dupe – 0___________ Oct 09 '21 at 07:39
  • Thanks. By the way, I wonder what will happen if I write `char *ptr=&str`. Actually I should use `char (*ptr)[5]=&str`. But how if I use a more little type `char` to interpret a bigger size `sizeof(char)*5`? Will `ptr++` make any sense? – Eric Oct 09 '21 at 15:58
  • 1
    @Eric `char *ptr=&str` is incorrect, just don't do it. – Some programmer dude Oct 09 '21 at 18:37
  • I see. Can I use type casting (perhaps something like `char *str=(...)&str`)? Is that legal? (Just wonder for a solid understanding!) Because I used to cast a `uint64_t` array to `uint8_t` before calling a function with `uint8_t` argument (can work, until now...). I hope I did it properly. – Eric Oct 10 '21 at 02:18
  • 1
    @Eric This is turning too much into an [XY problem](https://meta.stackexchange.com/questions/66377/what-is-the-xy-problem)... Please post a new question where you detail the actual and underlying problem you try to solve, and tell us why you think using the wrong type of pointer would solve that problem. – Some programmer dude Oct 10 '21 at 05:22
2

I know str itself is a pointer which points to the starting location that stores "t".

As you wrote "str itself" is not a pointer it is an array. But used in expressions array designators with rare exceptions are converted to pointers to their first elements.

From the C Standard (6.3.2.1 Lvalues, arrays, and function designators)

3 Except when it is the operand of the sizeof operator or the unary & operator, or is a string literal used to initialize an array, an expression that has type ‘‘array of type’’ is converted to an expression with type ‘‘pointer to type’’ that points to the initial element of the array object and is not an lvalue. If the array object has register storage class, the behavior is undefined.

In this call

printf("%p\n", str);

the array designator str used as an argument expression is converted to a pointer to its first element. In fact this call is equivalent to

printf("%p\n", &str[0]);

That is this call outputs the starting address of the extent of memory occupied by the array.

This call

printf("%p\n", &str);

that is better to write as and the previous call like

printf("%p\n", ( void * )&str);

also outputs the starting address of the extent of the memory occupied by the array.

What is the difference?

The expression str used in the call of printf has the type char * while the expression &str has the type char ( * )[5].

The both expressions is interpreted by the call as expressions of the type void *.

To make this more clear consider a two dimensional array

char str[2][6] = { "test1", "test2" };

The addresses of the array as whole and of its first "row" and of its first character of the first "row" are coincide.

That is the expression &sgtr that has the type char ( * )[2][6] and the expression &str[0] that has the type char ( * )[6] and the expression &str[0][0] that has the type char * yield the same value: hhe starting address of the extent of memory occupied by the array..

Vlad from Moscow
  • 301,070
  • 26
  • 186
  • 335