Original subtitles

So in this video will just demonstrate and give you I will give you some examples of streams that are

being used automatically whenever a new program is being launched.

OK, so basically show you how things were done so far and you haven't even noticed.

So let's start and let's say that we have like I don't know, we have this keyboard.

Right?

We have these nice little keyboard right here.

OK, sorry for my drawing specialties.

So this will be the key word, keyboard, keyboard.

This will be the keyboard.

And here we will have some display.

I don't know, something like that.

Some screen.

And we also have what do we have, we have something like that, we have our program.

So that's the program you've written, your main function and you are going to run it and we are going

to see what streams are associated with the program and the screen itself.

And the first thing that I want to start talking about is let's write it right here, is the standard

standard input.

All right, so the standard input and this is basically a pointer to your keyboard and the things that

you type in from these keyboard by pressing this one, and after that, this one and this one and so

on, these things that you type in from your keyboard that are being read by this pointer, by this

standard, the input pointer, or simply saying, let's say that our computer has an associated input

stream, let's make it like this, OK?

So this will be some input.

Input stream.

OK, and input stream of bytes, for example, and this stream will basically hold all the characters

you've typed from the keyboard before, it's being read by your program.

OK, so these characters you're going to type like this, c, d, e, s and so on and so forth are going

to be inserted inside of this input stream in some sort of a Q structure, OK?

So it will be like a Q structure structure.

So there will be like a character, a C, a character, a D, a character is there and so on and so

forth.

Some space.

And basically you got the idea.

And then basically every character that you that you've entered using these keyboard is being passed,

these IQ and then using your program, OK, you will be able to access these IQ using some SDD in remember

these one SDD input, SDD input, standard input, you will be able to access these IQ from your program.

And basically, you're going to read the characters from there, either it's going to be one by one,

well, two at a time and so on and so forth, even it's going even if it's going to use like the famous

caniff function that you're familiar.

Right.

So you're going to read different data from these.

Q And to basically translate these data based on the data type that you want to read and stories in

different variables, for example.

OK, so I hope that's clear.

Very important to understand this concept.

And also something that emphasizes the usage of KIU, let's say, for example, that you're typing something

using your keyboard.

I just want to show you that these things are getting inserted in a sort of a Q one after the other.

So if you have some form to feel right, some form that you have to feel, so you type down your first

name, your last name, but in the middle of the process, your program getting stuck in you like you

type everything from the keyboard, but you don't see the result yet.

It's getting stuck for one, two seconds and then you're going to see, like everything written to the

screen just the way you inserted it using the keyboard.

OK, so that's also where the key you think is involved.

So I hope that's clear.

If not.

Please feel free to ask any questions that you need.

We're here to help.

And now let's move on to where is it, where is it?

Let's move on to the standard output and we stand there and output.

OK, so this was the first one stand.

There are the input and we have like, let me read it and let me remove it standard.

Standard output.

So they stand there and the output is basically also a pointer and these pointer points, where do the

screen OK, and these pointer may provide different capabilities for you to display different messages

on this screen.

OK, so from your program, you're going to try running different.

Operations to display something to the screen, but here you will have like an output stream output

stream.

That behind the scenes, when you used like printf and so on and so forth, you used it to display different

messages that passed through these outward stream from your program.

To the screen off your, let's say, console application console app into display different values right

there.

OK, so that's the output stream.

And also we have what do we have?

We also have something that is called let me droid right here like that.

OK, so we have something that is called the standard error.

OK, so the third one is Standard Steane, the third system, Dand.

Error.

OK, basically, that's the third one that we are going to discuss in this video and simply saying this

is a pointer also to the screen, another pointer to the screen.

And and it is usually used to write different error messages to your screen without letting you specify

anything.

So you will simply it is simply done kind of automatically behind the scenes.

OK, so this is related to the error and it's used to simply show you that.

There is some problem in your code or some bugs are on.

Something else.

So on and so forth, OK, so output stream is the basic that you use from your program to display different

things on the screen and understand there are there are usually used without you specifying it simply,

explicitly is being used implicitly to specify that some errors have been occurred.

And yeah, so these were the standard sources for input and output information that we've used so far.

OK, the Ezzedine was used as an input source, DSD out and the error were used as output sources.

And now what we are going to learn about files is basically something very, very interesting.

OK, so we can see that so far we've read the information.

OK, that's our program.

We've been reading the information from the keyboard and we've been plotting the information, some

information from the program to the screen to the console application.

So we are going basically to modify it a little bit and say that let's instead of reading from information

from the keyboard, we may read information from some file.

OK, so there will be some file with some text inside of it.

And we are going to configure our program to read information from this file.

OK, just like we've configured it to read information from the keyboard and inserted like key keystrokes

after another.

So now we are going to read from the file.

OK, so we are going to read from files.

OK, just different functions, but the concept is very, very similar.

And it's very important for for you to understand clearly that your program can be configured to read

from the keyboard or from different files and also in a similar way, instead of plotting all the information

just by default.

Let's go live for now to the screen.

We may also plot information or write to a file.

OK, so instead of writing to some console application, we will be able to write information to some

file that these file will be later on stored in some non-volatile memory device.

And we will be able then to read it once again and work with it and so on and so forth.

So that's basically everything you have to understand.

So far, the streams, how you manipulate them, where you read this information from, where do you

write the information to, and so on and so forth.

And in this section we will see basically we will focus on these files, how to read from them, how

to write to them, different types of operations on files, because this part right here with working

with keyboards and screen, it will also accompany this section.

But these things will not be the main focus for this section.

In this section, we will focus on working with files, different functions, syntax usage, what happens

behind the scenes, what happens in the level and the level of the bytes and so on and so forth.

So I hope you like this video.

I hope you enjoyed it.

And.

As always, thank you so much for watching.

Keep on practicing.

Keep on working hard.

My name is Vlad, this is Alphatech and I will see you in the next videos.

Bye bye.