[MUSIC PLAYING]
>> DOUG LLOYD: OK so a suggestion before starting here.
If you haven't watched the video on pointers you might want to do so first.
Because this video is another way of working with pointers.
>> So it's going to talk about some concepts
that we cover in the pointers video, and we're
going to gloss over them now, assuming that they're already
sort of understood.
So that's just your fair warning that if you're seeing this video
and you haven't seen the pointers video, it might sort of
fly over your head a little bit.
And so it might be better to watch it in that order.
>> So we have already seen one way to work with pointers,
which is we declare a variable, and then we
declare another variable, a pointer variable, that points to it.
So we've created a variable with a name, we've
created a second variable with a name, and we point that second variable
at that first.
This sort of has a problem though, because it
requires us to know exactly how much memory we're
going to need the moment our program is compiled.
>> Why is that?
Because we need to be able to name or identify all of the possible variables
we might encounter.
We might have an array that might be able to hold a lot of information,
but it's still not exactly precise enough.
What if we don't know, what if we have no idea
how much we'll need at compile time?
Or what if our program will run for a really long time,
accepting various user data, and we can't really
estimate whether we're going to need 1,000 units?
>> It's not like we can say at the command line
enter how many items you think you'll need.
Well what if that guess is wrong?
Dynamic memory allocation sort of allows us the way
to get around this particular problem.
And the way it does it is by using pointers.
>> We can use pointers to get access to dynamically
allocated memory, memory that is allocated as your program is running.
It's not allocated at compile time.
When you dynamically allocate memory it comes from a pool
of memory known as the heap.
Previously all the memory we've been working with in the course
has been coming from a pool of memory known as the stack.
A good way to generally keep in mind-- and this rule
doesn't always hold true, but pretty much almost
always holds true-- is that any time you give a variable name it
probably lives on the stack.
And any time you don't give a variable a name,
which you can do with dynamic memory allocation, it lives on the heap.
>> Now I'm kind of presenting this as if there's these two pools of memory.
But you may have seen this diagram, which is generally
a representation of what memory looks like,
and we're not going to care about all the stuff at the top and the bottom.
What we care about is this part in the middle here, heap and stack.
As you can see by looking at this diagram,
these actually aren't two separate pools of memory.
It's one shared pool of memory where you start, in this visual
you start at the bottom and start filling up
from the bottom with the stack, and you start at the top and start filling up
from the top down with the heap.
But it really is the same pool, it's just
different spots, different locations in memory that are being allocated.
And you can run out of memory by either having
the heap go all the way to the bottom, or have
the stack go all the way to the top, or having the heap and the stack
meet up against each other.
All of those can be conditions that cause your program
to run out of memory.
So keep that in mind.
When we talk about the heap and the stack
we are really talking about the same general chunk of memory, just
different portions of that memory.
>> So how do we get dynamically allocated memory in the first place?
How does our program get memory as it's running?
Well C provides a function called malloc, memory allocator, which
you make a call to, and you pass in how many bytes of memory that you want.
So if your program is running and you want an integer runtime,
you might mallock four bytes of memory, malloc parentheses four.
>> mallock will go through looking through the heap,
because we're dynamically allocating memory,
and it will return to you a pointer to that memory.
It doesn't give you that memory-- it doesn't give it a name,
it gives you a pointer to it.
And so that's why again I said that it's important to maybe
have watched the pointers video before we get too far into this.
So malloc's going to give you back a pointer.
>> If mallock can't give you any memory because you've run out,
it'll give you back a null pointer.
Do you remember what happens if we try and dereference a null pointer?
We suffer a seg fault, right?
That's probably not good.
>> So every time you make a call to malloc you always, always
need to check whether or not the pointer it gave you back is null.
If it is, you need to end your program because if you try and dereference
the null pointer you're going to suffer a segmentation fault
and your program is going to crash anyway.
So how do we statically obtain an integer?
>> int x.
We've probably done that a bunch of times, right?
This creates a variable called x that lives on the stack.
How do we dynamically obtain an integer?
Int star px equals malloc 4.
>> Or more appropriately we'd say int star px
equals malloc size of int, just to throw some fewer
magic numbers around our program.
This is going to obtain for us four bytes of memory from the heap,
and the pointer we get back to it is called px.
And then just as we've done previously we
can dereference px to access that memory.
How do we get an integer from the user?
We can say int x equals get int.
That's pretty straightforward.
What if we want to create an array of x floats that live on the stack?
float stack_array-- that's the name of our array-- square brackets x.
That will create for us an array of x floats that live on the stack.
We can create an array of floats that lives on the heap, too.
The syntax might look a little more cumbersome,
but we can say float star heap_array equals
malloc x times the size of the float.
I need enough room to hold x floating point values.
So say I need 100 floats, or 1,000 floats.
So in that case it would be 400 bytes for 100 floats,
or 4,000 bytes for 1,000 floats, because each float takes up
four bytes of space.
>> After doing this I can use the square bracket syntax on heap_array.
Just as I would on stack_array, I can access its elements individually
using heap_array zero, heap_array one.
But recall the reason we can do that is because the name of an array in C
is really a pointer to that array's first element.
So the fact that we're declaring an array of floats on the stack here
is actually a bit misleading.
We really are in the second line of code there
also creating a pointer to a chunk of memory that we then do some work with.
>> Here's the big problem with dynamically allocated memory though,
and this is why it's really important to develop some good habits
when you're working with it.
Unlike statically declared memory, your memory
is not automatically returned to the system when your function is done.
So if we have main, and main calls a function
f, when f finishes whatever it's doing and returns control of the program
back to main, all of the memory that f used is given back.
It can be used again by some other program,
or some other function that gets called later on in main.
It can use that same memory over again.
>> If you dynamically allocate memory though
you have to explicitly tell the system that you're done with it.
It'll hold onto it for you, which could lead to a problem of you running out
of memory.
And in fact we sometimes refer to this as a memory leak.
And sometimes these memory leaks can actually be really devastating
for system performance.
>> If you are a frequent internet user you might use certain web browsers,
and I won't name names here, but there are some web browsers out there
that are notorious for actually having memory leaks that don't get fixed.
And if you leave your browser open for a very long period of time, days
and days, or weeks, you sometimes might notice that your system
is running really, really slowly.
And the reason for that is that the browser has allocated memory,
but then not told the system that it's done with it.
And so that leaves less memory available for all of your other programs
to have to share, because you're leaking-- that web browser
program is leaking memory.
How do we give memory back when we're done with it?
Well fortunately it's a very easy way to do it.
We just free it.
There's a function called free, it accepts a pointer to memory,
and we're good to go.
>> So let's say we're in the middle of our program,
we want to malloc 50 characters.
We want to malloc an array that can capable of holding 50 characters.
And when we get a pointer back to that, that pointer's name is word.
We do whatever we're going to do with word,
and then when we're done we just free it.
And now we have returned those 50 bytes of memory back to the system.
Some other function can use them.
We don't have to worry about suffering a memory leak because we have freed word.
We've given the memory back, so we're done working with it.
So there are three golden rules that should
be kept in mind whenever you're dynamically allocating memory
with malloc.
Every block of memory that you malloc must be freed
before your program finishes running.
Now again, in the appliance or in the IDE this sort of happens for you anyway
when you-- this will happen anyway when your program is terminated,
all the memory will be released.
But it's generally good coding practice to always, when you're done,
free what you have mallocd.
>> That said, only things that you've mallocd should be freed.
If you statically declare an integer, int x semi-colon,
that lives on the stack, you don't then want to free x.
So only things that you've mallocd should be freed.
>> And lastly, don't free something twice.
That can lead to another weird situation.
So everything that you've mallocd has to be freed.
Only things that you've malloc should be freed.
And don't free something twice.
>> So let's go through an example here of what some dynamically allocated
memory might look like mixed in with some static memory.
What might happen here?
See if you can follow along and guess what's
going to happen as we go through all these lines of code.
>> So we say int m.
What happens here?
Well this is pretty straightforward.
I create an integer variable called m.
I color it green, because that's the color
that I use when I'm talking about integer variables.
It's a box.
It's called m, and you can store integers inside of it.
>> What if I then say int star a?
Well that's pretty similar.
I'm creating a box called a.
It's capable of holding int stars, pointers to integers.
So I'm coloring it green-ish as well.
>> I know it has something to do with an integer,
but it's not itself an integer.
But it's pretty much the same idea.
I've created a box.
Both of these right now live on the stack.
I've given them both names.
>> int star b equals malloc size of int.
This one might be a little tricky.
Take a second and think about what you would expect to happen on this diagram.
int star b equals malloc size of int.
>> Well this doesn't just create one box.
This actually creates two boxes.
And it ties, it also establishes a point in a relationship.
We've allocated one block of memory on the heap.
Notice that the top right box there does not have a name.
>> We mallocd it.
It exists on the heap.
But b has a name.
It's a pointer variable called b.
That lives on the stack.
>> So it's a piece of memory that points to another one.
b contains the address of that block of memory.
It doesn't have a name otherwise.
But it points to it.
So when we say int star b equals malloc size of int, that right there,
that arrow that popped up on the right side there, that whole thing,
I'll have it appear again, is what happens.
All of that happens in that single line of code.
Now we'll get little more straightforward again.
a equals ampersand m.
Do you recall what a equals ampersand m is?
Well that's a gets m's address.
Or put more diagrammatically, a points to m.
>> a equals b.
OK so here's another one.
A equals b.
What's going to happen to the diagram this time?
>> Well recall that the assignment operator works
by assigning the value on the right to the value on the left.
So instead of a pointing to m, a now points to the same place that b points.
a doesn't point to b, a points where b points.
>> If a pointed to b that would have been a equals ampersand b.
But instead a equals b just means that and b are now
pointing to the same address, because inside of b is just an address.
And now inside of a is the same address.
m equals 10, probably the most straightforward thing
we've done in a little bit.
Put the 10 in the box.
Star b equals m plus 2, recall from our pointers video what star b means.
We're going to dereference b and put some value in that memory location.
In this case 12.
>> So when we dereference a point of recall we just travel down the arrow.
Or put another way, we go to that memory address
and we manipulate it in some way.
We put some value in there.
In this case star b equals m plus 2 is just
go to the variable pointed to by b, go to the memory pointed to by b,
and put m plus 2 in there, 12.
>> Now I free b.
What happens when I free b?
Remember what I said free means.
What am I saying when I free b?
>> I'm done working with it, right?
I essentially give up the memory.
I give it back to the system.
I don't need this anymore is what I'm telling them, OK?
>> Now if I say star a equals 11 you can probably
already tell that something bad is going to happen here, right?
And indeed if I tried that I probably would suffer a segmentation fault.
Because now, although previously that chunk of memory
was something that I had access to, at this point
now I'm accessing memory that is not legal for me to access.
>> And as we will probably recall, when we access memory
that we're not supposed to touch, that's the most common cause
of a segmentation fault. And so my program
would crash if I tried to do this.
So again it's a good idea to get good practice and good habits ingrained
when working with malloc and free, so that you don't suffer segmentation
faults, and that you use your dynamically allocated
memory responsibly.
>> I'm Doug Lloyd this is CS50.