why the following output? - c

Question

I am using gcc and written a small program as under:
#include<stdio.h>
void doing(){
char buf[4096 + 1];
printf("buf %d\n", buf);
printf("buf %f\n", buf);
printf("buf %d\n", (unsigned) buf);
printf("buf %s\n", buf+2);
printf("buf %d\n", buf+2);
}
int main (void){
char buf[4096 + 1];
printf("(unsigned) buf %d\n", (unsigned) buf);
doing();
printf("(unsigned) buf %d\n", (unsigned) buf);
return 0;
}
The Output of the program is:
(unsigned) buf 2268303
buf 2264159
buf 0.000000
buf 2264159
buf
buf 2264161
(unsigned) buf 2268303
I don't know why printing 2268303 as integer and where from this 2268303 value comes and one function is giving the value as 2268303 and another 2264159

Answer 1

Let's break it down a bit and see what we can say about each line of code, one after the other:
int main (void){
char buf[4096 + 1];
You declare a char[4097], that is typically allocated on the stack by adjusting the stack pointer when main is entered. The contents of the array are indeterminate.
printf("(unsigned) buf %d\n", (unsigned) buf);
An expression of array type, unless it is the operand of the address (&), sizeof or _Alignof operators, or it is a string literal used to initialise a character array, is converted to a pointer to the array's first element (6.3.2.1 p. 3), so that line is equivalent to
printf("(unsigned) buf %d\n", (unsigned) &buf[0]);
takes the address of the first byte in buf, converts it to unsigned and prints the resulting number as a signed integer. Note that the behaviour is undefined if the resulting unsigned value is not representable as an int. The conversion of the pointer &buf[0] to unsigned is implementation-defined, and may invoke undefined behaviour (6.3.2.3 p. 6). Typically, sizeof(unsigned) bytes of the pointer value are interpreted as an unsigned integer (typically includes that the size of a pointer is not smaller than the size of an unsigned). In your case, the result was that
(unsigned) buf 2268303
was printed. Next
doing();
So let's look at doing:
void doing(){
char buf[4096 + 1];
Another char[4097] is declared, typically it is allocated by adjusting the stack pointer when doing is entered. The contents of this array are also indeterminate.
printf("buf %d\n", buf);
Again, the expression buf of type char[4097] is converted to a char*, namely &buf[0], and that is passed to printf which expects an int argument. The type mismatch invokes undefined behaviour, commonly sizeof(int) bytes of the pointer value are interpreted as a signed integer. The result is the ouptut
buf 2264159
which strongly hints that the buf in doing was allocated 4144 bytes away from main's and the stack grows downward.
printf("buf %f\n", buf);
Once again we have the array-to-pointer conversion, and now printf expects a double argument but gets a char*. More undefined behaviour, the manifestation is that
buf 0.000000
is printed. How that comes cannot be answered in general (after all, it's undefined behaviour), on 64-bit systems, a common behaviour is that printf arguments of pointer or integral types are passed in general purpose registers, and floating point arguments in floating point registers, so that printf would read a floating point register - which happens to contain a 0 value.
printf("buf %d\n", (unsigned) buf);
This line has the same semantics as the corresponding line of main, but since it's a different array buf, the (unsigned) integer obtained from the conversion is different.
buf 2264159
it prints the same as the first printf in doing, which is not surprising (but not guaranteed, since undefined behaviour is involved).
printf("buf %s\n", buf+2);
buf is converted to &buf[0], then 2 is added to that, resulting in &buf[2]. That is passed to printf, which, due to the %s conversion expects a pointer to a 0-terminated array of char as argument. This is the only printf call in the entire programme where the type of printf's second argument matches the type expected due to the conversion specifier exactly. But the contents of buf are indeterminate, so if there is no 0 byte in the array, that will cause invalid reads by printf. However, apparently buf[2] was 0, so just
buf
was printed.
printf("buf %d\n", buf+2);
buf + 2 again evaluates to &buf[2], and that is passed where printf expects an int. The type mismatch invokes undefined behaviour, but the output
buf 2264161
suggests that nothing nefarious happened, and since &buf[2] is two bytes behind &buf[0], the number printed is two larger than the number printed in doing's first printf.
}
Back to main:
printf("(unsigned) buf %d\n", (unsigned) buf);
That line is identical to the first printf call in main, so it has the same semantics, that was discussed above,
(unsigned) buf 2268303
and produces the same output.
return 0;
}

Answer 2

Please read C Basics. You will get your answer.
Regarding,
one function is giving the value as 2268303 and another 2264159
Observe that, one char buf[] is declared in main() and another one is in doing(). Both have different storage and both will work in their own scope. [Read Scope of variables in C]

Answer 3

If you use %p you will get hex values.
You also need to brush up on scope as well. Go through these links too.
(unsigned) buf 2268303 // You have defined this in main its a local array so it has
//2268303 as address. And for an array the array name acts as a
//pointer too
buf 2264159 // You have defined this in fn doing, it is local to that function
//and has a different address (it is a different array than the one
//in your main)

Answer 4

Here's the explanation:
This:
printf("buf %d\n", buf);
will print the address(memory position) of the first element on your "buf" array
This:
printf("buf %f\n", buf);
will try to read a float from the address of the first element on your "buf" array, printf probably returns zero because it doesn't know what to do with it.
This:
printf("buf %d\n", (unsigned) buf);
will do the same as the first printf since the address of "buf" is always greater or equal than zero.
This:
printf("buf %s\n", buf+2);
will try to read a float from the address of the first element on your "buf" array, printf probably returns an empty string because it doesn't know what to do with it.
Finally:
printf("buf %d\n", buf+2);
returns the position off the third element in you "buf" array
Important to notice:
the two "buf" arrays you declared (one inside main, the other inside doing()) are two distinct arrays even though you gave them the same name.
Inside doing() "buf" refers to the one you created there, inside main "buf" also refers to the one you created there. Thats the reason why you get two different addresses when printing from inside doing or main