>> SPEAKER 1: Hi everyone.
We are going to get started.
I think people are still going to be filtering in.
But in the interest of time, so we can get you guys out of here on time,
we're going to start.
So welcome to the CS50 Quiz 0 review.
For those of you who haven't realized yet, you have a question on Wednesday.
Woo-hoo.
>> If you haven't started studying yet or haven't realized that this exists yet,
past quizzes and all information about your quiz are on cs50.net/quizzes.
There's some pretty good stuff on there, past quizzes from the last 10
years as well as information about this quiz and topics
that will be covered.
So let's get started.
>> So you guys might remember, the first day of class David had those lamps on.
So essentially, everything that goes on under the hood of a computer is
done in binary.
Binary means what it sounds like, 0's and 1's.
It has two values that can be represented.
>> So just like in the first day of section when David turned on a light
bulb to represent on, or 1, our computer understands binary as 0's and
1's, on or off.
Basics of Binary.
Every place is represented in base two.
So you add 2 to the 0 to the 1 to the 2 all the way up.
>> To calculate what your binary is to decimal, you just follow this equation
type thing.
If you have a 1 in any of those places, you multiply it by whatever
base it's in, add it up, and you get the decimal.
So this is how you count to 5 in binary.
Just like what we were doing on the last slide, this is how you would
represent 1 through 5.
>> Similarly, just like you can add and subtract in decimal or base 10, or
really any base, on can add and subtract in binary.
Exactly what you would expect when you add the two up, if it equals greater
than 1, you carry a 1, make it a 0, and do the addition that way, just
like you would expect with regular decimal or any other base.
Cool.
>> So like I said before, everything that goes on under the hood of our computer
is done in 0's and 1's, or binary.
So how do we express, for example, letters, or numbers, or characters?
And the answer to that is ASCII.
>> ASCII is a mapping between characters that we would normally see in the
English language like A's, B's, C's, underscore, dashes, and
anything like that.
And it maps that to an ASCII value.
An ASCII value is just a number that can be understood by your computer.
And just like you can do addition and subtraction with numbers, you can do
them with ASCII values.
>> So in this example, what will this print out?
Yeah, so just A space B space C space D. Where did my mouse go?
Notice you can define an int at 65.
And when you print that out using percent C, it'll interpret that as a
character and will print out A.
>> Similarly, you can declare it as a char.
And when you print it out using percent C, it'll interpret that as
percent D. And just like you can add a number, you can add characters are
ASCII values, in this case.
>> So a little pointer for everybody.
5, as a string, does not actually equal 5.
So how might we convert the string 5 to the integer 5?
Any ideas?
Yeah.
>> So if we have 5 as a string, we can subtract 0.
And that'll give us 5.
And similarly, if we have 5 as an integer, add that to the string 0.
And that gives us the string 5.
Cool.
>> Now, recall back to lecture one where we talked about algorithms.
So how do we actually want a computer to do interesting things?
You know, just adding and subtracting numbers and printing things out is not
that exciting.
Usually, we want our computer to perform some kind of algorithm.
Something a little more complex than just simple arithmetic.
>> An algorithm is just a step by step set of instructions for how to perform
a certain task--
just like a recipe.
You might remember the first day of class where David had us count a room
of people and how many people were in the room.
You might be used to counting one by one.
1, 2, 3, 4.
In that case, a linear time algorithm.
>> But David introduced an algorithm for you to count the people in the room
where everyone stands up, you say your number to another person, add that
number up, and one person sits down.
And you repeat that.
That's one type of algorithm.
We can analyze how efficient an algorithm is based on it's run time.
But we'll talk a little bit more about that later.
>> So all algorithms can also be written in pseudocode.
Pseudocode is just an English like syntax used to represent
a programming language.
For example, if we wanted to ask a user to guess my favorite number, we
might have pseudocode as such.
>> Get a users guess.
If the guess is correct, tell them they're correct, else tell them
they're not correct.
And pseudocode is a way of easily representing an idea or an algorithm.
So now we might want to actually write this in the language that the computer
might understanding.
So we could write our pseudocode and interpret that into source code.
>> So far, source code must adhere to a certain syntax of
a programming language.
And so far, in CS50, we've been using mostly c.
So this might be source code for c.
Later on in the course, you night come into contact with other programming
languages like PHP.
Or if you even take other classes, you might do Java, Python, or even OCML.
But in our c program language, this is how we might write the source code for
the pseudocode algorithm that I just described earlier.
>> So how does your computer actually understand that?
Like I said before, it only really understands zeros and ones.
So how does it get from the source code to something that can be
understood?
Well, we have something called a compiler.
>> If you recall back in most of your psets, you had some kind of program
written in a dot c file.
And then you would type make.
So what is make doing?
>> You can type make to compile your program because someone--
whoever wrote your p set; probably David--
created a make file.
And that tells make to know to run your compiler, called clang, that will
then compile your source code to object code, which is zeros and ones
that your computer understands.
But a little later on, we will go more in depth about compilers.
>> So recall pset 0, where-- yes, you have a question?
>> AUDIENCE: [INAUDIBLE]?
>> SPEAKER 1: Yes.
I think they actually should be online.
Yeah.
>> AUDIENCE: Is it like [INAUDIBLE]?
>> SPEAKER 1: It is not.
The are on cs50.net/quizzes.
>> AUDIENCE: Slash quizzes, slash 2013, slash 0, and just click through
quizzes 2013 and quiz 0, review section slides.
>> SPEAKER 1: Yeah, so if you guys want to pull it up and look at it on your
own computer, that's fine too.
Say that again.
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER 1: Yeah, [INAUDIBLE] is the dummy variable.
Oh, yes?
>> AUDIENCE: [INAUDIBLE]?
>> SPEAKER 1: No, strikes are not on the exam.
Sorry, her question was, was strikes on the exam.
And it is not.
So pset 0, you guys should have all implemented something using scratch.
And we learned some basic programming building blocks using scratch.
>> So let's take a look at some of these building blocks
that make up a program.
First is Boolean expression.
Boolean expressions are ones and 0's or anything that has
two possible values.
In this case, true or false, on or off, and yes or no.
An example of a simple, very simple, program that uses a Boolean
expression up here.
>> So in order for Boolean expressions to be useful, we have Boolean operators.
These are operators that can be used to compare certain values.
So we have and or not equal to, less than or equal to, greater than or
equal to, and less than or greater than.
But these operators aren't very useful unless we can combine them into
conditions.
>> So you guys might remember from scratch and from your p sets that we
had conditions.
They are, essentially, like forks in the logic of your program that
executes depending on whether a condition is met.
So one of the conditions that we had used many times in this course is the
if, else, if, and else conditions.
>> Here's an example of how you might use that.
Does anyone know the difference between just using if statements all
the way down verses if, else, if, and else combined?
Yes?
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER 1: Exactly.
So if I had if all the way down this way, even if this condition returns
true, it will still continue testing the next two.
Whereas, with an else-if, an else statement, if the one returns true,
the others are not tested.
Any questions about that?
Cool.
>> So you use an if-else of an else statement if you know that it can only
be one of these cases.
So we know if x is less than 0, it's definitely not going to be
greater than 0.
>> Next, another building block that we learned are loops.
We have three types of loops.
For loops, while loops, and do while loops.
And generally, when you sit down to write something, you have to decide
which of the three you want to use.
So how do we decide which one?
>> We generally use a for loop if we know how many times we want to iterate
through something or how many times we want to perform a task.
We use while loops if we need some condition to be true to keep running.
And we use do while very similar to while, but we want our code to run at
least one time.
>> So do while, whatever is in the do will always run at least one time.
Whereas, with the while, it may not run at all if the
condition is not satisfied.
Any questions with that?
>> So structure of a for loop.
You guys have all seen this.
You initialize it.
You have some kind of condition.
So, for example, we might initialize as for i equals 0.
i is less than 10.
And i++.
Very simple one that we've done.
>> For a while loop, similarly, you have to have some kind of initialization,
some kind of condition, and some kind of update.
So we can implement our for loop also as a while loop using this.
And similarly with a do while loop, we might have some initialization,
execute something, update it, and then check the condition.
>> So now functions.
We put everything together.
We might want to write some kind of function.
Common function that you might have seen already is main.
Main is a function.
It has a return type, int.
It has a function name, main.
And it has arguments, argc and argv.
So main is just a function.
>> Other functions you might have used, printf-- printf is a function--
GetInt, toupper.
But these happen to have been implemented for us by
some kind of library.
If you guys remember including this CS50.h library or the
standard I/O library.
Yes, question?
>> AUDIENCE: Is main just inherent in c?
Does it just kind of [INAUDIBLE]?
>> SPEAKER 1: The question is if main is inherent in c.
And yes, all functions have a main function.
It's kind of necessary for the computer to know where to start
running the code.
>> AUDIENCE: So you wouldn't [INAUDIBLE]?
>> SPEAKER 1: No.
Any other questions?
Cool.
So just like you can use a function that's written for you, you can also
write your own function.
This is a function that someone might have written to calculate the volume
of a q, for example.
There's a return type here, in this case int, our function name q and our
list of parameters.
>> And note that you have to write the data type of the parameter you want to
use or else the function doesn't know what kind of
parameter should I be accepting.
So, in this case, we want an integer as our input.
So why might we want to use functions?
>> First of all, great for organization.
They help break up your code into more organized chunks and make
it easier to read.
Simplification.
This is good for design.
When you're reading a piece of code and the main function is really,
really long, it might be harder to reason about what's going on.
So if you break it down into functions, it might be easier to read.
And reuse-ability.
If you have a chunk of code that's being called or run multiple times,
instead of rewriting that code 10 times in your main function, you might
want to reuse it.
And then every time you need to use that piece of code, call the function.
>> So now if we remember back to scratch, we also talked about a few concepts,
one of which is threading.
Thread is the concept of multiple sequences of code
executing at the same time.
So think back to day one where David had you guys count off the number of
people in the room.
>> Essentially, what was going on is all of you guys were
running separate threads.
And those threads were coming together to get some kind of answer.
Similarly, in Scratch, when you have multiple sprites, you might
have a cat and a dog.
And they would be simultaneously running their own scripts.
That is an example of threading.
>> And the other concept that was introduced in scratch was events.
And events are when multiple parts of your code communicate with each other.
In Scratch, this was when you used the broadcast control and the When I
Receive blocks.
>> And also, in Problem Set 4, we saw a little bit of events as well.
You guys might have used the Gevent library.
And there was a function waitForClick in which you were waiting
for the user to click.
And your click, in this case, would be the event and wait for click is your
event handler.
>> And also, throughout running your psets and working on your psets, you
might have come into contact with some of these commands.
This is what you typed into your terminal window or whatever window
that shows up on your g edit to, essentially, navigate your computer.
>> So for example, LS lists the contents of a directory.
Make directory creates a new folder.
CD, change directory.
RM, remove, deletes a file or some directory.
And then remove directory removes a directory.
>> AUDIENCE: [INAUDIBLE]?
>> SPEAKER 1: Yeah, sure.
Sorry, the question was if you would suggest putting this
on the cheat sheet.
It could help.
If you have room, you can put it on.
It's also just generally good enough to remember because when you use it
you might want to just have it memorized.
That'll make your life a lot easier.
Did I answer your question?
>> So now, we talked a little bit briefly about libraries.
But the two main ones that we've been using so far in the course are
standard I/O and cs50.
What kind of things are included in the standard I/O library?
>> Yeah, so far we've used printf.
In cs50, we've used GetInt and GetString.
And the data type string also happens to be declared in this cs50 library.
We'll talk a little more in depth about how libraries work and how they
interact with the rest of your code.
But those are the two main ones that we have come in contact with so far in
the course.
>> Types.
These are good to remember how much each type is represented by or how
many bytes each of type requires--
int, 4 bytes; char, 1 byte.
Float is 4 bytes.
What is a double?
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER 1: Yeah, so a float but double the size.
What about a long?
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER 1: OK.
What is a long?
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER 1: Yeah, double an int.
Yes.
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER 1: Long [INAUDIBLE].
And then a long long is double that.
>> AUDIENCE: No, no.
A long is just an int.
It depends on the architecture before the [INAUDIBLE]
and int have the same size.
[INAUDIBLE].
>> SPEAKER 1: So a long and an int are the same.
And then a long long is double the int.
Cool.
And then, what is the last type?
>> AUDIENCE: Pointer.
>> SPEAKER 1: Yeah, so we learned a little bit about pointers.
And regardless of what a pointer is pointing to-- it could be a char star
or an int star--
it's always 4 bytes for a pointer.
Questions about that?
Yes?
>> AUDIENCE: [INAUDIBLE]?
>> SPEAKER 1: So a long and an int are the same in this cs50 appliance.
>> AUDIENCE: The appliance are completely interchangeable.
>> SPEAKER 1: Yeah.
So then a long long is double an int.
>> AUDIENCE: This is the 32 bit?
>> SPEAKER 1: 32 bit, yeah.
>> AUDIENCE: So [INAUDIBLE]?
>> SPEAKER 1: Yes, if it doesn't explicitly say, you
should assume a 32 bit.
>> AUDIENCE: It would say something like assuming an
architecture like the appliance.
For 64 bit, the only things that change are longs and pointers.
They both [INAUDIBLE].
>> SPEAKER 1: Yes?
>> AUDIENCE: Question.
So on one of the practice quizzes, it asks about an unsigned int.
So how would that be determined from an int [INAUDIBLE]?
>> SPEAKER 1: An unsigned in is also 4 bytes.
But what is different about a signed int and an unsigned int?
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER 1: Right.
One can represent negative values.
But how does it do that?
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER 1: Yeah, it saves 1 bit to represent the sign.
The signed has one bit that represents the sign.
And unsigned just is all positives.
>> AUDIENCE: OK.
So you say that a double is twice the size of a float?
>> SPEAKER 1: Double is twice the size of a float, yes.
>> AUDIENCE: How does a pointer to a long long [INAUDIBLE]?
>> SPEAKER 1: So the question is how does the pointer to a long long--
how is that only four bytes when a long long its 8 bytes.
So remember what is a pointer, essentially, at the very base value.
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER 1: Yeah, so a pointer is just a memory location.
So it doesn't matter how much space that pointer is pointing to.
It only needs 4 bytes to keep track of that memory location.
Any other questions?
Cool.
>> So the last thing I have is standard output.
You should use them frequently enough that you can remember.
But this is when we use printf, for example.
And we have these placeholders that were called format codes.
>> So percent c char, percent i for int, and we can also use percent d.
It's the same thing.
But, generally, in CS50 we try to use percent i.
Percent f for float.
Percent ld for long long and percent s for string.
>> Similarly, we've been using a few of these escape sequences.
For example, backslash n for new line.
This is just for when you're formatting your code for print f.
Yes?
>> AUDIENCE: What is percent d for?
>> SPEAKER 1: So the question is what is percent d for?
Percent d is for ints.
Percent d and percent i are the same.
>> AUDIENCE: What's the difference between backslash n and backslash r?
>> SPEAKER 1: So the question is what's the difference between backlash n and
backlash r?
I think backslash r is--
>> AUDIENCE: So backslash r just implies returns to the beginning of the line
without actually going to a new line.
So if you print a backslash r and you go back to the beginning of the line
then you print more stuff, you overwrite the stuff that's already on
[INAUDIBLE].
Whereas, n actually goes to a new line and goes to [INAUDIBLE].
>> SPEAKER 1: Well, any other questions?
All right.
I'm going to hand it off to Dan who will continue.
>> [APPLAUSE]
>> DAN: All righty.
So I'll be talking about another wide range of ideas from the class that are
roughly representative of week two and the start of week three starting off
with casting, which is just a way of treating a value of a certain type as
a value of a different type.
So we can do this with chars to ints, floats to ints, and
long longs to double.
>> All of these things can be used as ways of treating some numeric value
minus char as some other numeric value.
So there are some issues with this, of course, which comes when you cast
things like float to ints.
So this is a little weird.
We have a float that is 1.31.
We multiply it by 10,000.
And then we print it as an int.
What does this output?
10,000 times 1.31.
So 13,000, is that the guess?
>> AUDIENCE: I think it's 10,000.
>> DAN: So I'm multiplying it by 10,000 before I'm casting it.
>> AUDIENCE: Oh.
Wouldn't there be one 9 and some 0 numbers?
>> DAN: You might have some weird digits.
So right, it's 1.3 times 10,000.
So that's 13,000.
And this extra weird--
>> AUDIENCE: 13,100.
>> DAN: 13,100.
Thank you, Rob.
And this extra weirdness--
this 9,9--
is simply because this casting ended up rounding down where
it shouldn't have.
Yeah.
>> AUDIENCE: The casting happens after anything else?
>> DAN: So because I have this in print, it does this multiplication before it
does this casting.
>> AUDIENCE: [INAUDIBLE].
>> DAN: I think it would cast first, yeah, which would be 10,000.
Anything else?
Cool.
So this is 13,099.
Why does this happen?
Imprecision.
>> Floats aren't perfect.
They can only represent numbers to a certain number of significant figures.
So if we print out 8 sig figs on this float, we get a kind of
ugly looking number.
And that's because 1.31 can't accurately be represented by simple
powers of two in the machine.
So it ends up taking the closest guess, which ends up
being a little low.
Make sense?
OK.
>> Now, switched are a different way of doing conditional statements where all
we care about is a single variable.
So in this particular example, we're getting an integer from the user.
And then we're looking at what that integer is.
Presumably, it's number between one and four.
That's what we're asking for.
>> So you do a switch of the variable name.
Then you set up cases of possible values it could be.
So case one, say it's low.
And then you break to get out of the switch condition so
you don't keep going.
>> In the next case--
so case two and case three--
if it's case two it just drops down to the first line of code it sees as with
case three until it sees a break.
So the reason you get case one to only print low is because I
have this break here.
If I, say, ignored this break-- if I threw this breakaway--
it would print low, and then it would print middle, and then it would break.
>> So breaks are an important part of switch conditions and
they should be there.
Any cases that are not stated explicitly are handled by the default
case in the switch and should be cast.
>> AUDIENCE: So 1, 2, 3, and 4 would be n?
>> DAN: Values that n can be.
Yes.
Yeah?
>> AUDIENCE: So when you have that [INAUDIBLE]?
>> DAN: You would print low, and then it would print middle, and
then it would break.
>> AUDIENCE: Why would it print middle if [INAUDIBLE]?
>> DAN: So everything under a case before a break falls under.
So case one print is underneath case one as is this following print.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> DAN: So this number is just a particular value that this variable
can take, right?
Does that make sense?
Yeah.
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Yes, case two would print middle and then break.
>> AUDIENCE: [INAUDIBLE]?
>> DAN: I think any?
What other data types can you switch over?
>> AUDIENCE: You can switch over any data types.
But it only means anything over chars and ints and stuff like that, because
if you're switching over a pointer that doesn't really make sense,
switching over loads, if it even let's you do that, because of floating point
in precision, you wouldn't really want to do that anyway.
So pretty much, just ints and chars and stuff like that.
>> DAN: Yeah, it's when you have explicit values that you know, I think, can be
that a switch is actually useful.
Good?
OK.
>> Scope is the range that a declared variable extends.
So in this little chunk of code I have, it would be full of errors.
And the reason is I declared this int i within the scope of this for loop.
And then I'm trying to reference that i outside of that for loop scope.
>> So basically, you can think about scope as anything that you declare
with inside a set of curly braces only exists within those curly braces.
And if you try and use that variable outside of those curly braces, you'll
get an error from the compiler.
Yeah?
>> AUDIENCE: So this one doesn't work?
>> DAN: This doesn't work, yes.
Strings.
String a char*.
They're exactly the same.
They are just pointers to characters.
And any strings that you have should end with backslash zero, which is just
a c convention.
>> It is called the NULL terminator.
And NULL--
capital N, capital U, capital L, capital L--
is not the same as the NULL terminator.
This is a pointer.
This is a character.
They are very distinct.
Remember it.
It will be on the quiz, probably.
I haven't seen the quiz.
Yeah?
>> AUDIENCE: So NULL is, say, the pointer?
>> DAN: Yes.
>> AUDIENCE: What does [INAUDIBLE]?
>> DAN: If, say, malloc is called when you don't have enough memory to get
whatever size you're asking for, malloc will return NULL.
It's, basically, whenever a function is supposed to return a pointer, you
need to check against NULL because NULL is a pretty good--
it's, sort of, the garbage value.
It's a zero as far as pointers go.
>> Whenever you call a function, that returns a pointer.
You're going to want to check to be sure that that pointer isn't NULL
because NULL is very common.
It's sort of a garbage return.
So if something didn't go right, just return NULL instead.
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Yes, and that's this.
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Spell it as this.
It's the NULL terminator.
It's lowercase N-U-L-L if you're spelling it.
>> AUDIENCE: And I just went back and tested it.
And if you try to put a floating point value into a switch, it'll yell at you
saying, statement requires expression of integer type.
>> DAN: There you go.
But yeah, what was the question again?
>> AUDIENCE: [INAUDIBLE]?
>> DAN: So capital N, capital U, capital L, capital L is an actual c thing.
It is the NULL pointer and will only be treated as such.
You won't ever try and spell the NULL character and see any
other way than this.
Yeah?
>> AUDIENCE: So returning to char max or something in the notes, would it
embody the same function as [INAUDIBLE]?
>> AUDIENCE: So are you referring to returning char max from getchar, or
whatever it is?
>> AUDIENCE: Yeah.
>> AUDIENCE: Yeah, so the general term for all those things
are sentinel values.
So like returning int max from GetInt and char max from getchar, it's
supposed to be like, all right, if these things are returning to us,
something went wrong.
>> For pointers, we just happen to have this sentinel value that everyone
agrees upon.
And this is the thing you return when things go wrong.
So char max is what we're using to represent something
like NULL or getchar.
>> AUDIENCE: So if you're testing getchar, could you just put NULL?
Would that make a difference?
>> DAN: You couldn't just check NULL.
You'd have to check char max because the return value from the function is
a character not a pointer.
Yeah?
>> AUDIENCE: This question asks for the string length.
Does that include the NULL character?
>> DAN: No.
And that's actually how string length knows to stop because it goes through
your array of characters until it sees a NULL character.
And then it's like, all right, I'm done.
>> AUDIENCE: [INAUDIBLE] five?
>> DAN: Hello would be five.
Yep.
So arrays are continuous blocks of memory.
They have instant access by saying the name of the array and then, in curly
braces, whatever index you want to go to, they're indexed from zero through
the length of the array minus 1.
>> And they're declared by the type of the thing that you're storing in the
array, the name of the array, and then whatever the size is of that array.
So this is a char array of length six that has these values.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Yeah.
>> AUDIENCE: [INAUDIBLE]?
>> DAN: If you have what is going into the array already made.
So you could specify this instead as, say, char, whatever the name of your
array is, empty brackets equals curly brace H comma E comma L comma L comma
O comma NULL character and curly brace.
That would also work as a declaration.
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Then you need to have the size already made.
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Yes.
All righty.
Command line arguments are a way of getting input from the user as
arguments to main.
Main takes two arguments.
The number of arguments that is being passed along the command line and a
string vector or a string array of all of the arguments.
>> So if I, say, called a function such as a dot out 1 space, 2 space, three,
argc would be 4.
And the argv 0 would be a dot out.
Argv1 would be 1.
argv2 would be 2. argv3 would be 3, in that particular case.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> DAN: The last element in the array because the array is length argc plus
one of argb, the last element is the NULL pointer.
It is argc plus 1.
So in the case that I just said, it would be argv 0 is a dot out.
argv 1 is 1. argv2 is 2. argv 3 is 3.
argv 4, which is one larger than argc would be NULL.
>> And that's the NULL pointer.
Yes.
And that's because string is a char star is a pointer.
So it has to be the same type.
Yeah?
>> AUDIENCE: Two questions.
So one, what's the difference between this and GetString other than one type
in the user engine?
And two, is it stored within your recent memory?
So like, GetString would be [INAUDIBLE]?
>> DAN: Where is it stored?
I don't know where it's stored.
>> AUDIENCE: So, actually, you know how any function you call it's arguments
are stored in the stack?
So argc and argv are arguments to main and they are on the stack, or really
just above what you think as the start of the stack.
What was the other part of the question?
>> AUDIENCE: So what's the [INAUDIBLE]?
>> DAN: Yeah, it's just a different way of getting input from the user.
This one's slightly more efficient and it's handier for scripts because you
can just pass arguments to your main function rather than having to wait
for users if you don't have any users.
>> AUDIENCE: And yeah, get strings would be [INAUDIBLE].
It would store the stuff you need.
>> DAN: Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Yes, argv 0 always includes the dot slash of the function call.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Yes, each of the arguments are ended in NULL character because they
are strings.
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Yes, argv argc is a NULL pointer.
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Oh yeah.
Yeah, sorry.
>> AUDIENCE: So [INAUDIBLE]?
>> DAN: So the question is if you had the command line dot slash a dot out 1, 2,
would the number of command line arguments be two or would it be three?
>> AUDIENCE: I think it doesn't really matter.
I tend to say, oh, you didn't pass any command line arguments when,
obviously, you called the function.
So I tend to vocally exclude the function from the command line
arguments even though it's included in argv.
>> DAN: But if it was on the test--
yeah-- and also if you say something like argc equals 3,
you're in safe standing.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> DAN: I think if instead of calling this in argc and string argv brackets
but kept the same types and just called them something different like a
and b, would it still work?
And it would still work, you would just--
instead of using argc-- you'd use a and b.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> DAN: So the question is GetString is going to store memory in the heap
because GetString is char*.
It stores memory in the heap because it calls now malloc within the actual
implementation of GetString.
OK, moving on.
>> Security.
So to be truly secure, you rely on no one and you allow no one access to any
of your information, which is why everyone builds their own machines,
their own operating systems, all their programs from scratch, and obviously
don't connect to any other machines via the internet.
So computers are insecure.
They really are.
We have to trust other people.
>> And the idea of security is that you're trying to limit the amount of
trust that you need.
And one of the means you do that is through cryptography.
Cryptography is, essentially, we have secrets.
>> Sometimes we have to pass our secrets along through, say, the internet or
other things.
And we don't want people to know these secrets.
So we encrypt our secrets into a way that we hope no one can figure out.
>> So we used--
through the course of this class--
things like Caesar cipher and [INAUDIBLE], which are both very, very
insecure ways of encrypting things.
They're easy to figure out what they are and what your secrets are.
The real world uses much more complicated encryption schemes.
And we won't get into much more than that.
>> Debugging.
GDB is the best.
I'm going to stress this again.
Use GDB all the time every time you have a problem.
Commands that are useful in GDB are break, which you pass either a line
number, a function name, essentially where in your code you want to stop,
and be able to take control.
>> Print takes a variable and prints out whatever that variable is at that
point in your execution.
Next moves your execution along one step.
And step steps inside a function in your execution.
>> Other things are run, which is how you actually run your code.
Continue takes all the steps needed to get to the next break point.
And there are many, many others.
Look them up.
They're great.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Yes, which is a debugger.
So a debugger is a program that lets you debug your program.
It's not a program that finds bugs for you, though that would be great.
>> And last for me is search.
So the types of search that we talked about in this class are linear search,
which is just that you look through each element of the search space, one
element at a time, until you find what you're looking for or until you reach
the end of your search space at which point you say that you couldn't find
the element that you were looking for.
And this takes at best constant time, which is 0 of 1 and at worst linear
time, which is 0 of n.
>> Binary search, which needs sordid elements.
You go to the middle of your elements, see if the element you're looking for
is larger or smaller than the element that you're at the middle.
It it's larger, you say that the bottom of your search space is your
current location, the middle, and you restart the process.
If it's smaller, you look say that the-- yeah, what's up?
>> AUDIENCE: [INAUDIBLE]?
>> DAN: Yes.
Any sort of sort that's been taught in the class is fair game for the test.
>> [LAUGHTER]
>> DAN: And the fact that you haven't had to do it for a problem set, it's fair
game for the test.
>> AUDIENCE: Can we go over it how to--
>> DAN: It will be gone over.
>> SPEAKER 2: The actual code for [INAUDIBLE] is on study.cs50.net.
So if you look at the practice problem in the merge sort page of
study.cs50.net, there is the code for implementing merge sort.
So you don't have to implement it yourself tonight.
But make sure you understand it rather than just memorizing it.
>> AUDIENCE: [INAUDIBLE]?
>> SPEAKER 2: The merge sort page on study.cs50.net, there is a practice
problem that, if you click through the problem, at the very end there is a
solution, which is the merge sort implementation.
But make sure you understand it rather than just memorizing it
or copying it down.
>> AUDIENCE: And a perfectly valid problem for the exam would be
something like here's a list.
What does this list look like after one step of selections sort or
insertion sort or whatever.
One full iteration of the list.
So even if you don't end up needing to code for it, you need to understand it
enough to know how it's going to be modifying this array.
>> DAN: That's it for me.
>> [APPLAUSE]
>> LUCAS: Hey everyone.
My name is Lucas.
I'm going to talk about recursion, all the sorts that we have learned, and a
little bit of all pointers.
OK?
So first of all, recursion.
What does it mean to say that a function is recursive?
>> AUDIENCE: Calls itself.
>> LUCAS: OK, calls itself, yeah.
So like this picture, for example.
It's like the picture inside of a picture and so on.
So for example, you can have-- as Dan that was talking about binary search.
One way in which binary search is recursive is the fact that you're
trying to find a number.
So you go to the middle.
And then you check if the numbers there in the left and in the right.
>> And then if you find out the number is going to be on the left, it's the same
thing as doing the search again but just on the left of the list.
So that's how it sounds like it's recursive.
So that's why you guys have recursive solution for merge sort.
>> OK, so here's an example.
So let's say that I want to choose all the numbers from 1 to n.
I can realize that the sum of the n number is n plus n minus 1 up to 1.
But then, if I look at n minus 1 plus n minus 2 plus 1, that's the same
thing as summing numbers up to n minus 1.
So I can say the sum of an equal sum equals n plus the sum of n minus 1.
Does that make sense?
>> And I also would have something else called the base case, which is that
the sum of the numbers up to zero would be zero.
So as soon as I get to the number zero, I stop counting.
Does that make sense?
>> So here's an example of how I can implement that.
So I have this function in some.
That takes an integer n.
So here I first check if n is less or equals to zero.
So if it's less or equal to zero, I return zero, which is our base case.
Otherwise, I can just return n plus the sum of the numbers from
one to n minus one.
Make sense?
OK.
>> So here's what it looks like.
You have sum of 2 equals 2 plus the sum of 1.
And some of 1 is 1 plus the sum of 0, which is 0.
Make sense?
So if we look at the stack of your program, this is what it looks like.
>> First, we have the main function.
And then the main function called sum 2.
And then sum 2 is going to say, oh, sum 2 equals 2 plus the sum of one.
So I add sum of 1 to the stack.
And the sum of 1 is going to call sum of 0, which is also going to be added
to the stack.
And then each of these ones that are on top of another have to return
before the other ones can keep going.
>> So for example, here, sum of 0, first, is going to return 0.
And then choose sum of 1.
Then sum of 1 is going to return 1 to sum of 2.
And finally, sum of 2 is going to return 3 to main.
Does that make sense?
>> It's really important to understand how the stack is working and try to
see if it makes sense.
OK, so sorting.
So why is sorting important, first of all?
Why should we care?
Anyone?
Give me an example?
Yeah?
>> AUDIENCE: [INAUDIBLE].
>> LUCAS: Yeah, OK.
So you can search more efficiently.
That's a good way.
So, for example, we have a lot of things, actually, in our lives that
are sorted.
For example, dictionaries.
>> It's very important to have all the words in some kind of order that we
can access easily.
So that's what he was saying.
You can search more efficiently.
Think of how hard it would be to have a dictionary in which the words are in
random order.
You'll have to look at, pretty much, every single word until you find the
word that you're looking for.
>> If you're using Facebook also, when you're looking at your friends, you're
going to see that Facebook put your closer friend's on top of the ones
that you don't talk to that much.
If you go all the way to the bottom of your friend list, you're going to see
people that you probably don't even remember that you're friends with.
And that's because Facebook sorts your friends based on how
close you are to them.
>> So organizing data.
Also Pokemon.
So you see that all Pokemons have numbers.
And that's like an easy way of accessing data.
>> AUDIENCE: Accessing Pokemon.
>> LUCAS: Yeah.
>> AUDIENCE: [INAUDIBLE].
>> LUCAS: Yep.
OK, so selection sort.
Selection sort is going to select the smallest unsorted value of a list each
time in each iteration.
It's kind of like the sort that you do in your head when you're trying to
sort a list on hand.
>> Basically, all you do is you look for the smallest number.
You put it in the sorted list.
And then you look for the next smallest number.
And then you keep doing that and so on.
>> So selection sort is basically you select every time the smallest
unsorted value.
Put at the end of the sorted part of the list.
And keep doing that.
So let's quickly see what this looks like.
So here's the sorted and unsorted list.
>> So for the sorted of list, it's initially empty.
And then I'm going to select the smallest number here, which is 2.
So I get the number 2 and I put in the front of the list.
And then I look for the next smallest element, which is 3.
So I put it at the end of the sorted list.
And then I keep doing that.
I find 4 and put it at the end.
Find 5 and put it at the end.
>> And look at how all of those times that I'm saying put it at the end is,
basically, swapping two values.
OK?
And then the last one, you just have one more element.
So it's already sorted.
>> OK, so insertion sort.
Insertion sort you're going to have also that thing of having a sorted and
an unsorted list.
The only thing is that every time that you're adding an element to the sorted
list, you just pick the element that is in front of the unsorted list.
And then you're going to find what position it should be in the sorted
part of the list.
>> Let's see what this is so this makes more sense.
So initially, for example, I'm trying to insert the number three in the
sorted part of the list.
So the list doesn't have anything.
So I can just put the number 3.
>> Now, I want to add the number 5 to the sorted part of the list.
So I look at the number 5.
I notice that it's greater than 3.
So I know that it has to be after 3.
So I put 3 and 5.
>> Then I want to insert the number 2.
I notice that the number 2 is actually last then both 3 and 5.
So I actually have to put it all the way in the beginning of the list.
So I have to, kind of, shift all the elements in the sorted list so I can
make room for the number 2.
>> Then I see the number 6.
I see that it should be after 5.
So I put it there.
And finally, I look at the number 4.
And I notice it should be between 3 and 5.
And then I put it there and shift all the other elements.
Make sense?
>> Bubble Sort.
So bubble sort is basically what you're going to do-- we call it bubble
sort because you go through the list-- it's actually better if I just show
you like this--
and you're going to compare adjacent numbers.
And you're going to swap their positions if they're not
in the right order.
>> So basically, what is going to happen is here, for example,
you have 8 and 6.
You know that the sorted order will actually be 6 and 5, right?
So you're going to swap the orders.
Then I see 8 and 4 here.
And I do the same thing.
I swap again.
And finally, 2 and 8.
I also swap them.
>> It's called Bubble Sort because after each of these iterations, actually,
the largest number in the list gets all the way to the end of the list.
Does that make sense?
Because it keeps swapping it and moving it to the right.
>> OK, so this is the second iteration.
It would be the same thing.
I'll do one swap and then the last one.
I that there are no swaps and the list is sorted.
So in Bubble Sort, we basically keep going through the list and swapping
things until I notice that I didn't do any swaps doing that iteration, which
means that list is already sorted.
Make sense?
>> Let's talk a little bit about running time.
So do you guys remember Big O, Omega, and Theta?
Yeah?
OK, what is Big O, first of all?
>> AUDIENCE: [INAUDIBLE].
>> LUCAS: Yeah, it's called a worst case runtime, which just means that it's
how much you expect the program to take to run.
Like, in terms of--
in this case-- n.
The number of elements in the list in the worst case.
Like, in the worst possible case.
>> So for Bubble Sort, for example, we have Big O of n square.
Why do we have that?
Why is Bubble Sort Big O n square?
>> AUDIENCE: [INAUDIBLE].
>> LUCAS: Yeah, so the worst case will be that I'll have to do n iterations.
So each of the iterations is going to bring the largest element to the end
of the list.
So the worst case is that I have to do that thing n times.
And for each of those times, I have to do n swaps because I have to compare
each two elements.
So that's why it's n squared because it's n times n.
>> Then, selection sort is also n square because, for each iteration, I have to
look at every single element in the list.
And then find the smallest, which means that I have to
look through n elements.
And I have to do that n times because I have to select all the n elements.
>> An insertion sort is also n square because the worst case scenario will
be, one, I have to insert n numbers, right?
So I already know that I'm going to have n iterations.
But for each of those numbers, if I had to look at all of the numbers in
the sorted list and put it all the way in the front, that will be n square
because it will be n times n again.
Make sense?
What about omega?
>> AUDIENCE: [INAUDIBLE].
>> LUCAS: It's the best case scenario.
So it's like, in a lot of times for sorting, the best case scenario is
when the list is already sorted.
So you don't really have to do anything.
Bubble Sort has the best case scenario of n.
Do you guys know why?
>> AUDIENCE: [INAUDIBLE].
>> LUCAS: Yeah, if you keep track of whether data ration had any swaps or
not, if you have something like set to true if there was an iteration, if the
list is already sorted, basically, what's going to happen is I'm going to
try to swap each two adjacent elements.
I'm going to see that there are no swaps.
And I just return right away.
>> So it means that I just had to go through the list one time.
So it's n because I look at n elements.
Why selection sort n square?
>> Yeah, even if the list is sorted, for every iteration of selection sort, I
have to select the minimum element.
So that means that I have out to look at all the elements in the unsorted
list and find the minimum for each iteration.
Does that make sense?
>> And insertion sword is n because in the case that I'm trying to insert the
numbers and all of the numbers, when I try to insert them, I see that they
are in the right position.
I don't have to go check all the other numbers in the unsorted list.
So that's why it will be n.
Make sense?
And what is theta?
>> AUDIENCE: [INAUDIBLE].
>> LUCAS: What, sorry?
Say it again.
>> AUDIENCE: [INAUDIBLE].
>> LUCAS: Exactly.
So you can see that only selection stored in Merge sort have thetas.
And that's because you only have theta if both Big O and Omega are the same.
OK.
And finally, merge sort is in log n.
>> And then, as Dan was saying, Merge sort is kind of like the same way that
you do binary search.
So you get the list.
And you're going to cut in half.
And then you cut them in smaller halves.
And then you merge them.
You guys remember that, right?
OK, as he was saying.
>> OK, pointers.
So what is a pointer?
>> AUDIENCE: [INAUDIBLE].
>> LUCAS: An address.
OK.
I know that David shows a bunch of videos of binky and things pointing
each other.
But I like to think of pointers as merely an address.
So it's a variable that is going to store an address.
>> So it's just this special variable that is four bytes long.
Remember, that pointer to anything is always four bytes long for our 32-bit
machine so the case with the appliance.
And it just has the location of a variable inside of it.
>> OK, so there's this memory, basically.
So each block of memory actually has a label, which is the address of the
slotty memory.
So that means that I can have a pointer pointing to
any of these addresses.
So the reason why we'll use pointers is if I have to remember the location
that a specific variable is a memory.
>> And you guys remember that one of those cases was if I have a function
if I have actually want you to swap for reals, I actually
have to send a pointer.
Not the variable.
Do you guys remember that?
The difference between--
what is the name?
Calling by value and calling by reference, right?
>> OK, yeah.
So call by value.
When you just send a variable to function you're just sending a value.
So you're actually sending a copy of the variable.
And your program couldn't care less about if the same variable actually
makes a copy.
>> And calling by reference means that I'm actually sending a copy of the
pointer to that variable.
So it means that I'm sending the location of that variable.
So sense I have the location of the variable, when I call the function
with pointers, I'm able to actually change the data that was in main.
Make sense?
>> Although, the pointer is a copy, the pointer still has the real address of
the variable that I want to change.
Make sense?
>> So creating pointers.
Remember, the pointer always have the type that it's pointing
to and then a star.
And then you put the name.
So remember that whenever you have whatever star, it's like a pointer to
that whatever variable type that you had.
>> So here in star, for example, it's a pointer and an integer.
And then char star is a pointer char star and so forth.
Yeah?
>> AUDIENCE: What if we have a pointer to n to star x.
I know that creates a pointer to x.
Does it also declare x an integer?
>> LUCAS: OK, so when you say n star x, you're not creating a pointer to a
variable x.
You're creating a pointer named x.
>> AUDIENCE: [INAUDIBLE].
>> LUCAS: So when I say n star x, I'm saying, hey, in memory, I'm going to
get one of these three boxes.
And I'm going to say that that is going to be x, which is
going to be a pointer.
And something interesting about pointers is that we say that they have
4 bytes for a 32-bit machine.
And the reason for that is because 4 bytes are 32-bits.
>> And machines that are 64 bits actually have pointers addresses
that are 64 bits long.
So it just means that the size of the addresses in the machine is different.
>> So Referencing and Dereferencing.
There are two operators that you guys should remember.
The first is ampersand.
The second is star.
Don't get confused by that star and this star because remember that, in
this case, you have n star.
>> It's like a whole thing together.
There's no n space star.
So it means that it's the type.
Remember, that when you have the variable star, you're
talking about the type.
>> When you have just star and then the name of the variable, it means that
you're dereferencing the pointer, which means that you're looking at the
pointer, finding the address it's pointing to, going to that address,
and looking at whenever you have there.
So I tell my students that when you have star, you should think that it's
the abbreviation of content of.
>> So if you have a pointer and you do star pointer, it's the
content of the pointer.
So you go to whatever it's pointing to and look at the constant content.
And the ampersand is the same thing as address of.
>> So if I have a variable a-- like, let's say that I did int a equals 3--
if I want to find the address of that variable a memory, I can just do
ampersand a.
So it's address of a.
Make sense?
>> So here's an example.
This is missing int b and int c.
So int a equals 3 means that I'm going to go to memory.
And I'm going to find a slot and put the number 3 here.
>> And then int b equals 4.
I'm going to do the same thing.
Go to memory and put a number 4 in one of the boxes.
And int equals 5.
Find another box and put a number 5.
>> So what is this line doing out? n star pa equals ampersand a.
So first of all, n star pa.
What is it doing?
>> AUDIENCE: [INAUDIBLE].
>> LUCAS: Yeah, so n star pa, first, declares a pointer called pa.
And then it's assigning the value of that pointer to be the address of a.
So ampersand a.
Then, if I do star pb, what is a star pb?
>> Oh, sorry.
This is also missing. n star pb.
I mean star pc.
I'm so sorry.
It's the same thing.
But now I'm good ar creating a pointer to b and then a pointer to c.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> LUCAS: Yes.
So if you go to memory and you go to the box that is designator for pa,
you're actually going to see an address of a.
OK?
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> LUCAS: Yeah, pointer is an address.
Never forget that.
It's like the most important part about pointers.
There's storing and address to some variable.
Anything else?
Any other questions?
OK.
>> So Pointers and Arrays.
Remember that when I do int array 3, basically, what I'm doing is I'm, kind
of, declaring in a pointer.
So array is kind of like a pointer to a specific place in memory in which I
allocated three slots for integers.
Does that make sense?
>> So when I do int array 3, what I'm doing, basically, is creating three
slots in memory.
So I just find three slots in memory.
So if I do, then, a star array, it basically means the content of array,
which means I erase the pointer, I go to that place that it's pointing to,
and I put the number one.
>> And then, if I do star array plus 1, that's the same thing as doing array
brackets one, which just means I go to the place that it's pointing at.
And then the plus 1 makes me shift one position.
So I go to this position, actually, and put the number two.
>> And then, finally, when I do array plus 2, I go to where
array's pointing at.
And then I move to memory blocks.
And then I put the number three here.
Yeah?
>> AUDIENCE: So star array is simply saying the very first point.
And you can add 1, just because we're only really
referencing that first address.
>> LUCAS: Yeah.
Why do we, for example, say array 0, array 1, and array 2?
I'm saying, why do you do 0, 1, 2, 3 instead of 1, 2, 3?
One of the reasons is, one, computer programmers prefer to start
counting from 0.
Two is because when you do array 0, it's the same thing as doing array
plus 0, which means I go to that position, and I don't
skip any memory blocks.
So I don't move any memory blocks.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> LUCAS: So she's asking what is the difference between doing
this or doing malloc.
One of the differences is that int array 3 is creating an
array on the stack.
And when I do malloc, it creates on the heap.
Does that make sense?
>> So how does malloc actually work?
So why do we even need to use malloc?
Your compiler kind of figures out all the variables that you declared.
And he creates space for all of them in the stack.
So all of your variables are going to be somewhere in the stack.
So here is the environment variables.
>> So basically, space for those variables in memory is allocated at
compile time.
So it means that your computer has to know all of those variables
beforehand.
It doesn't need to know what value you're going to put in them.
But it needs to know how much memory you need.
>> But now let's say that, for example, you're creating an array or taking a
string that you're taking from the user.
You don't know how long the string is going to be, for example.
So you don't know exactly how many memory blocks you allocate, right?
>> So it doesn't really make sense for you to say put 100 characters.
And then what if the user writes 150?
You're going to be screwed.
>> So basically, you cannot be sure of how much memory you need to allocate
when you compile the program.
You just know that on run time.
So that's why you have the heap.
So the heap is going to have memory that you're allocating during the
duration of the program running.
>> So basically, when you do malloc, what you're doing is allocating memory at
runtime, which means that you're deciding right at that moment that you
should have that memory.
So that's when you're allocating it.
Does that make sense?
>> So remember, the stack has variables that are created on compile time.
And then the heap has variables that are created as you go
with malloc, for example.
>> AUDIENCE: [INAUDIBLE]?
>> LUCAS: So GetString is going to call malloc.
Let me talk about malloc, and I'll explain GetString.
So malloc is the same thing as memory allocation.
So it's going to allocate memory on the heap.
And it's going to return a pointer to where that memory was allocated at.
>> So when you do--
here for example--
n star pointer.
And then pointer equals malloc size of inch times 10.
I'm creating a pointer.
And then I'm assigning that pointer to the value of the pointer that malloc
is giving me.
>> So I'm asking malloc can you allocate space for 10 integers.
That's what it's saying.
And malloc gives me back a pointer to that place.
Make sense?
OK.
I And GetString is, basically, doing a call to malloc so you can allocate
memory during runtime.
>> Always remember to check for null because malloc is going to return null
if it cannot allocate memory.
Let's say that you ask for a ridiculous amount of memory.
Your computer is not going to be able to allocate that much.
>> So malloc is just going to return null.
So always remember to check if the pointer that you got from malloc is
null or not because, if it is, you might be dereferencing a pointer and
causing side faults.
And finally, don't forget your free memory.
>> Malloc is creating memory in the heap.
And you have to free the memory before the program ends.
OK, that's all for me.
Sorry, Rob.
Thanks.
>> [APPLAUSE]
>> LUCAS: Any last questions before Rob comes?
No?
Yeah?
>> AUDIENCE: I didn't see this one online.
Have you uploaded it yet?
>> LUCAS: I think Dave is uploading it soon.
>> DAVE: It'll be posted.
>> LUCAS: It'll be online.
>> AUDIENCE: It's up.
>> LUCAS: It's up?
OK.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> LUCAS: Yes, you should free all the memory that is put in the heap.
>> AUDIENCE: [INAUDIBLE]?
>> LUCAS: Yes.
Any time that you have a culture malloc, you should have a culture free
after you stop using that variable.
So malloc and free are always together.
Their best friends.
Yeah.
Rob?
>> ROB: I'll go quickly.
And also the video will be put up.
I have the mic on.
>> OK, so week five stuff.
First thing we have is the stack.
So remember that there's only one stack frame per active function call.
We'll see that in a second.
And also remember what actually goes in each stack frame are going to be
the local variables of our functions, the arguments that are passed into our
functions, along with a couple other things you don't really
need to worry about.
>> So here's an example program where, notice, main is printfing the return
value of foo 4.
foo is just going to return the value of bar 4 comma 6.
And bar is going to set some local variable n equal to 4 times 6.
And then return n.
>> So let's look at the stack throughout the actual iteration of this program.
So there's the bottom of our stack.
Remember that the stack grows up.
So at the bottom of our stack, we have a stack frame for main.
When the program starts, main is always going to be at the
bottom of our stack.
>> And what is inside of our stack frame for main?
So even though there are no local variables to main, like I said before,
we have argc and rgv taking up space inside of main stack frame.
So main is now going to call the function foo.
And that means foo is going to get its own stack frame.
>> So now we're inside of the function foo.
And what needs to go in foo's stack frame?
Well, foo has an argument n.
And n is equal to 4 since that's what main is passing as foo's argument.
>> So now foo is going to call bar.
What is bar going to have inside of its' stack frame?
It has x equal to 4 y equal to six.
That's not all that we're going to have in the stack frame because bar
also has a local variable n.
And n we're going to set equal to 24.
>> So now bar is going to return n.
So bar is returning 24 to the stack frame foo.
And because bar is now returning, that means we're popping the stack frame
for bar off of the stack.
So all the memory that bar had been using is now off the stack.
>> Now, foo is also going to return 24 to main.
So now that foo is returning, the memory that foo was using in its'
stack frame is also gone.
And now, main is going to call printf.
So printf is just another function.
When we call printf, it's going to be another stack frame for the printf
function call.
>> What are we passing printf?
That's what's going to go on its stack frame.
At the very least, we're passing that percent i backslash n and
the argument 24.
It might have more in it's stack frame if printf happens to be using some
local variables.
We don't know.
>> But all that goes in printf's stack frame.
It's going to execute the printf.
Then printf's done.
It will return.
Finally, main is done.
Main will return.
And then our program is done.
Yeah?
>> AUDIENCE: Are you seeing [INAUDIBLE]
arguments [INAUDIBLE]
parameters?
>> ROB: So there is a subtle difference between arguments and parameters.
And really, in common speak, people tend to just mix them up all the time.
But parameters are the formal name of the things.
>> So argc and argv are the parameters to main.
Arguments are what you actually pass in as those parameters.
So there when I call foo of 4, 4 is the argument I'm passing in.
And the parameter n, inside of foo, takes on the value 4
since 4 was the argument.
>> AUDIENCE: [INAUDIBLE]?
>> ROB: n is a local variable to bar.
n is still local to foo, but it's a parameter to foo.
It's not a local variable.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: foo is just calling bar and returning whatever bar returns.
>> AUDIENCE: [INAUDIBLE]?
>> ROB: Yeah, just to see multiple stack frames.
Yeah?
>> AUDIENCE: Why was foo called before printf?
>> ROB: Why was foo called before printf?
So I could have, instead, done something like int x equals foo of 4
and then printed x.
But instead, I combined the function call into the printf argument.
>> But notice that we can't actually execute the call to printf until we
figure out what foo of 4 is.
So we're going to evaluate this.
And only once that's done are going to come back and evaluate this.
Yeah?
>> AUDIENCE: Since both bar [INAUDIBLE]
value, why do we not have [INAUDIBLE]?
>> ROB: They totally should be int.
That was not caught over multiple passes.
So it should be int bar and int foo since both of those
are returning integers.
Void is only if they're not going to return actual values.
Yeah?
>> AUDIENCE: If you had a line above the return, [INAUDIBLE]?
>> ROB: A line above the return?
>> AUDIENCE: Yeah.
Like if you did printf and [INAUDIBLE], would it print twice?
>> ROB: So inside of foo?
If we had a printf right here?
>> AUDIENCE: Yeah.
>> ROB: So if we had a printf right here, it would print once.
Since we are calling foo once right here, then we'll hit the printf.
Then we'll call bar.
And then foo will return.
And that's it.
We only ever encounter the printf once.
Yeah?
>> AUDIENCE: [INAUDIBLE]
printf calling foo because we're first calling printf and then we're passing
the arguments.
>> ROB: So in theory, isn't printf calling foo?
So no.
Just the order that c is going to execute these things is, before we can
call a function, all of the arguments to the function have to
be completely evaluated.
So is this completely evaluated?
Yes, it's just a string.
It's just a value.
>> Then we have to completely evaluate this.
Once this is done, now all of its arguments are evaluated.
And now we can make the call to printf.
Yeah?
>> AUDIENCE: One question.
If you have a void function, must you have return semicolon?
>> ROB: You do not a return semicolon if you have a void function.
OK.
So now some heap stuff.
So heap is how we're going to deal with dynamic memory management.
And this directly contrasts with the stack which we would call automatic
memory management.
>> So on the stack, you never really have to deal with how the local variables
are being pushed and popped off all these stack frames and all that stuff.
You don't have to worry about it.
It's automatic.
So the heap is manual.
And the [INAUDIBLE]
comes from these functions malloc and free.
>> So here's another program.
All we're doing is mallocing an integer.
We're storing it in star x.
Of course, we have to check to see if x is null.
Then we're going to just set what x is pointing to to 50.
Print what x is pointing to, print x, and then free x.
>> So how is this actually going to look if we look at our stack and heap?
So we'll start again.
The bottom of our stack as before.
Remember that thee heap directly opposes the stack?
So we're going to have the top of our heap up there.
>> So the bottom of our stack, we have our stack frame for main.
It has the space for argc, argv, and we now have a local variable x, which
is an int star.
So we're going to iterate through this program.
First thing we have is a call to malloc.
>> So we're making a call to malloc.
Malloc is a function.
It's going to get a stack frame.
What are we passing to malloc?
That's going to go inside of the stack frame.
We're passing size of n, which is 4.
So that is passed to malloc.
>> What does malloc do?
It grabs us some space on the heap.
So we're going to go to the heap.
And we're going to grab 4 bytes from the heap.
So let's just give that an arbitrary address.
0x123 Just pretend that is an address that is on the heap.
>> So what is actually inside of that region of memory at address Ox123?
Garbage.
So we have not stored anything in it.
So as far as we know, it could be anything.
You shouldn't assume it's zero.
It's most likely not zero.
>> So now malloc returns.
And what do we do when malloc returns?
We set what it returns.
We set x equal to what it is returning.
So what is it returning?
It's returning 0x123 since that is the address of the block of memory that it
just allocated in the heap.
>> So return 0x123 x is now going to be set equal to 0x123 which, pictorially,
we frequently draw as x having an actual arrow pointing to that block.
But x is just storing that address.
So now we have to check if x is null.
It's not null.
We pretend that that malloc succeeded.
>> So now star x equals 50.
So star remembers it means go to that address.
So 0x123 We're going to go to that address.
So that brings us up there.
What are we doing at that address?
We're storing 50.
>> So after this line, that is what things are going to look like.
So now it's no longer garbage up there.
Now we know that 50 is in that particular address because
we set it to that.
OK?
So now we're going to print f.
>> So first we're going to print star x.
So what is star x?
Again, star x means go to the thing that x is pointing to.
So x is storing 0x123 Go to that.
We get 50.
So print f that.
And that means it's going to print 50.
And then that returns.
>> And then we have the second printf.
We're now percent p.
If you haven't seen it, that's just how you print a pointer.
So we have percent i, percent f, and all of those already.
So percent p, print a pointer.
>> So x is a pointer.
So if we're going to print x itself, we're printing what is actually inside
x, which is 0x123 So the first print f is going to print 50.
The second print f is going to print 0x123 Yeah?
>> AUDIENCE: Do you use percent x to print a pointer?
>> ROB: So do you use percent x to print a pointer?
So you can but percent x is just, generally, for like if you have some
integer and you want to print it as a hexadecimal.
That's just how you do that.
>> Whereas, percent d would print as decimal.
That's were we get percent d. i is just integer.
percent p is specifically for pointers.
>> So x is a pointer.
We want to use percent p.
But percent x could work.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: Yeah.
At least for this call-- so I didn't include it in here.
But these two arguments are necessarily inside of this stack frame
along with any local variables printf happens to be using.
And then the next call to printf now inside of printf stack frame is
percent p backslash n and whatever the value of x is, which is 0x123.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: It'll print something that looks like this.
>> AUDIENCE: [INAUDIBLE].
>> ROB: So it prints it in address form.
It looks like an address.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: Why is what?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: Why is this pointer 4 bytes?
So there are a whole bunch of 0's in front of this.
So it's really 0x0000000123.
On a 64-bit system, there would be a whole bunch of more zeros.
Yeah?
>> AUDIENCE: [INAUDIBLE].
>> ROB: So the first printf is going to print--
>> AUDIENCE: [INAUDIBLE].
>> ROB: Yes, it's going to print what x is pointing to.
Star says what is this thing pointing to.
Grab it.
So what is it pointing to?
50.
Grab it.
That's what we're going to print.
Whereas, the next one, we're just printing x itself.
What is inside of f?
0x123.
OK.
>> And then, finally, we have the free.
What are we passing to free?
We're passing x.
That time I actually displayed it in the stack frame.
>> So we're passing the value 0x123 to free.
So now free knows, all right, I have to go up to the heap
and free that memory.
It's no longer using what is at address 0x123.
>> So free is going to release that from the heap.
Now our heap is empty again.
We have no memory leaks.
Now free will return.
Notice that x is still 0x123.
But that is now not valid memory.
We should no longer dereference x.
Yeah?
>> AUDIENCE: Is return 0 redundant?
>> ROB: Is returen 0 redundant?
Yes.
We just put that there because we have a return one for air.
So it's like, yeah, lets include the return 0.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: So after free x, what happens if we try to dereference the pointer?
It's possible that nothing goes wrong.
It's possible that we'll still get 50.
>> It's possible, also, that that memory is now being used for something else.
So it's undefined behavior.
And undefined means anything can happen.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: No, so if you assign x to something else.
So if right here we said x equals malloc something else--
malloc size event--
then that original block of memory is not freed.
And we have officially lost it.
That is a memory leak.
We've lost all references to that block of memory.
So there's no way we can ever free it.
OK, so then return 0 means done.
>> All right, so stack overflow.
What's the idea here?
So remember, heap is going down.
Stack is going up.
So this was the example from lecture, I think, where main is just going to
call this function foo, which is going to call itself recursively over and
over again.
>> So stack frames are going to work exactly the same.
So we're going to start with main as the bottom stack frame.
Then main is going to call foo, which is going to get a stack frame.
>> Then foo is going to call foo again, which is going to get
another stack frame.
And then again, and again, and again, and again until, eventually, we run
into the heap.
So this is how we get a stack overflow.
And at this point, you seg fault.
Or you'd really seg fault before this point but yeah.
>> AUDIENCE: Is core dump the same as seg fault?
>> ROB: So you'll see segmentation fault core dumped.
You get a core dump when you seg fault.
And it's like a dump of all of the contents of your current memory so
that you can try and identify why you seg faulted.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: So a segmentation fault means there's a stack overflow.
So not necessarily.
A segmentation fault means that you're touching memory in a way
you shouldn't be.
So one way of that happening is, when you stack overflow, we start touching
memory in a way that we shouldn't be.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: So inside of an infinite loop.
Like, this is like a recursive infinite loop and so we get another
stack frame each time.
But just inside of a regular infinite while one--
well, let's not even print f--
do something.
Whatever.
>> We're not going to be getting another stack frame.
We're just going to keep looping over this single instruction.
The stack isn't growing.
It's the fact that each recursive call is giving us a stack frame.
That's why we get a stack overflow.
Yeah?
>> AUDIENCE: So if you said to get the while loop and then [INAUDIBLE]?
>> ROB: So if inside of the while loop there was a printf, you still would
not seg fault.
I just didn't want to confuse things.
It would loop.
You'd get a single stack frame for the printf.
>> Then printf would return.
Then you'd loop again.
You'd get a single stack frame for the printf.
It would return.
Single stack frame.
So you're not getting this infinite piling up stack frames.
>> AUDIENCE: [INAUDIBLE]?
>> ROB: Yes.
So this stack overflow happens because none of these
calls to foo are returning.
So if we return, then we would start losing stack frames.
And then we would not stack overflow.
And that's why you need a base case for your personal functions.
Yeah?
>> AUDIENCE: Is the potential size and the stack for the heap the same for
all programs?
>> ROB: Roughly.
Is the potential size of the stack and the heap the same for all programs?
Roughly.
There is some randomization to where the stack starts and
where the heap starts.
If you happen to have a whole lot of global variables and things, you might
take away from some space for your heap.
>> On a 64-bit system, you virtually have infinite memory.
There's just so much.
Between 32 bits and 64 bits, that is a significant difference.
>> You're going to get a whole lot more stack and heap space on a 64-bit
system because there's just more addresses that they can use.
But on an individual system, it will be roughly the same amount of stack
and heap space.
All right.
>> So last thing is compilation.
So you should know this process.
There are four big steps.
So the first one should be easy to remember.
Pre-processing.
It has the prefix pre in it.
So it comes before everything else.
>> The thing to remember is the hash.
So hash defines and hash includes in all of those.
Those are all pre-processor directives.
These are the things that the pre-processor takes care of.
>> So what does a pre-processor do?
It's a really dumb thing.
All it's capable of are all of these copy, and cut, and paste operations.
>> So hash includes standard i0 dot h.
What is that doing?
It's grabbing the standard i0 dot h file and pasting it into the top
wherever it says hash includes standard i0 dot h.
>> And any hash define that we've seen, what is that doing?
Its copying the value that the hash defined is defined as and pasting that
wherever you are using the value.
So the preprocessor just does really simple text based operations.
It does nothing smart.
So everything else is more complicated.
>> So now that preprocessor is done, we actually compile.
So what does compiling mean?
We're now going from c code to assembly code.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: Yeah, we caught that.
So compiling.
We're going from c to assembly.
So this is an actual language change.
Compiling itself means going from a higher level language to
a lower level language.
>> And c is a high level language compared to assembly.
What is assembly?
Its instructions that are, pretty much, made for your CPU.
But your computer still does not understand assembly.
It only understands ones and zeros.
So the next step is assembling, which brings us from these instructions that
your CPU understands and actually translates them, to
the ones and zeros.
>> So C to assembly to binary.
But I don't have an executable yet.
So think of the cs50 library.
We have provided you with a binary for this cs50 library, which has GetString
and GetInt and all that.
>> But the cs50 library--
in and of itself-- is not executable.
It does not have a main function.
It's just a bunch of binary that you can use.
So linking is how we bring together all of these different binary files
into an actual executable.
One that you can type dot slash a dot out.
>> So this is like the file that you wrote,-- whatever your program is--
Ceaser dot c.
But now it's been compiled down to binary.
So Ceaser dot o.
And this is our cs50 libraries binary.
And they're being combined into a single executable.
Yeah?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: So first include, remember, the hash include is actually a
pre-processor step.
But that's separate.
If you're not using any functions that are outside of your single file then,
no, you don't need to link anything since you have everything.
>> That said, printf is being linked in.
If you ever use printf, that's something that needs to be linked in
because you didn't write that.
And, in fact, printf is automatically linked in.
You know how at the command line or when you type make, you see it have
dash l cs50, which has link in the cs50 library?
Printf, and stuff like that, is going to be linked in automatically.
Any other questions on anything?
>> AUDIENCE: [INAUDIBLE]?
>> ROB: Linking?
We have a whole bunch of different binary files.
This is the canonical example that we use is cs50 library.
We have compiled and given to you the binary for this cs50 library.
>> You want to use GetString in your program.
So you go and use GetString.
But without my binary code for GetString, when you compile your code
down, you can't actually run your program because GetString String is
not yet completely defined.
>> It's only when you link in my binary that contains GetString that now, all
right, I can actually execute GetString.
My file is complete.
And I can run this.
Yeah?
>> AUDIENCE: Does linking convert the binary to executable?
So even if you don't have other libraries, wouldn't it still be
necessary to translate the [INAUDIBLE]?
>> ROB: So an executable is still in binary.
It's just combining a whole bunch of binaries.
>> AUDIENCE: Thank you so much.
>> ROB: No problem.
Any other questions?
Otherwise, we're all set.
All right.
Thanks.
>> [APPLAUSE]
>> AUDIENCE: Thank you.
>> ROB: Yeah.