Name: CS50 2016 - 第5週 - データ構造 (CS50 2016 - Week 5 - Data Structures)
Uploaded: 2021-01-14T06:57:29.000Z
Duration: 1 h 46 min 44 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

SPEAKER 1: All right, this is CS50 and this is week five.

And let's take a look at where we left off last time.

法助動詞 B1

You may recall this guy here, Binky from our friends at Stanford.

And we used Binky to start talking about pointers.

So, a pointer is just an address, the location

of some piece of data in memory, because recall at the end of the day

your computer just has a few pieces of hardware inside of it, one of which

And in RAM you have the ability to store bunches and bunches of bytes,

or kilobytes, or megabytes, or gigabytes,

And if you assume that no matter how much RAM you have you

can enumerate the bytes-- this is byte 0, this is byte 1, this is byte 2,

and so forth-- you can give each of the bytes of your computer's memory

an address and those addresses are simply called pointers.

And now in C we have the ability to use pointers

both to go to any location in memory that we want

and even to dynamically allocate memory in case we don't necessarily

know a priori how much memory we might need for a program.

Now, in terms of your computer's RAM, recall

that we divided the world into this picture

here whereby if this rectangular region, arbitrarily, represents your computer's

memory, here is how the computer divvies it up

At the bottom of your computer's area of memory, you have the so-called stack.

And recall that the stack is where any time you call a function,

it gets a slice of memory-- a frame of memory,

if you will-- for all of its local variables, all of its arguments

On top of that might go another slice or frame of memory

And if that second function in turn calls another function,

you might have a third frame on the stack.

Of course, this doesn't end well if you keep calling function after function

And so, hopefully you don't accidentally induce some kind of infinite loop

such that these frames pile on top of each other infinitely

many times, because eventually they'll run the risk of hitting the heap.

Now, the heap is the same type of physical memory.

You're just using it in a slightly different way.

The heap is used any time you want to dynamically allocate memory,

when you don't know in advance how many bytes

you need but you do know once the program is running how many you now

You can ask via functions like malloc the operating

system for some number of bytes, and those bytes

And so, the operating system, by way of malloc,

just figures out which of those bytes are not yet

being used so that you can now put whatever piece of data

Now, beyond that [? appear ?] things like initialized data,

That's where things like global variables that are initialized or not

end up that might be outside of your main function.

And then above that is the so-called text segment,

which are these zeros and ones that actually compose your program.

So when you double click an icon on Windows or Mac OS

to run a program or you type dot slash something in the Linux command line

environment in order to run a program, the bits that compose your program

are loaded also into memory up into this region here.

So, at the end of the day, you have access to just pretty generic memory,

And it allows us to ultimately solve problems

that we might not have been able to in the past.

Recall for instance this example here, deliberately shown in red because it

Now, logically, it does do the swap that we intend whereby a goes into b and b

And we achieve that result by way of this temporary variable

so that we have a temporary placeholder into which to store one of those values

But it had no permanent impact on the two variables that were passed into it.

And that was because by default in C any time you pass arguments to a function,

those arguments are passed so to speak, by value.

You get copies of those values being passed into a function.

And so, if main, for instance, has two variables, x and y--

as they did last time-- and you pass x and y

into a function like this one here swap, x and y

are going to get copied as a and b respectively.

So you might perfectly, logically, correctly swap a and b,

but you're having no permanent impact on x and y themselves.

But what if, per this green version here,

we reimplement swap to be a little more complicated

looking, but at the end of the day actually correct?

Notice now we've declared a and b not to be

integers but to be pointers to integers, the addresses of integers.

And that's what's implied by the star that we're putting

Meanwhile, inside of the body of this function,

And we're still using a temporary variable, and that in itself

It's just an integer as before, but notice

we're using this star notation again, albeit for a different purpose

Recall that int star a and int star b means give me a variable that

字幕リスト動画再生

CS50 2016 - 第5週 - データ構造 (CS50 2016 - Week 5 - Data Structures)

ultimately

sort

bunch

access