>> [MUSIC PLAYING]
SPEAKER: All right.
So let's talk about another
thing that's kind of unique to C,
which is data types and variables.
When I say unique to C, I really
only mean in the context of,
if you've been a programmer
for a really long time,
you've probably not
worked with data types
if you've used modern
programming languages.
Modern languages like
PHP and JavaScript,
which we'll also see a little
later on in the course,
you don't actually have to specify
the data type of a variable
when you use it.
>> You just declare it and start using it.
If it's an integer, it
know it's an integer.
If it's a character, it's
knows it's a character.
If it's a word, it knows
it's a string, so-called.
>> But in C, which is an
older language, we need
to specify the data
type of every variable
that we create the first time
that we use that variable.
So C comes with some
built-in data types.
And let's get familiar
with some of those.
And then afterwards we'll also talk a
little bit about some of the data types
that we've written for you,
so you can use them in CS50.
>> The first is int.
The int data type is used for variables
that will store integer values.
So 1, 2, 3, negative 1, 2, 3, and so on.
Integers, which is something you
should keep in mind for the quiz,
always take up four bytes
of memory, which is 32 bits.
There are eight bits in a byte.
>> So this means that the range of
values that an integer can store
is limited by what can fit within
32 bits worth of information.
Now as it turns out,
it was long ago decided
that we would split up
that range of 32 bits
into negative integers
and positive integers,
each getting half of the range.
So the range of values that we represent
with an integer range from negative 2
to the 31st power to 2 to
the 31st power minus 1,
cause you also need a spot for 0.
>> So basically half of the possible values
you can fit in an int are negative,
and half are positive.
And roughly here, this is about negative
2 billion to about positive 2 billion.
Give or take a couple hundred million.
So that's what you can fit
in an integer variable.
Now we also have something
called an unsigned integer.
Now unsigned ints are not a
separate type of variable.
Rather, unsigned is
what's called a qualifier.
It modifies the data
type of integer slightly.
>> And in this case, what unsigned
means-- and you can also
use unsigned other data types,
integer's not the only one.
What it effectively does is doubles
the positive range of values
that an integer can take on at
the expense of no longer allowing
you to take on negative values.
So if you have numbers that you know
will get higher than 2 billion but less
than 4 billion, for example--
which is 2 to the 32nd power--
you might want to use
an unsigned int if you
know your value will never be negative.
>> You'll occasionally have
used for unsigned variables
in CS50, which is why I mention it here.
But again, the range of values that you
can represent with an unsigned integer
as to t regular integer, are 0
to 2 to the 32nd power minus 1,
or approximately 0 to 4 billion.
So you've effectively doubled the
positive range that you can fit,
but you've given up all
the negative values.
>> Now as an aside, unsigned
is not the only qualifier
that we might see for
variable data types.
There are also things called
short and long and const.
Const we'll see a little
bit later in the course.
Short and long, we probably won't.
>> But just know that there
are other qualifiers.
Unsigned isn't the only one.
But it's the only one we're
going to talk about right now.
So all right.
So we've covered integers.
What's next?
>> Chars.
So chars are used for variables
that will store single characters.
Char is short for character.
And sometimes you might hear
people pronounce it as car.
>> So characters always take up one
byte of memory, which is just 8 bits.
So this means that they can only fit
values in the range of negative 2
to the seventh power, or negative 128,
to 2 to the 7th power minus 1, or 127.
>> Thanks to ASCII, it was
long ago decided a way
to map those positive numbers from
0 to 127 to various characters
that all exist on our keyboard.
So as we'll see later on in
the course, and you'll probably
come to memorize at some
point, capital A, for example--
the character capital A--
maps to the number 65.
And the reason for that is
because that's what's it's
been assigned by the ASCII standard.
>> Lowercase A is 97.
The character 0 for when you
actually type the character, not
representing the number zero, is 48.
You'll learn a couple
of these as you go.
And you'll certainly come to need
them a little bit later in CS50.
>> The next major data type
is floating point numbers.
So floating point numbers are
also known as real numbers.
They're basically numbers that
have a decimal point in them.
Floating point values
like integers are also
contained within 4 bytes of memory.
Now there's no chart here.
There's no number line, because
describing the range of a float
isn't exactly clear or intuitive.
>> Suffice it to say you
have 32 bits to work with.
And if you have a number
like pi, which has
an integer part 3, and a floating
point part, or decimal part 0.14159,
and so on, you need to be
able to represent all of it--
the integer part and the decimal part.
>> So what do you think that might mean?
One thing is that if the decimal
part gets longer and longer,
if I have a very large
integer part, I might not
be able to be as precise
with the decimal part.
And that's really the
limitation of a float.
>> Floats have a precision problem.
We only have 32 bits to
work with, so we can only
be so precise with our decimal part.
We can't necessarily have a decimal
part precise to 100 or 200 digits,
because we only have
32 bits to work with.
So that's a limitation of a float.
>> Now fortunately there's
another data type called
double, which somewhat
deals with this problem.
Doubles, like floats, are also used to
store real numbers, or floating point
values.
The difference is that
doubles are double precision.
They can fit 64 bits of
data, or eight bytes.
What does that mean?
Well, it means we can be a lot more
precise with the decimal point.
Instead of having pi to seven
places maybe, with a float,
we can maybe have it to 30 places.
If that's important, you might want
to use a double instead of a float.
Basically, if you're
working on anything where
having a really long decimal place
and a lot of precision is important,
you probably want to
use a double overfloat.
Now for most of your work in
CS50, a float should suffice.
But do know that doubles exist as a
way to somewhat deal with the precision
problem by giving you an extra 32
bits to work with for your numbers.
>> Now this is not a data type.
This is a type.
And it's called void.
And I'm talking about it
here because we've probably
seen it a few times already in CS50.
And you might be wondering
what it's all about.
>> So void is a type.
It does exist.
But it is not a data type.
>> We can't create a variable of type
void and assign a value to it.
But functions, for example,
can have a void return type.
Basically, if you see a function
that has a void return type,
it means it doesn't return a value.
>> The parameter list of a
function can also be void.
And you've also seen that
quite a bit in CS50 too.
Int main void.
Does that ring a bell?
Basically what that means is that
main doesn't take any parameters.
There's no argument that
get passed into main.
Now later on we'll see that there is
a way to pass arguments into main,
but so far what we've
seen is int main void.
Main just doesn't take any arguments.
And so we specify that by saying void.
We're just being very
explicit about the fact
that it doesn't take any arguments.
>> So for now, suffice it to
say that void basically
should just serve as a placeholder
for you as thinking about as nothing.
It's not really doing anything.
There's no return value here.
There's no parameters here.
It's void.
It's a little more complex than that.
But this should suffice for
the better part of the course.
And hopefully now you have a little
bit more of a concept of what void is.
>> So those are the five types you'll
encounter that are built-in to C.
But in CS50 we also have a library.
CS50.h, which you can include.
And which will provide you
with two additional types
that you'll probably be able
to use on your assignments,
or just working generally programming.
>> The first of these is bool.
So the Boolean data type,
bool, is used for variables
that will store a Boolean value.
If you've ever heard
this term before, you
might know that a Boolean
value is capable of only
holding two different distinct values.
True and false.
Now this seems pretty
fundamental, right?
It's kind of a surprise that this
doesn't exist in C as it's built-in.
And in many modern languages,
of course, Booleans
are a standard default data type.
But in C, they're actually not.
But we've created it for you.
So if you ever need to create
a variable whose type is bool,
just be sure to #include CS50.h
at the beginning of your program,
and you'll be able to create
variables of the bool type.
>> If you forget to #include CS50.h, and
you start using Boolean-type variables,
you might encounter some problems
when you're compiling your program.
So just be on the lookout for that.
And maybe you can just fix the
problems by pound including CS50.h.
>> The other major data type that we
provide for you in the CS50 library
is string.
So what is a string?
Strings are really just words.
They're collections of characters.
They're words.
They're sentences.
They're paragraphs.
Might be whole books, even.
>> Very short to very long
series of characters.
If you need to use strings,
for example, to store a word,
just be sure to include CS50.h
at the beginning of your program
so you can use the string type.
And then you can create variables
whose data type is string.
Now later on in the course,
we'll also see that that's
not the entire story, either.
We'll encounter things
called structures,
which allow you to group what may be
an integer and a string into one unit.
And we can use that for
some purpose, which might
come in handy later on in the course.
>> And we'll also learn
about defined types,
which allow you to create
your own data types.
We don't need to worry
about that for now.
But just know that that's
something on the horizon,
that there's a lot more to this whole
type thing than I'm telling you just
now.
So now that we've learned a
little bit about the basic data
types and the CS50 data types, let's
talk about how to work with variables
and create them using these
data types in our programs.
If you want to create a variable,
all you need to do is two things.
>> First, you need to give it a type.
The second thing you need
to do is give it a name.
Once you've done that and slapped a
semicolon at the end of that line,
you've created a variable.
>> So here's two examples.
Int number; char letter;.
What have I done here?
I've created two variables.
>> The first, the variable's
name is number.
And number is capable of holding integer
type values, because its type is int.
Letter is another variable
that can hold characters
because its data type is char.
>> Pretty straightforward, right?
If you find yourself
in a situation where
you need to create multiple
variables of the same type,
you only need to specify
the type name once.
Then just list as many variables
of that type as you need.
>> So I could for example, here
in this third line of code,
say int height;, new line.
Int width;.
And that would work too.
I'd still get two variables called
height and width, each of which
is an integer.
But I'm allowed to, things to C syntax,
consolidate it into a single line.
Int height, width; It's the same thing.
I've created two variables, one called
height one called width, both of which
are capable of holding
integer type values.
>> Similarly here, I can create three
floating point values at once.
I can maybe create a variable
called square root of 2--
which presumably will eventually
hold the floating point--
that representation of the square
root of 2-- square root of 3, and pi.
I could have done this
on three separate lines.
Float, square root 2; Float square root
3; float pi; and that would work too.
>> But again, I can just consolidate
this into a single line of code.
Makes things a little bit
shorter, not as clunky.
>> Now in general, it's good design to only
declare a variable when you need it.
And we'll talk a little
bit more about that
later on in the course
when we discuss scope.
So don't necessarily need to
create all of your variables
at the beginning of the program, which
some people might have done the past,
or was certainly a very common
coding practice many years ago
when working with C. You might just
want to create a variable right when
you need it.
All right.
So we've created variables.
How do we use them?
After we declare a
variable, we don't need
to specify the data type
of that variable anymore.
In fact, if you do so, you might
end up with some weird consequences
that we'll kind of gloss over for now.
But suffice it to say,
weird things are going
to start happening if you inadvertently
re-declare variables with the same name
over and over.
>> So here I have four lines of code.
And I have a couple of
comments there just indicating
what's happening on
each line just to help
you get situated in what's going on.
So int number;.
You saw that previously.
That's a variable declaration.
>> I've now created a variable
called number that's
capable of holding integer-type values.
I've declared it.
>> The next line I'm assigning
a value to number.
Number equals 17.
What's happening there?
I'm putting the number 17
inside of that variable.
>> So if I ever then print out what
the contents of number are later on,
they'll tell me it's 17.
So I've declared a variable,
and then I've assigned it.
>> We can repeat the process
again with char letter;.
That's a declaration.
Letter equals capital
H. That's an assignment.
Pretty straightforward, too.
>> Now this process might
seem kind of silly.
Why are we doing this
in two lines of code?
Is there a better way to do it?
In fact, there is.
Sometimes you might see
this called initialization.
It's when you declare a variable
and assign a value at the same time.
This is actually a pretty
common thing to do.
When you create a variable, you usually
want it to have some basic value.
Even if it's 0 or something.
You just you give it a value.
>> You can initialize a variable.
Int number equals 17 is the same as
the first two lines of code up above.
Char letter equals h is the same as the
third and fourth lines of code above.
The most important takeaway here
when we're declaring and assigning
variables is after we've
declared it, notice
I'm not using the data type again.
I'm not saying int number equals 17 on
the second line of code, for example.
I'm just saying number equals 17.
>> Again , re-declaring a variable after
you've already declared it can lead
to some weird consequence.
So just be careful of that.
>> I'm Doug Lloyd.
And this is CS50.
