Value types and Reference types
Last updated
Last updated
The value type stores data directly in Stack memory
Reference types only store addresses in the Stack, while variable values ​​are located elsewhere (Heap).
A reference type that stores its contents in allocated memory is Stack. When we create a variable of value type, a memory area will be allocated to store the value of the variable directly.
If you assign it to another variable, the value will be copied directly and both variables will work independently.
Reference data types in .NET:
Integer types
Real number type
Logical type bool
Character type char
Structure type
Enum
Reference types are used to store a reference value (memory address) of an object but do not store the object itself.
Because the reference type only stores the address of the variable's memory instead of the value of the variable, when assigning a reference variable to another variable, it does not copy the data, it only copies the reference address.
So both variables will refer to the same address on the Heap memory.
This means that when a reference variable is deprecated, it will be marked for the Garbage collection.
Reference data types:
Classs
Object
Array
Indexer
Interface
Stack is statically allocated memory and Heap is dynamically allocated memory, both are stored on the computer's RAM.
You can use Stack if you know for sure the size of the data to be stored before compiling the program, it cannot be too large.
You can use the heap if you don't know exactly how much data you will need at runtime or if you need to allocate a lot of data.
In a multi-thread application, each thread will have its own stack but they will share heap memory. The stack is separate for each thread and the heap is shared across the entire application.
Stack
Heap
Memory is managed automatically
Memory is managed manually
Small size
Large size
Easy and fast access, easy cache
Difficult to cache because it is scattered in memory
Inelastic, allocated memory cannot be changed
Flexible, allocated memory can be changed
Limited to thread scope
Get access to the entire application
The operating system allocates the stack when the thread is created
The operating system is called by the language at application runtime to allocate heap for the application.
Static allocation
Issuance of activation
The size must be known at compile time
Variable size is unknown at compile time
Done at compile time
Executed at runtime
Assigned to stack
Assign to heap
FILO (First – in, last- out)
Straggling
We have 2 data types: value and reference:
Values ​​are small, fixed-size data types whose values ​​are stored directly on Stack memory.
Reference is a type that only stores addresses on the stack and values ​​​​stores on the heap.
Both types of memory are stored in RAM, it's just a different area. One side is static allocation, the other side is dynamic allocation.
Why must it be divided?
Because with large data types, such as objects, it is impossible to know its size at compile time, so it is not stored on the stack but only stores the address of the Heap, because the heap is dynamically allocated memory.
For example: We read a Harry Porter book, instead of saying I read Harry Porter book 1 , I have to say I read …. from the first sentence to the last sentence... do you know? Instead of having to state the entire content of the very long book, we just need to refer to the name of the book, which is the memory cell address pointing to the book's content. As for the book's content, that person will read it for himself.
As for short sentences, we can always say them in conversation. For example: Have you eaten rice yet? That sentence is not in any book or it is very short so it can be said in conversation.
That's the type of greed.
