>> [MUSIC PLAYING]
>> DOUG LLOYD: All right, so let's
talk about command-line arguments.
So, so far in the course pretty
much all of your programs
have probably started
like this-- int main void.
We've been collecting
user input if we need it
in our programs, such as the
Mario program, for example,
by in-program prompts.
We haven't needed to modify
the declaration of main,
because instead inside of main we
just say, you may call it to get int.
How large do you want the pyramid to be?
Or you may call it to get
float-- how much change
should I output to the user?
>> There is another way though,
and if we want our users
to be able to provide
data to our program
at runtime instead of while
the program is running,
a subtle distinction but
sometimes a very useful one,
we need a new form of declaring main.
We can't use int main void if we want to
collect other data at the command-line
when the user runs the program,
hence command-line arguments.
>> To collect these command-line
arguments from the user,
change your declaration of
main to look like this-- int
main, open paren, int argc, comma,
string argv, square brackets,
and then open curly brace.
So what does that mean already?
Well, we are passing in two parameters,
or arguments, or inputs to main.
One, an integer called
argc, and the other is what?
It's an array of strings, right?
We see that square bracket notation.
It's an array of strings.
It's not an individual string,
it's an array of strings.
And these two arguments, argc and argv,
enable you to know what data the user
has provided at the command-line
and how many things they
provided at the command-line.
Pretty useful things to work with.
>> Argc stands for argument count,
and you should know, by the way,
that you could call argc
whatever you want it.
You can call argv whatever you wanted.
These are just conventional names
that we use for them-- argument count,
and as we'll see in a second,
argument vector, argv.
But you don't have to call them
argc and argv if you don't want to,
but conventionally, that's what we do.
>> So anyway, argc, the argument count.
It's an integer-type variable and so, as
you might expect, if we have two things
that we're going to be finding
out what these are typed
and how much stuff the
user typed, argc is
going to tell us how much
stuff the user typed.
So it gives you a number of
command-line arguments user
typed when the program was executed.
So if your program is
run dot slash greedy,
and inside of your greedy
program your main function
has the declaration int main int argc,
string argv square brackets, then
argc in that case is one.
Now notice we don't
count how many things
the user typed after the program name.
The program name itself counts
as a command-line argument.
>> So dot slash greedy, in
that case, argc is one.
If the user typed slash greedy 1024 CS50
at the command-line, argc in that case
would be three.
And we know this because the way
that the division between the strings
is detected is whether
there is a space, or a tab,
or something like that between them.
So any amount of white space, so-called,
between the values typed command-line
indicates how many there are.
So dot slash greedy space 1024 space
CS50, argc, in that case, is three.
>> Argv is the argument vector.
Vector, by the way, is just
another word for an array,
and this is an array
that stores strings.
One string per element, which is
the strings that the user actually
typed at the command-line
when the program was executed.
Now, as is the case
with any array, if you
recall from our discussion of
arrays, the first element of argv
is always going to be found
at argv square bracket zero.
That's the first index
of the argv array.
So that will-- and in fact, that will
always be the name of the program,
will always be located at
argv square bracket zero.
>> The last element of argv is always found
at argv square brackets argc minus one.
Do you see why?
Remember how many elements
exist in this array.
Well, we know that-- it's
argc number of elements.
If the user typed three things at
the command-line, argc is three.
But because in c, when we're working
with arrays, each element of the array,
or rather the indices of
the array, start at zero.
If we have three elements in our
array, we have an element at argv zero,
an element at argv one,
and an element at argv two.
There is no element at argv
three, and an array of size three.
So that's why the last
element of argv can always
be found at argv square
brackets argc minus one.
>> So let's assume the user executes
the greedy program as follows--
if they type in the command-line dot
slash greedy space 1024 space CS50,
and for whatever reason we've
already prepared our greedy program
to know and work with these
command-line arguments.
We didn't previously when we worked
on it for the greedy problem,
but let's say we've now modified
it so that we do process
the command-line arguments in some way.
In this case, argv zero
is dot slash greedy.
What's argv one?
Well, it's 1024, right?
It is 1024, but here's a
really important distinction--
do you remember the data type of argv?
>> It stores strings, right?
But it looks like 1024
is an integer value.
This is a really important
distinction, and is actually
going to become something that you
might encounter in later problems.
Everything in argv is
stored as a string.
So argv one's contents are the
string one, zero, two, four,
consisting of those four characters.
It's as if the user typed
one, zero, two, four
as individual letters or characters.
It is not the integer 1024,
and so you can't directly
work with it by saying int 1,000, or
rather int x equals argv one minus 24.
>> Intuitively, you might think of that
as, OK, well it's 1,024 minus 24,
so x is equal to 1,000.
But in fact, that's not the case,
because argv one is a string.
The string 1024.
Now there is a function that can be
used to convert strings to integers.
I won't spoil it for you
now, but I'm sure Zamyla
will be happy to tell you about it in
the walkthrough for a future problem.
But you can also find
problems like-- excuse
me, functions that would
do this in reference 50,
if you go to the reference guide
you can find a function that
will make this conversion for you.
But again, in the walkthrough
for a future problem,
Zamyla will be happy to
tell you what function
it is that will convert the
string 1024 to the integer 1024.
>> All right, so moving on.
We've covered our argv zero,
we've covered argv one.
What's in argv two?
CS50.
That one's probably
pretty self-explanatory.
What's in argv three?
Well again, we don't really know, right?
We have an array of size three,
that's how many elements the user
typed at the command-line,
so if we go to argv three,
we're now overstepping
the bounds of our array.
The compiler will let us do this,
there's no intuitive problem with it,
but in terms of actually what's going
to happen, we don't really know.
It depends on what is
located at the memory where
argv three would be expected to be.
And so we could end up
getting away scot free.
More likely than not, particularly when
you're working with argv as opposed
to any other array
that's in our program,
we're probably going to suffer
a segmentation fault. So again,
be sure not to overstep the bounds
of your arrays, particularly argv,
given its high degree of
importance in your programs.
>> I'm Doug Lloyd.
This is CS50.
