内存段堆栈和堆

Question

i've looked over so many topics and i still could not find out why this happens:

struct B
{
    int _arr[5];
};
struct A
{
    struct B * _pb;
};
int main() {
    int i;

    struct B b;
    struct A *pa = (struct A*)malloc(sizeof (struct A));
    for (i=0;i<5;++i)
    {
        b._arr[i] = i;
    }
    pa->_pb=&b;
    Struct A a = *pb;
}

How come pa found on stack and *pa is found on heap! both are local variables and should be only valid through scope so it should be on stack. also why is ‪a._pb->_arr[2] on stack should not be on heap? can anyone clarify for me when it should be on stack and when on heap

Answer 1

The variable pa is on the stack. The memory it points to is on the heap.

Somewhat graphically a pointer variable can be describes like this:

+----+     +--------------------------------+
| pa | --> | allocated memory for structure |
+----+     +--------------------------------+

The two locations illustrated above ( pa and the memory it points to) can be in different "segments", or they can be in the same.

And a._pb->_arr[2] is on the stack because a._pb is pointing to b which is on the stack.

Lastly a note about the "stack". While it's common to store local variables on the stack, the C specification doesn't say anything about it. Local variables are really automatic variables , and the C specification only specifies the semantics of those not where they should be stored.

Answer 2

First off, the C standard says nothing about stacks and heaps. Those are implementation details of a given compiler. That being said, most compilers for desktop applications use both of these.

You are correct that pa is local to the main function and therefore resides on the stack. *pa however is not a local variable. It is an expression which evaluates to an instance of struct A .

In this case, the malloc function returns a pointer to a block of memory big enough for a struct A and the value of that pointer is stored in pa .

Generally speaking, anything returned by malloc , realloc , or calloc lives in the heap, while variables declared local to a function (even pointer variables which may point to the heap) reside on the stack.

Answer 3

Short answer: *pa (what pa points to) is found on the heap because that's where you allocated the memory using malloc(). The variable pa, the pointer itself, is allocated on the stack because it's a local variable.

Long answer: Make sure you note the difference between a pointer and what the pointer refers to.

A declaration like this:

int a[5]

Tells the compiler to reserve space for a 5-element array, while a declaration like this:

int *a;

Tells the compiler to reserve space for a pointer. If you want the pointer to refer to an array then you need to allocate the memory, usually on the heap using malloc() and then release it when you're done using free().

And just to confuse things, in the C language, the array operator, [], is equivalent to the pointer arithmetic *() so that these two statements are wholly equivalent, regardless of whether a was declared as a pointer or an array:

a[2] = 5;

*(a + 2) = 5;

Digression: Which leads to some amusing possibilities. The above two statements are also equivalent to this one:

2[a] = 5;

Because addition is commutative in C:

2[a] = 5;

*(2 + a) = 5;

*(a + 2) = 5;

a[2] = 5;

But this absolutely does not work in C++ for reasons that are too far afield for this digression.