Memory Management with malloc and free

We are with Huiqi again and this video is part 1 of a series where we walk about memory management. In this part, we will talk about how manual memory management is done in the C programming language. In upcoming episodes we'll talk about garbage collection (GC) as well as automatic reference counting (ARC).

Transcript

The following transcript was automatically generated by an algorithm.

00:00 : yeah so i wanted to tell you about
00:02 : memory management and how that works
00:05 : if you started out with a language like
00:09 : javascript or java or c-sharp
00:12 : then you're using a programming language
00:15 : that has
00:16 : automatic memory management
00:19 : and specifically it use those languages
00:23 : use a garbage collector
00:25 : which is a invention
00:28 : that came about at some point
00:31 : a lot of that work was done in the
00:35 : self programming language which is
00:37 : related to the small talk
00:39 : programming language um but before we
00:42 : had that
00:43 : uh like an older programming language
00:46 : like c
00:47 : developers had to manage uh memory
00:50 : themselves
00:51 : and i kind of first want to lay out
00:54 : how that would work to give an outline
00:56 : of some of the things i wanted to cover
00:59 : first manual memory management just a
01:02 : little bit and
01:03 : all of these are not going to be very
01:05 : in-depth because we don't
01:07 : have that much time to go into it if you
01:10 : want to learn more about it you can
01:12 : read up on it more there's two main
01:15 : categories
01:16 : of automatic management one is called
01:19 : garbage collection and then the second
01:22 : one
01:22 : is called uh automatic
01:27 : reference counting um i would say
01:29 : there's
01:30 : okay this is maybe too specific i'm
01:33 : gonna call this just reference counting
01:35 : within this reference counting scheme
01:39 : there's multiple ways of applying this
01:42 : um i don't even know if i want to call
01:45 : this reference counting
01:47 : maybe like i'm gonna actually call this
01:49 : scope
01:50 : based scope based automatic cleanup uh
01:54 : but the main one i'm gonna focus on is
01:56 : automatic reference counting
01:58 : because that's the one that i've studied
02:00 : the most
02:02 : um okay so let's first talk about
02:05 : manual memory management this is hello
02:08 : world in c
02:09 : first of all there's two ways in which
02:12 : programs
02:13 : use a memory one is the stack
02:16 : and the second way is the heap the stack
02:19 : is used for
02:20 : local variables that are needed within a
02:24 : function
02:25 : so if you have a function f and it takes
02:28 : parameters x and y i don't know
02:32 : it it declares more variables in there
02:37 : the stack is responsible for
02:40 : allocating space to hold all of the
02:43 : local variables
02:44 : including the function parameters in in
02:47 : a
02:48 : frame of the stack if at any point in
02:50 : time
02:51 : the program decides to call this
02:53 : function f
02:54 : stack means it's a first in first out
02:57 : data structure so if we call this
02:59 : function
03:00 : we put this stack in here and it'll
03:03 : it'll remember
03:05 : like that well this you called me
03:09 : and then i'm gonna initialize the values
03:12 : of x
03:13 : and y
03:16 : and when it encounters this line it'll
03:19 : also initialize the
03:20 : value of a and so forth so all of this
03:25 : information is remembered for the
03:27 : purpose of executing this
03:29 : function um if sometime
03:32 : later inside the body of f if f decides
03:35 : to call
03:36 : another function say g we will push
03:40 : another frame onto the stack this is
03:42 : called a frame
03:43 : this this this rectangle here is called
03:45 : the frame
03:46 : so we'll add an additional frame for the
03:49 : purpose
03:50 : of whatever g needs to remember right
03:54 : and maybe i don't know g has a w
03:56 : variable i don't know
03:58 : uh so this is how it works and when g
04:00 : finishes
04:01 : when the execution of g is done
04:04 : then this frame can be destroyed and
04:07 : then we're left with just the f
04:09 : frame and so forth so this is the stack
04:12 : memory and that's not what we're going
04:14 : to talk about although we just did but
04:17 : not in depth the heap memory
04:20 : now the the one thing about the stack is
04:23 : that
04:24 : you can see that the things gets
04:26 : destroyed
04:28 : uh on the fly and get created on the fly
04:32 : as
04:32 : functions are called and and end right
04:35 : everything that's remembered on the
04:38 : stack
04:38 : is short lived so the stack is not going
04:41 : to work
04:42 : for long lived objects that you need to
04:45 : remember
04:46 : so long left objects is
04:49 : what the heap is for such as like
04:52 : there's some
04:53 : array data structures or dictionary data
04:55 : structures
04:56 : that you want to remember across
04:59 : all of these function calls you don't
05:02 : want them to get destroyed just because
05:04 : the function is finished because you
05:05 : might want to pass that on to another
05:07 : function that needs to work on it
05:09 : etc i don't know why they called it the
05:11 : heap um
05:13 : but they do so let's call it the heap
05:15 : but
05:16 : but other names other names for the heap
05:19 : might be
05:20 : uh dynamic memory um yeah so
05:23 : an example of using the heap would be oh
05:26 : i i'm gonna
05:27 : i have a function maybe inside this
05:30 : function
05:30 : i'm gonna make an array this this array
05:35 : is gonna contain these two numbers that
05:37 : got passed in
05:38 : and then i'm gonna pass this array to g
05:41 : there should be an equal sign in here
05:44 : sorry
05:44 : um so if we did this like uh this is the
05:48 : stack
05:48 : uh so we first will like somebody has to
05:51 : call f
05:52 : first so when you call f like this
05:56 : we're gonna make a frame on the stack
05:59 : for
05:59 : f and we'll have a e
06:02 : two and b is three we're gonna make an
06:06 : array variable now and the the content
06:09 : of the array will actually
06:11 : point to the heap we're gonna
06:14 : allocate an array on the heap
06:18 : and we're gonna place the numbers two
06:20 : and three in
06:21 : inside the array and so the heap is not
06:24 : like specific to this frame or to the
06:27 : stack
06:28 : right it's somewhere that it depends
06:30 : yeah
06:31 : that's why it's called long-term memory
06:33 : it will live on
06:34 : it'll live on even if this stack gets
06:37 : cleared out
06:38 : so now this array variable is gonna be a
06:41 : pointer
06:43 : that is referencing this object and
06:45 : there's there's an
06:46 : address where this actual data is stored
06:49 : in the heap
06:50 : and and now if we call g we'll add
06:53 : another frame
06:54 : into g well we're actually passing to g
06:58 : this array variable
07:02 : and maybe g has its own name for this
07:04 : array
07:05 : i don't know uh my array and this my
07:08 : array is gonna
07:09 : point to the exact same object in the
07:12 : heap
07:13 : and when g is terminated then
07:16 : this frame will go away but this array
07:18 : object will not go away
07:20 : um when f goes away
07:25 : do you think this object will go away
07:29 : uh no it was still reader right
07:32 : um depends
07:35 : um well i'm writing pseudocode here so
07:38 : you you don't
07:39 : you don't know what language i'm using
07:42 : but
07:43 : it depends on what the language does um
07:47 : if it's javascript or python then this
07:50 : array will go away
07:52 : because memory is automatically managed
07:55 : for you and
07:56 : it can see that there's no one else that
08:00 : could possibly
08:01 : would want anything to do with this this
08:04 : array anymore
08:05 : because this array was created
08:08 : within the body of f and f
08:12 : hasn't handed this to any other place
08:15 : that could be active it handled it to g
08:18 : but g
08:18 : is dead now and it didn't return the
08:21 : array to anywhere else
08:23 : if it had returned the array that's a
08:25 : different story
08:26 : then you have to worry about oh maybe we
08:29 : need to um
08:30 : keep this array around but that's not
08:31 : the case so it basically keeps like a
08:33 : registry of
08:34 : who is gonna potentially use the array
08:37 : yes and if they're like
08:38 : okay nobody's gonna use it then i'm
08:40 : gonna automatically destroy it
08:42 : in the language that you don't have to
08:44 : yes yeah
08:45 : and and and the behavior i just talked
08:47 : about is the
08:49 : garbage collection and also the arc
08:52 : both of these systems will do that for
08:56 : you will automatically clean up
08:57 : but if but if you're using a programming
09:01 : language like c
09:02 : then it will not do that for you and
09:05 : i'll show you
09:05 : maybe a little bit of code let's say you
09:08 : have let's not do structs
09:10 : let's just do it ray now in c it is
09:12 : actually possible to create
09:14 : an array in the stack frame memory
09:19 : by the way it's possible to do that
09:21 : although we're not doing that here
09:23 : it's c c gives you the option of
09:26 : like if if you write it in a certain
09:29 : syntax
09:29 : numbers
09:33 : i think this is how you do it and see
09:35 : this is an array of numbers
09:37 : um and if you had written it in this
09:40 : syntax
09:40 : that means the array of numbers actually
09:43 : goes on the frame
09:45 : so this is not a use of dynamic memory
09:49 : c gives you the choice to do either way
09:52 : but but
09:52 : we're not going to talk about that we're
09:54 : going to talk about dynamic memory i i
09:56 : want to store this array in the heap
09:58 : how do i do that i need to ask the c
10:02 : standard library to allocate some memory
10:05 : and the function
10:06 : we use is malik
10:10 : which stands for memory allocation
10:13 : so we're gonna malek so if you if you
10:16 : hear the word
10:17 : malik anywhere that's what that means it
10:20 : means
10:22 : memory allocate so this is the api
10:25 : docs for uh the
10:28 : for the functions in the standard lib
10:31 : library and one of them is malik malek
10:34 : takes in one parameter which is the size
10:38 : it wants you to tell it the number of
10:40 : bytes you want to allocate so does it
10:42 : happen
10:43 : how many or how what is the information
10:46 : you stored in the array
10:48 : yeah so like if you if you put in 12
10:50 : then then that means
10:52 : i want 12 bytes but like as a c
10:54 : programmer
10:55 : i how how do you know what kind of data
10:58 : structure
10:59 : requires how many bytes to store right
11:04 : c does give you a method
11:07 : of calculating that for you and that
11:10 : method is size of if i have an integer
11:15 : array that has two numbers in it i'm
11:18 : going to try this
11:19 : see if this works
11:22 : no i'm i'm going to get the size first
11:25 : before i ask for the memory so print a
11:28 : number
11:29 : this is how you do it in c and then i'm
11:32 : gonna
11:32 : call this f function here
11:35 : so i'm gonna gcc compile this
11:40 : file and i'm gonna say
11:43 : output the resulting binary as
11:46 : mem dot bin and and then i'm gonna call
11:49 : memdap in
11:50 : the size is eight so apparently if i
11:52 : want an
11:53 : integer containing two numbers
11:56 : that is gonna cost me eight bytes
11:59 : to store the information in that array
12:02 : eight bytes of memory
12:03 : and and if i wanted to store ten numbers
12:06 : i would guess that would be forty right
12:10 : just just based on doing some math yeah
12:13 : if i wanted to integer type in
12:16 : c that's gonna cost me four bytes and an
12:19 : array of that is the number of elements
12:22 : times that
12:23 : number okay so anyway so now that i
12:27 : know the size the number of bytes i'm
12:30 : going to need to ask for i'm going to
12:31 : call
12:32 : malloc and ask for that size
12:35 : and then i'm going to receive it the
12:38 : type
12:39 : of the receiving value
12:45 : an initializer okay so it won't let me
12:48 : do this
12:48 : because i there might be a way of
12:51 : writing it in this syntax
12:53 : um but i i think more or less it's
12:55 : telling me
12:56 : if you're trying to declare this as an
12:58 : array then you you're gonna need to
13:00 : figure out more specifics about the
13:03 : array which i don't care to give because
13:05 : this is
13:06 : coming from dynamic memory it's very
13:07 : dynamic so what i'm going to do instead
13:10 : is
13:10 : call this this is an integer pointer
13:14 : i'm going to make this a pointer and in
13:16 : reality anything that
13:18 : malloc returns to you is a pointer to to
13:21 : some
13:21 : place in the memory um and pointer is a
13:25 : concept that
13:26 : newer languages don't have it's a lower
13:28 : level concept
13:30 : essentially it's a memory address and it
13:32 : represents represents
13:34 : a reference to some dynamic object uh
13:37 : either in the heap or on the stack so so
13:40 : i believe
13:41 : this will at least compile yes
13:44 : i basically took the value that malloc
13:47 : returned to me which is a pointer and i
13:50 : said
13:51 : i'm gonna assign it to a variable which
13:53 : is an
13:54 : integer pointer which can be used uh
13:57 : to represent an integer array and then
14:00 : and then after that
14:02 : i can start like utilizing this i can
14:05 : say
14:06 : the first number is 4 the second number
14:10 : is
14:10 : 19 and so forth and and i i have to
14:13 : remember
14:14 : the length of the array myself though
14:18 : so let me let me make sure i remember
14:21 : that so now i can do something like
14:23 : for
14:27 : i plus one times two i will just
14:30 : initialize
14:31 : this array with something
14:32 : [Music]
14:34 : and and then and then we can maybe even
14:38 : return it
14:42 : out
14:44 : we're going to return this array of
14:46 : numbers which was
14:47 : allocated on the heap back to the
14:49 : outside
14:50 : back to the collar and then maybe
14:54 : we'll loop through it and print it out
14:55 : on the outside to prove that it worked
14:59 : okay we'll just hard code the length for
15:00 : now
15:04 : but this time i'm not gonna assign to it
15:06 : i'm gonna print it out
15:13 : uh it's print f not print
15:17 : okay that actually compiled uh
15:21 : yeah okay let me let me put a new line
15:23 : character here
15:24 : so that it's separated yep so that
15:27 : worked
15:28 : so what if you go over the allocated
15:31 : members
15:32 : great question let's try it
15:39 : oh
15:43 : i i'm so glad you asked that question
15:45 : because um
15:47 : do you see what's happening here yeah
15:49 : wait what did you do why it prints these
15:52 : stuff
15:52 : i i i artificially changed the length it
15:55 : thinks it is
15:56 : to 20 instead of 10. even though only 10
15:59 : was allocated
16:01 : once it returned back to the caller the
16:03 : caller pretend it had 20 elements in it
16:06 : right so so what do you think is going
16:09 : on here
16:11 : not sure where where do they get these
16:15 : numbers from
16:16 : is it does it point to some other memory
16:19 : location to get these numbers
16:21 : yeah yeah yeah so so actually what
16:23 : happens is
16:24 : it's extremely hilarious well the heap
16:26 : is a
16:27 : just a large section of a memory right
16:31 : everything memory trip looks like this
16:32 : and then you slot it there's this
16:34 : slot you you push it into the slot
16:38 : like a like a game cartridge or
16:41 : something like that
16:42 : there's these cells inside
16:45 : like the basically there's a lot of you
16:48 : can just think of it like a mailbox
16:50 : a lot of mailboxes right next to each
16:52 : other like
16:53 : it's it's it's arranged like a grid and
16:56 : all the grids are numbered
16:57 : one two three every
17:01 : address space is numbered when we
17:05 : ask mala for some space
17:08 : some of these will already be been
17:11 : allocated
17:12 : because somebody else mallocked for it
17:14 : somebody is using this already
17:16 : so you can't use that when you call
17:18 : malloc
17:19 : malloc is like oh i found this one
17:22 : you can use this one so i'm gonna return
17:25 : six
17:25 : to you so so the the thing in here
17:29 : is actually the address six
17:33 : i'll put a star next to it to mean this
17:36 : is a six
17:36 : address is pointing to here so malek
17:40 : actually returns a number back because
17:43 : pointers are just numbers
17:45 : which are everything in computers are
17:47 : numbers
17:48 : i don't know if you know this yeah
17:50 : everything in complete
17:52 : sorry so we have the size does it still
17:55 : only return like one number or it will
17:57 : give you like a consecutive
17:59 : like series of number in this case yeah
18:02 : yeah so to actually uh the the way that
18:05 : works
18:06 : happens later actually which is
18:08 : important to understand so
18:10 : so malek is like uh yeah okay
18:14 : because they wanted 10 boxes
18:17 : let's say i'm gonna assign ten
18:20 : boxes starting at six okay to your
18:23 : program so that's yours now
18:25 : okay this chunk is mine
18:29 : to store my numbers and malloc just
18:32 : returned me the address of six i'm
18:35 : thinking this is an integer array
18:37 : in reality it's just the number six
18:41 : i'm gonna prove that to you by just
18:44 : printing out
18:45 : this the memory
18:49 : address as a number
18:54 : so you can actually print that out
18:58 : uh okay
19:01 : why is this still negative i'm not sure
19:04 : why
19:05 : but it's okay we don't have to dwell too
19:08 : much on it
19:09 : but essentially what i'm trying to show
19:11 : is that this is a
19:13 : address number uh that's similar to
19:16 : my table right they they just have a
19:18 : much larger table than i do
19:20 : um and they're so this array
19:24 : is nothing more than an address into
19:27 : this
19:27 : table and then the way
19:31 : your program then accesses all the
19:34 : numbers in the array
19:36 : is actually by adding an offset
19:39 : to this number okay so like you gave me
19:43 : six
19:43 : so in order to access the zeroth element
19:47 : well that's six in order to access the
19:50 : first element of the array that's six
19:52 : plus one
19:53 : right and and so forth right
19:57 : okay so it just gets into the location
20:00 : after
20:00 : what you got yes yeah that's called
20:03 : pointer arithmetic uh that you just add
20:06 : you're just adding and subtracting
20:09 : offset numbers
20:10 : from one address location to get another
20:13 : to see compiler
20:15 : when it looks at this array indexing
20:18 : operation it will do that arithmetic
20:22 : automatically for gotcha
20:24 : because like this number this number
20:26 : let's say i
20:27 : is four and it sees that you're trying
20:30 : to access
20:31 : index four of this got numbers array
20:34 : and it it looks at the type of god
20:37 : numbers
20:37 : and oh it's a it's a pointer to an
20:40 : integer
20:41 : it's trying to be used as an integer
20:43 : array let me figure out the size of an
20:45 : integer an integer has
20:47 : four bytes every integer is four bytes
20:49 : so when you index
20:51 : into um so so when you do this
20:54 : i'm gonna do i so i is
20:57 : four so if if i'm trying to index
21:01 : into index four of this array i'm gonna
21:04 : do
21:05 : four times uh the size of integer
21:08 : which is four we end up with
21:12 : 16. well okay so this there's actually
21:16 : four boxes if we're gonna do it like
21:19 : that
21:21 : for every number we need four bytes
21:25 : right okay and so forth so so the 16 is
21:28 : like
21:29 : i need to move 16 over to get to this
21:32 : element which is
21:33 : which would be at index four it's the
21:36 : beginning of here
21:37 : actually so so this expression
21:40 : what it actually does is six
21:44 : plus 16 to find the memory location
21:48 : of of here right and
21:51 : and then it retrieves the value from
21:54 : that
21:55 : memory location it retrieves uh
21:58 : four bytes to to make a number from that
22:01 : memory location
22:03 : there's an operator in c that actually
22:06 : does this
22:06 : explicitly even though this one does it
22:09 : implicitly for you
22:10 : there's a you could do this explicitly
22:13 : yourself
22:14 : using this star operator star operator
22:17 : says
22:18 : given a memory address go there
22:21 : and fetch the number and then and then
22:24 : the result here
22:25 : is the number that's in the memory
22:27 : location
22:29 : uh question so how does it know it needs
22:31 : to
22:32 : grab the next four bytes there
22:36 : uh you know it knows because it this
22:38 : this is a strongly typed programming
22:40 : language
22:41 : and all variables are tagged with a type
22:44 : identifier
22:45 : now in javascript obviously they would
22:48 : have to do it differently well you don't
22:51 : do
22:52 : the memory handling of this stuff in
22:55 : javascript anyway
22:56 : so you just don't have to do it
22:58 : javascript does it for you
23:00 : well javascript like figure out how to
23:03 : allocate memory yourself i mean i i
23:06 : guess you don't have a size
23:08 : you don't tell it you don't tell the
23:09 : size the arrays are dynamically sized
23:12 : um and it'll you'll just ask for more as
23:16 : you need more
23:17 : memory like if you push dynamically push
23:19 : element to an array then
23:21 : it's going to realize oh i need
23:22 : more memory and then go
23:24 : go ask for more if needed gosh
23:28 : so but but all of this uh i was
23:31 : basically trying to
23:32 : answer your question of why we got these
23:36 : extra
23:36 : weird numbers back here can you answer
23:39 : that question now
23:41 : yeah i think it's uh just keep going
23:44 : down
23:45 : yeah yeah it's it's whatever it will
23:47 : whatever junk
23:48 : is in here it also printed out even even
23:52 : though
23:52 : that doesn't belong to you you're still
23:55 : accessing it
23:57 : which which shows a huge problem
24:01 : with this design which is that
24:05 : you can access data that does not belong
24:07 : to you
24:09 : right and that's actually a source of a
24:12 : lot of security problems because
24:14 : when programmers make bugs in c
24:18 : um they can actually like hackers can
24:21 : actually take advantage of that and like
24:24 : if it's a like a network program
24:26 : like let's say you're a website that
24:29 : allows people to
24:30 : upload images or something and then as
24:33 : one
24:33 : one of the parameters is you're gonna
24:36 : tell me
24:37 : how many bytes are in that image
24:40 : and and if the hacker gives a
24:44 : fake number for that length and it tells
24:48 : and it tells your program a bigger
24:51 : length
24:51 : than the actual images it could actually
24:54 : end up causing the program to read
24:56 : uh data from a different part of the
24:59 : program
25:01 : and that different part of the program
25:02 : might be some other information that the
25:04 : program is
25:05 : remembering and maybe the hacker can
25:08 : figure out a way
25:09 : to access that data that the
25:12 : act the hacker should not have access to
25:15 : so what may see
25:16 : language is designed this way um to have
25:20 : you
25:20 : at least have the ability to access the
25:23 : memory
25:24 : uh location directly well
25:27 : mostly it's historical right because
25:30 : back then
25:30 : people haven't come up with automatic
25:33 : memory management schemes yet
25:36 : so that just wasn't available they were
25:38 : dealing with very primitive tools
25:40 : c was already a huge step up like it was
25:44 : already a huge improvement
25:46 : versus assembly language programming
25:49 : right there there's a point in time
25:51 : where you didn't even
25:52 : have c this was the only thing they knew
25:55 : how to do
25:56 : back then gotcha right um but but
25:59 : having said that though there are
26:01 : advantages to having
26:03 : this level of access because like
26:06 : copying
26:07 : memory is one of the performance
26:09 : intensive things
26:10 : you can do with the program like when
26:12 : your program is slow
26:14 : oftentimes is because it's accessing
26:17 : memory
26:18 : in a poor way and when you have a low
26:20 : level of control like this
26:22 : you can come up with hacks that makes
26:25 : your program much much faster
26:27 : because you can smartly access the
26:29 : memory instead of
26:31 : copying stuff two three four times
26:34 : sometimes you can just smartly do
26:36 : everything in one pass and only have to
26:38 : copy thing
26:39 : one time so basically it's good for like
26:41 : a machine that has very limited memory
26:44 : yes
26:45 : exactly exactly such as cell phones
26:48 : those cell phones are you know very
26:51 : powerful now
26:52 : but it's not always that way so it
26:54 : definitely helps
26:55 : in embedded devices which is why uh when
26:58 : you
26:59 : write a iphone app for example they
27:02 : they still the apple team still not
27:05 : willing to go to something like
27:07 : javascript or java they still want to go
27:12 : low level at first they have objective c
27:15 : and now they have swift swift
27:18 : uses a memory management scheme
27:21 : called arc which again stands for
27:25 : automatic
27:26 : reference counting and objective c
27:30 : in the old days everybody who wanted to
27:33 : make an iphone
27:34 : app had to use objective-c even though
27:37 : it's a
27:38 : terrible programming language in my
27:41 : opinion
27:42 : but uh this is like a semi i would say
27:46 : semi-automatic arc is how i would
27:49 : characterize that i don't think we have
27:51 : time to
27:51 : talk about garbage collection or arc so
27:54 : maybe we can save it for next time
27:57 : but i do want to finish this discussion
27:59 : about memory management
28:00 : we can't end until we talk about how do
28:03 : you
28:04 : free the memory that you've allocated
28:07 : already oh that's true can you just
28:08 : override it
28:09 : why freeing if it's necessary can you
28:13 : just like
28:14 : yeah later
28:19 : this analogy of the registry like if if
28:22 : i
28:23 : allocated a block of memory to you the
28:26 : purpose of
28:27 : free is to later on just yield it to
28:30 : other programs or other parts of the
28:33 : program
28:34 : who might need to use memories like i'm
28:35 : not using this anymore
28:37 : you can mark that as unused so that
28:40 : other programs
28:41 : that do malloc later they can access
28:44 : that one
28:45 : why would you want to use free well if
28:47 : you continue
28:48 : to only allocate and not free the system
28:52 : might not have enough memory resources
28:54 : usually a system that doesn't
28:56 : process a large amount of data we'll
29:00 : never have a problem
29:01 : when your program completes all the
29:03 : memory is going to get freed anyway
29:05 : so that's not a problem it's only when
29:08 : your program is kind of long running
29:11 : and also it has to go through a lot of
29:13 : data
29:14 : or generate a lot of data and and then
29:17 : that could become an issue
29:18 : you you you're gonna end up mallocking
29:21 : for
29:22 : a lot of memory and if that keeps piling
29:25 : up
29:25 : without freeing you might run out of
29:27 : memory the way you freeze them
29:30 : i think it's just free
29:34 : let me make sure yes it's just free
29:38 : we don't get any indication though that
29:41 : it
29:41 : worked so i can i kind of just have to
29:44 : trust
29:45 : that it got freed um can you print the
29:48 : thing
29:48 : like uh the same like uh value of the
29:52 : memory location
29:53 : yeah so after upgrades okay i will
29:59 : i think it will still print it okay
30:03 : yeah you didn't change the reason is
30:06 : first of all
30:07 : i don't have any code clearly
30:10 : it's going to stay the same because i
30:12 : didn't reassign a value to god numbers
30:16 : i only passed it to another function
30:19 : and that function has no way of
30:21 : modifying
30:22 : my local variable here right
30:25 : and and i guess the second thing about
30:28 : it
30:28 : i know this seems counterintuitive for
30:32 : you because
30:32 : why can you still access the numbers
30:36 : after you freedom it it's even worse
30:40 : than that
30:40 : because even after i freed it i can
30:43 : still go back and print out the numbers
30:48 : yeah i i can as you can see
30:51 : because it doesn't matter you can access
30:54 : things
30:55 : that you have not claimed and and we
30:58 : already
30:58 : showed that previously with with these
31:01 : weird random numbers getting printed out
31:03 : that don't belong to you
31:04 : so now that you freed it these numbers
31:08 : this space no longer belongs to you but
31:10 : you can still
31:11 : access it so the only difference is
31:15 : maybe it's ready for allocation exactly
31:19 : yeah exactly it's not
31:22 : safe at all basically there's a system
31:26 : but there's no safeguards around the
31:28 : system okay
31:30 : uh yeah that's how it works it's a
31:32 : little
31:33 : weird it's it feels very low level and
31:36 : feels like you can hurt yourself really
31:38 : easily right
31:39 : yeah yeah exactly that's how c
31:42 : programming is
31:43 : and and when you're doing c programming
31:45 : you you need to be careful
31:46 : and you need to like double check things
31:49 : make sure you got things right yourself
31:51 : yeah but i guess i believe it's pretty
31:53 : useful for like you all have limited
31:55 : memory like a little
31:56 : machine that makes a robot or whatever
31:59 : like really small
32:00 : and then you only have this much memory
32:02 : to work with
32:04 : then you have to do something like that
32:07 : i think this is a good stepping point
32:09 : perhaps later
32:10 : we can talk about the the automatic
32:13 : memory management
32:14 : schemes