All language subtitles for 4. C-Actions introduction #3

Hello and welcome in see action in the U.S. for seven.

Today, we have the third movie about this action.

As we remember, the variable is reserved area in our memory inside our computer that stores the data

needed to perform some actions.

For example, we need to calculate some volume or calculate some specific math elements.

This.

Variable and.

The size of the desert memorial depends on the type of this element, so different sizes for the char

elements and different sizes for floating point.

But in later we will go deeper so that programming guy or the programmer computer is going to variable

using this name specific to variable declarations.

So we have always the name and the type of our variable, and we can't leave this without this declarations.

So we always need to perform this specific elements.

Let's go to first example.

In first example, I did a small script in, say, the Civil Seven where I put some declarations we

have char and float short double bird by word and the word, as you see.

Every time I use the declaration online, I need to perform that declaration time and I need to perform

the name of the variables inside our script and I need to finish the line with semicolon.

But we did talk about this in the video.

If you didn't solve this, go back and check this.

So we have the four basic dives inside and C and also in C actions in C, we have the cha cha issues

for.

Keep in memory the one character, that ASCII character, and we can inside this jar, we can put,

for example, the A, B, C, the.

Each character separately.

So if you want to have 10 characters, we need to have 10 variables inside our script.

The next basic is integer int.

It keeps usually in 64 bytes, brontosaurs, four bytes memory.

We can put here that integers.

We can put here some big numbers and low numbers.

But I have examples in lighter's screens.

We have the float, so we need sometimes put some calculations inside our variables.

So we have the floating point values in float type.

We can use the six digits after the.

Dot pointing so we can put that zero point zero zero zero zero zero, for example, nine, and we have

the six digits and we can put this into Floud type.

The next is double.

Double has the double possibilities as flawed so we can have 10 digits after our point number.

But the memory in our memory is that memory computer.

We need the eight bytes every time we use this data type.

We can use some modifiers inside, see actions, we can use the short, long side on side and some more,

but it's the basic modifiers for C language so we can put before, for example, and we can say short

and long and unsigned int signed in so we can modify the.

The variables limits inside our number, so we can have that integer if we sign and we have the same

integer with unsigned only numbers so we can modify our memory and we can also change the limits for

our docs.

In this example, I show how to use this modifiers inside integers so we can have them less or more

space used in our process of.

So I have 64 bit processor and my int integer base line.

This first line and this line keep for me four bytes.

So my memory is used for bytes and we can decrease the range using this, for example, short end.

And after I use the short end, my size of memory used for this kind of.

Dog is shorter to two bites.

As you see below, I use that end short and I use that big, unsigned, long, long end to show you

how our integer working inside wins see seven so I can put my ten number inside my values.

But after this, the size of the stack is different.

So our integer short is that less space inside our script.

Keep in mind.

So if you don't need a lot of memory inside your scripts, you can make this shorter to make this better

performance.

Here I put some.

Examples how to use this, some basic elements inside the NCC, so we have the JARDÍN flow chart, double

byte word and the word ball by word and the word is specified for Zaman's application because we always

use in Zaman's application this kind of stuff.

But the first chart in Floud, short double.

As you see, I put some declarations.

So ABC is four for me a the floating value is zero point zero zero zero zero three integer number is

two nine nine and for example, double the value of this 19 dot nine nine nine nine nine nine nine one.

And my book value, I can put that true or false.

It's my declarations and I can use this bool value inside my script later.

Inside, we see actions we can put us under our eyes, let's say I heard the floating point table with

100 lemons, this table has the 100 elements with.

Floating point values, so I can put 100 floating point elements inside out.

All right, I have the index.

This index go through my table one by one, and I can put a lot a lot of values inside my table.

We have the index from zero.

So I have to index 99, as you see on screen, the same with integer table as you see we have in the

end, in the end and twenty ninth element is also the integer.

We don't have to index because it's out of our table, the same as that chart table.

As you see I have two hundred fifty, fifty six elements by my index.

It's only going to to fly five and if I put some characters' inside our inside my table three in last

element I need to put the null value so system know that it's finish off my table of string.

I can also declare some Konstanz, so as you see my chart, text one and I open and close the brackets,

it's find me here but this the same I can make it with.

The second option is text two, but it's the second option.

The text, too.

I have the indicator to my text and I can put also the find me here after I print a f this option,

we will talk in about the print F options, but not now its introduction to C actions to show you step

by step the elements.

So I use the print F option and I displayed inside our we see runtime that values.

So on the right side you see that text in text one was find me here and text in indicative text to was

also there.

Find me here.

In ruins seafoam seven actions, we can declare some numbers, usually we use the decimal, but in some

case we can use all of that hex and floating point.

The first decimal is the easier one.

We can put, for example, one where 50, 60 or so.

It's that simple into.

That's human, for example, at the end value we can put of that hex value, if you want to put the

hands value, we need to remember about the zero X before our X value.

It's important because without this system will know that it's dead simple at not X, it's just difficult

to think to remember about this.

The last point is the floating point.

First is the normal notification about the floating point.

So it's one point ninety nine.

It's normal or 5.5.

It's it's just not notifications.

And the next, if you want to use the power, we need to remember the power in WTC four seven actions.

We need to put 1.0 e power.

Then, for example, as you see on my screen, it's the power version of Floating Point.

If you have any questions about this, alignment's I talked today does give me the comments, I hope

you understand how you go with variables, incitements to civil servants actions.

If you have something, leave me the comments.

I try to make you the answer.

In the next video, we will go through next introduction movies.

Keep in mind that I used always the Zamansky mom, for whom I used also the C programming language,

but.

I use also the C programming language, the answer is C from Brian Darryll Cadigan, it's the fantastic

book and my blog is MISCA the word go dot com.

Goldar, I invite you to my mailing list so you can be up to date with my documents and some presentations.

See you and have fun.