堆栈内存仅用于指针，而堆仅用于对象吗？

Question

Firstly, I'm currently working in C# and I've been reading up on memory management. So far, I've read through some great answers on stack overflow explaining the difference between stack memory and the managed heap memory. The majority of the answers state that by declaring:
int x = 5 , you're allocating enough memory for the type of x within the stack memory.

I understand how this works as well as the scope of it, however when I read the explanation of heap memory, it confused me.

If you're saying int x = 5 , since int is an alias of System.Int32 , wouldn't x technically be a pointer to a new instance of the System.Int32 struct? And if so, wouldn't it then be stored in the heap memory since that's used for instance objects.

In this tutorial, it states (for the line class1 cls1 = new class1() ):

... creates a pointer on the stack and the actual object is stored in a different type of memory location called 'Heap'.

By this logic, isn't everything stored on the heap and only pointers stored on the stack? Examples being new instances of System.String , System.Int64 , System.Boolean , System.Decimal etc.

I thought I understood it, however clearly I don't, so I would appreciate someone explaining whether the stack is only for pointers or which part I've misinterpreted. Thanks in advance.

Answer 1

You can use the following rule: if it's a struct (including primitive types) then it's allocated where it's declared, otherwise a pointer to an object in heap is allocated.

Possible locations are:

1. For local variables it's a stack. Note that physically values can be stored in CPU registers rather than in stack.
2. For class fields it's inside of contiguous chunk of memory allocated in heap for an instance of the class.
3. For static fields it's allocated in loader heap as a part of type metadata (сorrect me if I am wrong).

Warning: this is just basic, non-comprehensive explanation to have a basic understanding of what's going on. The reality is more complicated. Local variables can be hoisted and moved to heap, optimizer can eliminate them altogether, etc...

Answer 2

You may want to check Classes and structs (MSDN) to understand what is stored where and how:

int x = 1; // 32 bits holding an integer in the stack
System.Object bo = x; // 32+some more bits are on the heap to hold the "boxed" (wrapped to be kept on the heap) integer value
System.Object ho = new Object(); // some bits are created on the heap right from the start

In simple words there are two types of objects: classes and structs. The classes (reference types) are meant to be stored on the heap and have a pointer to them while structs are meant to be stored in the stack (the structs can be relocated to the heap though with a little overhead of wrapping("boxing") them).

If you really need/want to understand how CLR works in general, consider reading "CLR via C#" (Richter).