What is real meaning behind this easy printf output in c?

Question

look at the two line c code and output: code:

char * str = "hello world!";
printf("h at heap memory address: %p\n",str);
printf("str pointer stack memory address: %p\n",&str);

and output:

h at heap memory address: 0x4008a8
str pointer stack memory address: 0x7ffc9e7ceb90

the memory address length for heap and stack is 0x4008a8, 0x7ffc9e7ceb90 respectively. Why memory address for heap is 3 bytes whereas memory address for stack is 6 bytes? Something related to virtual memory and paging ?

Answer 1

Try this instead:

char * str = "hello world!";
printf("h at heap memory address: %p (%zu bytes)\n", str, sizeof(str));
printf("str pointer stack memory address: %p (%zu bytes)\n", &str, sizeof(&str));

Using the sizeof operator, we can print the actual size of the two pointers. (%zu is a format specifier for an unsigned result from sizeof—it is probably equivalent to %lu on your system.)

You'll see that in both cases, the pointer actually takes up 8 bytes (64 bits).

The reason that the hexidecimal representations displayed by printf only show 3 or 6 bytes is because printf drops any leading zeros. Consider this similar example:

int i = 10;
printf("%x\n", i);

The result will just be "a", but that doesn't mean that i only takes up one byte.

Answer 2

@JohnathanLeffler nailed it. "The string literal is probably stored in the code [data] segment, where it will be non-writable." You can see this with a little more probing.

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

/* Do this in a function so I can verify what is stack and what is heap.
 * Try to return a variable and see if the compiler warns that it's
 * stack memory!
 */
static char *test_mem() {
    char *stack = "whom";
    char *heap = malloc(sizeof(char) * 5);

    printf("char *stack = \"%s\" at %p (size %zu) inner %p (size %zu)\n",
           stack, stack, sizeof(stack), &stack, sizeof(&stack));
    printf("char *heap = malloc at %p (size %zu) inner %p (size %zu)\n",
           heap, sizeof(heap), &heap, sizeof(&heap));

    return heap;
}

int main(void)
{
    char *ret = test_mem();
    printf("%s\n", ret);
    return 0;
}

char *stack = "whom" at 0x102fc0f28 (size 8) inner 0x7fff5cc3f4d8 (size 8)
char *heap = malloc at 0x7f9362404c80 (size 8) inner 0x7fff5cc3f4d0 (size 8)

Note that only the string literal is in the lower memory address. All the rest are in basically the same location. When I open up the executable in a hex editor I can find a block of strings.

00000f20: dcff ffff 2573 0a00 7768 6f6d 0063 6861  ....%s..whom.cha
00000f30: 7220 2a73 7461 636b 203d 2022 2573 2220  r *stack = "%s" 
00000f40: 6174 2025 7020 2873 697a 6520 257a 7529  at %p (size %zu)
00000f50: 2069 6e6e 6572 2025 7020 2873 697a 6520   inner %p (size 
00000f60: 257a 7529 0a00 6368 6172 202a 6865 6170  %zu)..char *heap
00000f70: 203d 206d 616c 6c6f 6320 6174 2025 7020   = malloc at %p 
00000f80: 2873 697a 6520 257a 7529 2069 6e6e 6572  (size %zu) inner
00000f90: 2025 7020 2873 697a 6520 257a 7529 0a00   %p (size %zu)..

The string foo is not stored in the heap, it is in the data segment of the executable which, as you guessed, is accessed as virtual memory which is allocated a special range.

Finally, the output shows those pointers are all of the same size. They're all (in my case) 64 bit (8 byte) pointers.

Answer 3

Explanation

Note that pointers are still variables in C and the only thing that makes them special is that they have the special * notation beside them. The value of a pointer is the address it refers to, just like the value of an int is the value it is assigned to

char * str = "hello world!";
printf("h at heap memory address: %p\n",str);
printf("str pointer stack memory address: %p\n",&str);

They both use the pointer specifier (%p) which is used to print memory address of a value. Note this is implementation defined.

• The first one prints the memory address of the string literal "hello world!", i.e. the value of the pointer str
• The second prints the memory address of the pointer i.e. the memory address of str

As for why these values are so far apart, @DaoWen already answered this and it has nothing to do with virtual pages or whatnot.