Original subtitles

[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.