>> DOUG LLOYD: All right, so let's talk about loops.
So loops are kind of cool because they allow your program
to execute lines of code over and over and over.
Repeatedly, without having to copy and paste or otherwise repeat them.
There are three major kinds of loops you'll see.
You'll probably have occasion to use each one as you progress through CS50.
Some of these loops are pretty familiar to you from Scratch,
so again, as we did with conditionals, we'll put them up side by side
if there is an analogy we can draw.
>> First is forever from Scratch, which compares to while (true).
This is what we call an infinite loop.
The lines of code between the curly braces, much like the puzzle pieces
that fit inside the C of the forever block,
will execute repeatedly from top to bottom, over and over and over,
forever.
After all, if you recall our discussion of Boolean expressions,
true is always true.
So if we're doing something so long as true
is true-- it seems a little silly-- true is always true, so it'll always run.
It'll run forever and ever and ever until we
find a way to break out of it with a break statement, which again,
we saw a little while ago we were talking about switch.
>> Or otherwise just kill our program, which incidentally,
if you ever find yourself in a situation with an infinite loop
and you don't know how to stop your program from running.
Just hit control and C and that'll kill your program for you.
But this, again, is called an infinite loop.
It is a loop that will run forever.
Now, while loops are not always infinite, because also
we can replace the Boolean expression with something
a little more useful than just true.
So here's another example.
While and some Boolean expression and then curly braces.
That's pretty much analogous to repeat until, from scratch.
Although in a second, I'll explain the difference.
>> So in C, if the Boolean expression inside of the while loop
evaluates to true, the lines of code between the curly braces
will execute repeatedly over and over and over until Boolean expression
evaluates to false.
So for example, you might have some sort of counter.
So say you at the beginning of this loop say int x equals zero.
While x is less than 100, do a couple things inside that curly braces,
then in the end of your loop, you say x plus plus, you're incrementing x.
Eventually x will get to 100 and you will
stop because the condition x is less than 100
will no longer be true as soon as x is equal to 100.
100 is not less than 100.
>> Now somewhat confusingly, the behavior of the scratch block is reversed.
So be really careful if this is your first foray into using loops.
Basically, the repeat until block in Scratch
will repeat something over and over and over,
until the expression, the Boolean expression in the hexagon is true.
So it will keep doing it until it is true.
Meanwhile, the while loop will continue to do it until it is false.
So they're quite similar, but there's that little distinction just
to be careful of especially as you make your first foray from transitioning
to Scratch into c.
The next kind of loop is actually pretty similar.
It's called the do while loop.
This loop will execute all the lines of code between the curly braces once,
and then it will check the Boolean expression.
If the Boolean expression evaluates to true,
it'll go back and repeat that process over and over
and over until the Boolean expression evaluates to false.
So this loop, unlike a while loop, is guaranteed to run at least one time.
This can be pretty useful.
>> Lastly, we have a for loop.
For loops are kind of syntactically unattractive
and there's a lot going on here, so bear with me
as we try and break these pieces apart.
Generally, the use case of a for loop is you
want to repeat something a specific number of times.
In this example here, I have the repeat block
from Scratch, which is analogous to the for loop
in C, repeating something 10 times.
And the for loop on the left there, which
is a four loop that would do the same thing.
This would go 10 times.
Counting from zero, we increment each pass of the loop.
And we keep doing that until i is less than 10.
>> So what happens?
There's a whole lot of code there.
Let's break it down to what is happening step
by step as we dig through a for loop.
The first thing that happened is the counter variable is center.
Everything to the left of that first semicolon inside the parentheses
is executed.
In this case, we are saying int i equals 0.
Declaring a new variable called i, that variables is a type integer
and we're saying the value inside that variable is going to be zero.
>> The second thing we do is we then immediately evaluate
the Boolean expression.
Boolean expression is in the middle of the two semicolons.
I is less than 10.
That's true here, right?
We just said i is equal to zero, and so 0 is less than 10,
and so that condition is true and we will now
proceed to execute the body of the loop.
If it was false.
If, for example, I said instead of i equals 0 there I said i equals 15,
int i equals 15.
Well 15 is not less than 10, so we would never enter the body of the loop
because the Boolean expression there would evaluate to be false.
>> After we go through from top to bottom, we encounter that closing curly brace,
a third thing happens.
The counter variable is incremented, or rather, the lines
of code of a statement after the second semicolon inside of the
for loops parentheses is executed.
So we start out by saying int i equals 0.
Then we check whether or not the Boolean expression is true.
0 is less than, 10 so it's true.
So we're going to proceed into the body the loop.
Things will happen inside the loop, and when we encounter that closing curly
brace, the next thing we do is we say i plus, plus.
I was zero now i is one.
Then, we again check the value of the Boolean expression in the middle.
One is less than 10.
So we'll go through this process again and again.
We'll get to the closing curly brace again.
We'll increment i from 1 to 2 and from 2 to 3.
And so on and so on and so on, until eventually i's value becomes 10.
Is 10 less than 10?
No.
Counting from 0, we've gone through 10 iterations of loop.
We've repeated 10 times, just as we did in the Scratch block.
And so that's basically the process for a four loop.
>> Now taking away the actual code and putting it
in just some basic general statements.
Here's what happens.
All the statements in start are executed first.
You might have more than one.
Then, the Boolean expression is checked.
If the expression evaluates to true, execute the body the loop one time.
If the expression evaluates to false, we're done.
We don't execute the body of the loop at all.
After we've executed the body the loop one time,
we then do what is in the increment part there.
Which is usually going to be something like i plus, plus
or something like that, that modifies a counter variable.
Then, after we increment, we check the expression again
and repeat those steps over and over and over until the expression is
no longer true.
>> So what are the use cases for a loop?
Use you use a while loop when you want a loop to repeat
an unknown number of times, but it possibly might not run all.
A really common example of a while looping being used
is to run the control flow for a game.
You might not know how long the user is going to be playing,
but you want to keep doing the same thing.
Updating the positions of various sprites on the board.
You want to keep things moving at all times,
but you don't know when the user is going to stop playing
or when they're going to run out of lives.
So a while loop is really good for something like that.
That's a good use case.
>> For a do while loop, it's pretty similar.
You want a loop to repeat an unknown number of times, but at least once.
You might use this for a game too, but a really common use case
is prompting the user for input.
Generally, you might say something like, give me a positive integer,
and you might put that inside of a do while loop.
So it will always ask them at least once for a positive integer.
If they give you a positive integer, you might break out of the loop.
You might be done.
The Boolean expression in the do while might be false.
>> And you won't ask them again.
If they give you a negative number where they type some word or something that's
not really useful to you, you might use the
do while loop to go back and do it again and again and again.
You definitely want to ask them to give you a number once,
but you don't know how many times after that they might be pests.
And so a do while it's a great use case for prompting the user for input.
And a for loops use case typically is when
you want to repeat a loop a discrete number of times,
though you might not know the number of times
the moment the program is compiled.
>> So for example, maybe you have a program where you prompt the user for a number.
And they enter 100.
And then your for loop will in that case run 100 times.
Or maybe they enter 1,000 in your program
and then run the loop 1,000 times.
It's a specific number of times.
They don't necessarily know what that number
is the moment program is compiled.
It's not like a while loop where it could be infinite.
It's rather a number that you just don't know.
Now even though I've outlined all these use cases,
you should know that in pretty much every circumstance,
you can interchange all three of these loops.
You can use a for loop where you would otherwise use a while loop.
You can use a for loop wherever you'd use a do while loop and so on.
It can be a little tricky sometimes, so generally it's a good practice
to adhere to a typical use case.
Use a do while loop if you wanted something once, at least.
Use a for loop if you want to do something a specific number of times.
After all, that's why there are three different kinds of loops.
>> So they can be used in the right context.
But you can interchange them if you want.
If you feel comfortable with while loops and you always want to use while loops.
It is something that you can do, although it
might be a little syntactically tricky, where a for loop
would be a lot more straightforward.
>> My name is Doug Lloyd and this is CS50.