All language subtitles for data_types-720p-en

>> [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.

Can you think of a common function that we've used so far

in CS50 that doesn't return a value?

>> Printf is one.

Printf does not actually return anything to you.

It prints something to the screen, and it's basically

a side effect of what printf does.

But it doesn't give you a value back.

You don't capture the result and store it in some variable to use it later on.

It just prints something to the screen and you're done.

>> So we say that printf is a void function.

It returns nothing.

>> The perimeter 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.