malloc（）| 堆栈和堆位置的内存地址长度的差异 C程序设计

Question

I am learning memory management of c program. I have arrived at a good doubt. (Ubuntu OS)

My Doubt :

I wanted to know addresses of data that lie inside stack and inside heap both . But when I tried printing those addresses, I observed that length of addresses are different! Question here is why it is displaying stack address having more length than heap address?

What I know :

• Stack memory per process is fixed and less than heap memory.
• malloc() memory allocate on heap
• local variable goes on stack

I put my demo code here so that you can answer my doubt well.

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

int main()
{
    int *ptr; // goes on stack

    ptr = (int *)malloc(sizeof(int));
    *ptr = 10; // 10 is stored on heap
    printf("%p : heap address\n",ptr);
    printf("%p:  stack address\n",&ptr);
    return 0;

}

Output : I got following output in my terminal

0x1ea2010 : heap address
0x7ffda62cb3c0:  stack address

So now you might understand what I am asking. Why stack address has more length than heap? Heap is large pool of memory so obviously it should have more length.

If stack and heap allocation is done in same memory block(as per modern OS..I have read this somewhere) so then also it should have same length.

Okay. Please help me to make my memory concepts crystal clear.

Note : If my doubt is very simple or silly then also at least please let me know how memory allocation is done in my demo code and magic behind different lengths of addresses.

Thanks for reading such post. Happy answering !

Answer 1

Given that you are running Ubuntu, I'm assuming you're running on an x86 or x86-64 platform. Assuming that's true, your program layout looks something like this:

              +-----------------------------+
High Address: |   Command-line arguments    |
              |  and environment variables  |
              +-----------------------------+
              |            Stack            |
              |              |              |
              |              V              |
              |                             |
              |              ^              |
              |              |              |
              |            Heap             |
              +-----------------------------+
              |     Uninitialized Data      |
              +-----------------------------+
              |      Initialized Data       |
              +-----------------------------+
              |        Program Text         |
 Low Address: |       (machine code)        |
              +-----------------------------+

The stack starts at a high address and grows "downwards" (towards decreasing addresses), while the heap starts at a fairly low address and grows "upwards" (towards increasing addresses). The %p conversion specifier isn't printing the leading zeros in the address values; if it did, your addresses would look like

0x0000000001ea2010: heap address
0x00007ffda62cb3c0: stack address

Both addresses really are the same length, it's just that the leading zeros aren't being displayed.

Answer 2

It seems like you are working with 64bit addresses, meaning that they print out as up to 16 hexadecimal characters. you should pad all addresses with zeros on the left hand side to reach 16 characters.

0x0000000001ea2010: heap address
0x00007ffda62cb3c0: stack address

The heap and stack(s) both live in the same virtual 2^64 byte space.

Answer 3

Your format string in printf specifies to skip leading zeroes, that's the default. You need to add the desired length of your printed addresses as in %016p, %016x or %016X (if you want uppercase hexadecimal characters).

As you correctly assume, all pointers must be the same length.

Answer 4

There is no standard.

But, typically, what happens is Heaps grows upwards while Stacks grows downward. Hence, logically, at starting point, Heap will be smaller in size , while, Stack is larger in size.

The reason why such an implementation is present is because, it gives a program a lesser chance to have overlap of static vs dynamic memory.

Someone above mentioned Virtual addresses and Physical addresses. Contextually speaking, every piece of memory in a process is a Virtual address, hence, trying to explain the BUDDY algorithm is aa redundancy at best and irrelevant at worst.

Answer 5

Imagine you live on a long street. You live at the south end of the street, where the house addresses are 1, 2, 3.

Imagine that the street runs north for one mile. Imagine that at the north end of the street, the addresses are 998, 999, 1000.

Imagine that so far, only the north and south ends of the street have been developed. From address 20 to address 990 is nothing but undeveloped vacant lots.

But at your end of the street there's lots of activity. New buyers buy lots 20 through 30 and start building houses on them.

Meanwhile, at the north end of the street, there's not so much activity. It looks like lots 989 and 990 have been sold, and something's being built there.

So, where is there a bigger "pool" of undeveloped lots? At the north or the south end of the street?

So far, there are more houses at the south end of the street (1-20, and growing) than there are at the north end of the street (990-1000). So far, growth is faster at the south end of the street, also. (10 lots under construction at the south end, versus 2 at the north.)

And yet, the addresses at the north end of the street are bigger (3 digits starting with 9, or 4 digits) than they are at the south (2 digits). What does this mean? (Answer: it doesn't really mean anything.)