The mistake in writing on the 'heap' part is glaring.
Starting from the low address, we have the: - **text** --- Basically the code itself, albeit converted to binary code - **initialized data segment** --- At times, it may be referred to simply as the data segment. This is where variables with initialized values are stored. - **uninitialized data segment** --- May be referred to as **bss**. This is where uninitialized variables or variables set to 0 are stored. Since most of the time, compilers would throw a warning or an error regarding using uninitialized variables, this is mostly not being minded by newcomers. Also, we can undo the warning by compiling our program with the appropriate options for our compiler to ignore uninitialized variables. - **stack** --- where automatic/declared variables are stored - **heap** --- where the dynamic memory allocation takes place - **high address** --- includes the command-line arguments and the environmental variables which are basically variables that interacts with the whole system and can affect the processes running inside of the environment ## The memory stack The stack is a part of the shared memory pool that includes the statically declared or determined data. It may be referred to as the execution stack, the call stack, the runtime stack, or simply the stack. Generally, most popular programming languages such as C, Python, and JavaScript implemented some form of a call stack but still, it largely depends on the programming language. I just want you to keep that in mind. The main function of the stack is to store data from our program but it also handles the function execution. Every variable that is declared will be pushed onto the stack. The way how the stack works is that it is made up of stack frames. A stack frame is created from a function call and it can be removed from the stack either if the function returned something or finished running the code. Similar to how real life stacks work, it utilizes the First In, Last Out (FILO) approach. That means the most recent stack frame is the first to be "popped" out of the stack while the stack frame at the very bottom will be the last frame to be removed. ```c int multiply(int a) { return a * a; } int square(int n) { return multiply(n); } int main(void) { int number = 6; number = square(number); printf("%i\n", number); return 0; } ```
Within each stack frame is an allocated memory space that is included with a set of data and values that have
been passed on from the previous function(s). The most recent stack frame also gets to have
its code to be executed and every stack frame below it has will pause its execution for a while until the function that pushes the
most recent stack frame finishes executing.
The stack follows an arbitrary order or at least has some organization when it comes to memory allocation. Since it uses the
[stack data type](https://en.wikipedia.org/wiki/Stack_(abstract_data_type)), it can be easier to abstract how things in your
program would work.
There exists a limitation and this commonly occurs to recursive function if it is not implemented properly. The stack can only
hold a number of stack frames and this is usually referred to as the *stack bound*. When the number of stack frame has exceeded
the stack bound, it will throw an error that the call stack has been exceeded or a [*stack overflow*](https://www.geeksforgeeks.org/heap-overflow-stack-overflow/) error.
Bad things will inevitably happens when you encounter it, just take a look at
[this guy](https://www.geek.com/games/why-gandhi-is-always-a-warmongering-jerk-in-civilization-1608515/).
The main thing with the stack is that its size is determined at compile time.
What about if we want to create space for those data that we don't know how to precisely determine it while the program is still
running? We can still adjust it by coding out to possible values, variables, and such but it is not going to be an efficient
solution in long term.
## Dynamic memory allocation and the memory heap
This is where dynamic memory allocation comes from. This is a technique wherein the program can allocate resources at runtime.
Since the memory set from the stack only provides the possible amount of memory from a function call, we have limited resource
to begin with. Dynamic memory allocation allows us to get around that possible problem and make our programs more dynamic
especially at taking inputs.
What about the heap? Where does it comes from?
Heap is the space where the dynamically allocated memory goes to. Remember that the stack and the heap are both memory locations
used to describe the memory spaces so the dynamically allocated space must go somewhere and that is the heap.
Unlike the stack which has some form of organization, heap does not have. It assigns memory spaces randomly in the memory pool.
Also, unlike the stack which pops out the memory space of the most recent stack frame when the function finishes running, the
heap does not have any form of automatic deallocation and we would have to deallocate it ourselves. This does add on the random
nature of the heap that we can deallocate it in any order.
The data assigned to the heap can interact with any part of the stack as long as the data has not been deallocated.
Like the stack, there is also a buffer overflow for the heap, namely, the [*heap overflow*](https://www.geeksforgeeks.org/heap-overflow-stack-overflow/). This usually happens if we continuously
allocate our memory on the heap and did not free or deallocate it or if the size of the allocated memory that we request is
too large for the computer to handle.
Now it is easier if we just have that in code but before that, let's discuss another topic that relates to the memory management
thing which is the pointer.
## Pointers
They are basically a way to pass variable by storing the memory address with the specific value that is inside of that address.
This has opened up other ways for us to pass variable since we can pass it *by reference*.
The way how a memory work, whenever we want to do something like initializing a variable, do a function, or return a
calculation, the computer system would assign memory space somewhere in order to make those possible. With that in mind, we can
initialize two variables with the same value but it would be on two different memory locations, in other words it passes *by
value*.
Well, we can take the idea outside, shall we.
We can say that the concept of pointers are similar to URLs, which is a form of address to the file.
Like I said, don't mind the drawing.
We can get the very exact file through different addresses but then, on the computer's term, they are considered different. Plus if one of the maintainer updates a file, only one of them would be updated. ### Syntax But first, let's be familiar on the syntax on pointers, at least on C. In C, we can assign a pointer with by adding an asterisk `*` into the variable name: {% highlight c linenos=table %} // some variables int n = 9; float o = 12.345; // assigning a pointer variable for an integer and initializing it with an address int *n_ptr = &e; // assigning a pointer variable for a float and initializing it with an address float *o_ptr = &f; // assigning a pointer variable to a string literal with 10 char; char s[10] = "hello word"; {% endhighlight %} What would happen here is that we assign a pointer variable with the name beside the `*` which will point to the memory address that has the value assigned from the assignment operator. Include that with the type that is beside the name that indicates what data type can we find inside of that address. Also, take note that the pointer variable has an address of its own so we can assign a pointer variable to another pointer variable. Although I don't see a valid use case of doing that yet but you can do that if you want to. You might also notice the ambersand (&) on the initialization of the pointer variables. As it turns out, the ambersand (&) is the *address extraction operator* which is used on non-pointer variables such as `n` and `o` on the code above. As one might conclude, the pointer variable needs an address in order to make it work and not get an error with unmatched type in the initialization of the pointer variable.
Uhh... the design around the text is a design decision, yup. Not a mistake that has been decided into a design by accident at all. Yeah, it looks worse than I thought.
If we would describe it what happening on line 6 on the code example above, we would say that we assign a pointer named `i` that points to the memory location which contains an integer, `7`. On line 8, we assign a pointer named `f` that points to the memory location which contains a float whose value is `12.345`. But how about on line 10? Why is it included there? That is just an array, is it related to pointers? Well, yes. As it turns out, an array is already a form of a pointer. To be technical, it points to the first element of the array. So if we have been working with arrays in C before, you are already interacting with pointers in a way. Just keep in mind what are we storing in a pointer variable: addresses. Like how we usually store appropriate data into a variable with a specified data type. We also need to insert only addresses or else the code would not be compiled and the compiler will throw an error. Speaking of addresses, there is also one other type of a special address which is the null pointer which is a pointer that points to nothing. ```c // assigning a pointer variable to a null pointer int *i = NULL; ``` It seems useless but it has a variety of use cases. If we don't immediately assign it to something else, leading the pointer into the null pointer is said to be a safer option since undefined behavior could happen since its value could be a garbage value that is left from other programs. Just make sure that the pointer that points to the null pointer does not get dereferenced (in which we'll talk about in just a bit), otherwise we would get our program crashed due to a seg fault. As this [video on CS50 has said](https://www.youtube.com/watch?v=XISnO2YhnsY): > Pointers are nothing more than an address. ### Pointer dereferencing OK. So we assign a variable that stores an address but what do we do with it, how about the values that is inside of that memory location? We can do that by *dereferencing* the pointer to get the values that is inside of it. Dereferencing, also known as indirection, is simply the process of going into that address and getting the value located at that address. How can we do that in C? The syntax with dereferencing in C looks like this: ```c int addTwo(int a, int b); int main(void) { int *first_int = 6; int *second_int = 12; // dereferencing of the pointer and getting the values int sumOfTwo = addTwo(*first_int, *second_int); printf("%i\n", sumOfTwo); } int addTwo(int a, int b) { return a + b; } ``` As you can see, it is mostly the same as we assign a pointer variable but take a closer look at the differences between assigning and dereferencing. When we want to create a pointer variable, we can see that it is on the left side of the assignment operator and also has the data type indicating the type of value that is located at the address assigned to the pointer variable. Another example from the previous subpoint: ```c int n = 9; int *n_ptr = &n; printf("%i\n", *n); ``` Would have this as a simple visualization when an indirection was needed:
This has been previously mentioned but to nail the point: when the pointer points to a null pointer and we dereferenced it, the
compiler would compile the program (assuming no errors were thrown at compile time, of course) but it would get a segmentation
fault at runtime.
```c
// one surefire way of getting a seg fault
int main(void)
{
int *ptr = NULL;
printf("%i\n", *ptr);
return 0;
}
```
We could also use the null pointer to do some error handling like avoiding to dereference the pointer if the pointer contains
`NULL`, thus preventing some error like the segmentation fault.
```c
// making sure to avoid to dereference a null pointer
if (ptr != NULL) /* we can also use if (ptr) */
{
/* do some stuff */
}
else
{
/* some error-handling */
}
```
## Dynamic memory allocation in code
Now that we are done with what we should know with pointers, we can now demonstrate how do we dynamically allocate some memory
for our program at runtime since we can't really adjust the memory resources from our stack.
For a recap, when we create some more complex and flexible programs, we should have a way on how to create some programs that can
easily adjust to our input especially if we don't know what value that input is. For instance, if we want to have our program
accept various set of data like the number of users which can dynamically change over time and we wouldn't really know the data
that will come in.
Dynamic memory allocation lets us get around that by setting some memory aside on the fly while our program is running. In this
way, we can set some memory space for the number of those data. Another thing with dynamic memory allocation is that any
memory that is set by the system this way will take place in the heap.
Now how about doing them in code?
In C and C++, you can dynamically allocate memory by `malloc()` and its related functions such as `calloc()` and `realloc()`.
For now, we'll just focus on `malloc()` since it makes things easier to understand. The `malloc()` function needs an integer to
how many memory (in bytes) do we need as its parameter and will return a pointer to that memory chunk.
{% highlight c linenos=table %}
// assigning a float on the heap
float *f = malloc(sizeof(float));
// assigning a string of 9 chars (since must be /0 is included and it takes one more byte) on the heap
char *s = malloc(sizeof(char));
// creating a chunk of memory that can hold 20 integers
int *numbers[20] = malloc((sizeof (int) * 20);
{% endhighlight %}
As you can see, we are assigning a chunk of memory that is being given by the computer through `malloc()` to a pointer variable.
In line 2, we can describe it as we are requesting for a chunk of memory that is worth 4 bytes (the size of float) then
assigning the pointer of the newly created memory chunk to a pointer variable named `f`.
Keep in mind that we are using the `sizeof` operator here so that we can reduce throwing magic numbers in our program. Also,
in this way, we can keep sustain our program some portability (the ability to run on other systems without much dependencies).
Also, if `malloc()` cannot find some free memory, it will return a null pointer (`NULL`).
This adds up another use case for the null pointer wherein we can check to know whether `malloc()` successfully obtained some
memory for our program in order to prevent an accidental dereferencing and cause a segfault and do some error-handling, as well.
```c
// creating
float *arr = malloc(sizeof(float) * 10);
if (arr == NULL) /* we can also use if (!arr) */
{
/* error-handling code */
}
/* continue on if it does returned a memory chunks */
```
Now, as previously mentioned, here's the problem when creating dynamically-allocated memory: it does not automatically
deallocated or returned to the system once the function that created the dynamic allocation of the memory has finishes execution.
We would have to free it ourselves with the `free()` function on C/C++.
Now, freeing the allocated memory is easy compared to creating the dynamic memory. All the `free()` function needs is a
pointer that with the memory chunk being malloc'd.
```c
int *a = malloc(sizeof(int) * 2);
if (a == NULL)
{
/* error-handling code */
}
/* do some stuff with a */
/* assume that we are done with it */
free(a);
```
With that said, there are some things that you want to take in mind, specifically, the three golden rules of dynamic memory
allocation (as ripped off from [CS50's Dynamic Memory Allocation video](https://www.youtube.com/watch?v=9uhSYDY4sxA)):
- every block of memory that have borrowed needs to be freed
- only `free()` what you have `malloc()`'d
- never `free()` the same `malloc`'d block twice
Well, generally, bad things can happen since we are talking about interacting with memory here and it might affect other
programs, too.
As previously mentioned, there are some related functions of the `malloc()` family such as `realloc()` and `calloc()`.
### `realloc()`
Syntax: `realloc(void* ptr, size_t size)`
The `realloc()` function accepts a pointer to a malloc'd memory followed with the new size of the memory. It will deallocate the
old chunk from where the `ptr` is pointing to and find a new one that is worth `size` bytes. Like `malloc()`, it will return a
pointer to the new chunk and if it fails, it will return `NULL` instead.
```c
int *user_id = malloc(sizeof(int) * no_of_users);
if (user_id == NULL)
{
printf("malloc failed.");
return 1;
}
/* some code */
/* if you need to allocate some memory for the new data */
realloc(user_id, sizeof(int) * new_no_of_users);
if (!user_id) /* this is just the same as user_id == NULL */
{
printf("reallocation failed.");
return 1;
}
```
### `calloc()`
Syntax: `calloc(size_t n_items, size_t size)`
`calloc()` does the automatic initialization of the values inside of the memory for you so you don't have to worry about the
garbage values. The functions also need two parameters except it requires the number of elements as its first value and the
size (in bytes) of each element as its second value. The return value of the function is the same, however, as it returns a
pointer to the newly allocated memory block and `NULL` if the function fails.
```c
int number = 9;
/* allocating 36 bytes into the heap and initializing them to 0 */
int *mem_chunk = calloc(number, sizeof(int));
```
## (Re)Sources:
- ### Books
- [Chapter 22: Pointers on *C Notes For Professionals (Goalkicker)*](https://goalkicker.com/CBook/)
- [Chapter 3: Hardware on *Computer Science Made Simple (V. Anton Spraul)*](https://www.amazon.com/Computer-Science-Made-Simple-hardware/dp/0767917073)
- [Chapter 46: Memory Management on *C Notes For Professionals (Goalkicker)*](https://goalkicker.com/CBook/)
- [Learn the Basic Electronic Components from *Build Electronics*](https://www.build-electronic-circuits.com/dbe-components/)
- ### Videos
- [Blinky Pointer Video from *Stanford University Archive*](https://www.youtube.com/watch?v=f-pJlnpkLp0)
- [Call Stack on *CS50*](https://www.youtube.com/watch?v=aCPkszeKRa4)
- [Dynamic Memory Allocation on *CS50*](https://www.youtube.com/watch?v=9uhSYDY4sxA)
- [Lecture on Memory from *CS50*](https://www.youtube.com/watch?v=Zn8OJMYT-gc)
- [Pointers on *CS50*](https://www.youtube.com/watch?v=XISnO2YhnsY)
- ### Web
- [Computer Memory from *Tutorials Point*](https://www.tutorialspoint.com/computer_fundamentals/computer_memory.htm)
- [Computer memory on *Wikipedia*](https://en.wikipedia.org/wiki/Computer_memory)
- [Heap and Stack Overflow from *GeeksForGeeks*](https://www.geeksforgeeks.org/heap-overflow-stack-overflow/)
- [Memory Layout for C from *GeeksForGeeks*](https://www.geeksforgeeks.org/memory-layout-of-c-program/)
- [Memory: Stack vs Heap by *Paul Gribble*](https://www.gribblelab.org/CBootCamp/7_Memory_Stack_vs_Heap.html)
- [Null Pointer in C from *GeeksForGeeks*](https://www.geeksforgeeks.org/few-bytes-on-null-pointer-in-c/)
- [What and where is the stack and heap on *Stack Overflow*](https://stackoverflow.com/q/79923)
## Where to go from here?
Here are some of the topics/concepts that you'll expect to encounter if you want to progress from this type of topic:
- Some data structures
- Assembly programming (I guess way too advanced?)
- Electronics integration (y'know from computer engineering and stuff)
## Author's Note
Yes, it is another new series that's called *Simplified!* which sounds like one of the most common name for a beginner-friendly
kind of posts out there. If there's a more cool-sounding name, I would take it but I'm not good at naming things. If we would
take the previous regular posts such as [this one]({{ site.baseurl }}{% post_url 2018-06-21-a-closer-look-on-computers %}) or [that one]({{ site.baseurl }}{% post_url 2018-05-18-git-concepts-and-mechanics %}), they would be probably one on the series too but I don't want to include
them in this series since I'm currently making a new writing and content style.
So I put the debut of this kind of series since I might make an more detailed version of this topic. It is kind of an interesting
take since this topic of memory management goes beyond the things whatever I've explained above. If you want to get a more
technical version of it, you can research about it yourself with Google, Stack Overflow, and a lot of resources regarding computer
science or programming, in general.
If there is anything that ticks you off from my very simple drawing (such as the mistakes and accidents), cut me some slack as
this is my first time. Although I can just restart with a new paper, I don't *really* want to waste paper.
**NOTE**: This article may undergo changes as I'm trying to explain the concepts better in a better and consistent way, same with
other articles.