Name: 數組和排序算法--計算機科學導論--哈佛的CS50（2018）。 (Arrays and Sorting Algorithms - Intro to Computer Science - Harvard's CS50 (2018))
Uploaded: 2021-01-14T10:51:30.000Z
Duration: 2 h 7 min 33 s
Description: 【看影片學英語】數萬部 YouTube 影片，搭配英漢字典即點即查，輕鬆掌握單字發音與用法，長久累積看電影不必再看字幕。

This is CS50 and this is the start of week two.

And you'll recall that over the past couple of weeks,

First initially from Scratch, the graphical programming language

that we then, just last week, translated to the equivalent program NC.

And of course, there's a lot more syntax now.

It's entirely text but the ideas, recall, were fundamentally the same.

The catch is that computers don't understand this.

DAVID J. MALAN: zeros and ones or binary.

And so there's a requisite step in order for us to get from this code to binary.

And what was that step or that program or process called?

And of course, recall as you've now experimented

with this past week that to compile a program,

And you can just say clang and then the name of the file

And that outputs by default a pretty oddly named program.

But recall too that you can override that default behavior.

And you can actually say, Output instead a program

But you can go one step further, and you actually use Make.

And Make it self is not a compiler, it's a build utility.

But in layman's terms, what does it do for us?

And it essentially figures out all of those otherwise cryptic

So that the program is built just the way

we want it without our having to remember

And though that only works for programs as simple as this.

In fact, some of you with the most recent problems that

might have encountered compilation errors that we actually

did not encounter deliberately in class because Make was helping us out.

In fact, as soon as you enhance a program

to actually take user input using CS50's library by including CS50 dot H,

some of you might have realized that all of a sudden the sandbox,

and more generally Clang, didn't know what get_string was.

And frankly, Clang might not even known what a string was.

And that's because those two are features of CS50's library

But it's not enough to teach Clang what they look like, as by including CS50.h.

Turns out there's a missing step that Make helps us solve

but that you too can just solve manually if you want.

And by that I mean this, instead of compiling a program with just Clang,

When you want to use CS50's library, you actually

need to add this additional command line argument.

Specifically at the end, can't go in the beginning like dash-O.

And this is a way of telling Clang, by the way when compiling my program,

please link in CS50's zeros and ones that we the staff

wrote some weeks ago and installed in the sandbox for you.

So you've got your zeros and ones and then

you've got our zeros and ones so to speak.

And dash-LCS50 says to link them together.

So if you were getting some kind of undefined reference error to get_string

you weren't able to compile a program that just used any of the get functions

Odds are, this simple change dash-LCS50 would have fixed.

But of course, this isn't interesting stuff to remember, let alone

remembering how to use dash-0 as well, at which point

And in fact, if you henceforth start running Make and then

pay closer attention to the fairly long line of output that it outputs,

you'll actually see mention of dash-LCS50,

you'll see mention of even dash-LM, which stands for math.

So if you're using round, for instance, you

might have discovered that round two also

doesn't work out of the box unless you use Make itself

So this is all to say that compiling is a bit of a white lie.

Like, yes you've been compiling and you've been going from source code

But it turns out that there's been a number of other steps happening

for you that we're going to just slap some labels on today.

At the end of the day, we're just breaking the abstraction.

So compiling is this abstraction from source code to machine code.

Let's just kind of zoom in briefly to appreciate

what it is that's going on in hopes that it makes the code we're

So step one of four, when it comes to actually compiling a program

So recall that this program we just looked at had a couple of

These are generally known as pre-processor directives.

Not a particularly interesting term but they're

字幕列表影片播放

數組和排序算法--計算機科學導論--哈佛的CS50（2018）。 (Arrays and Sorting Algorithms - Intro to Computer Science - Harvard's CS50 (2018))

literally

sort

context

access