1
00:00:01,350 --> 00:00:06,960
So how can we kind of remedy this situation that we have right here?

2
00:00:09,190 --> 00:00:17,260
Well, something that we can do is, you know, if the scene fails.

3
00:00:18,480 --> 00:00:27,000
So this is just like a very kind of hard coded example, but, you know, we know that it failed here

4
00:00:27,000 --> 00:00:27,750
on this.

5
00:00:29,920 --> 00:00:35,200
You know, this integer when we entered a B, so I just kind of want to show you what's going on with

6
00:00:35,200 --> 00:00:43,270
this keyboard buffer and how we can actually change it to still read in this 10.

7
00:00:43,960 --> 00:00:48,250
And this isn't going to be like a super programmatic way, but it's meant to just kind of show you what's

8
00:00:48,250 --> 00:00:50,020
going on with the keyboard keyboard buffer.

9
00:00:51,010 --> 00:00:54,070
So we have this scene to fail, right?

10
00:00:55,660 --> 00:01:03,220
If it fails, I can actually do something called in dot clear.

11
00:01:05,140 --> 00:01:09,100
The C unclear is actually going to.

12
00:01:10,300 --> 00:01:11,080
Clear.

13
00:01:11,290 --> 00:01:22,660
The failed bid, so this thing that happens is that there's basically a failure in the seeAnd input

14
00:01:23,050 --> 00:01:27,200
which happens here on this character, right, because we expected an integer.

15
00:01:27,220 --> 00:01:32,620
Yet it was a character, so it's kind of messed up everything at that point.

16
00:01:32,950 --> 00:01:35,110
So what we have to do?

17
00:01:36,760 --> 00:01:43,080
Is when it fails, we need to fix that failure, so we need to clear that like it was called kind of.

18
00:01:43,150 --> 00:01:44,920
You can think of it like a flag.

19
00:01:45,370 --> 00:01:50,200
Quite often people refer to these things as flags, but there's kind of some flag that gets set that

20
00:01:50,200 --> 00:01:51,550
says, Oops, stuff failed.

21
00:01:51,550 --> 00:01:52,900
Everything's messed up now.

22
00:01:53,870 --> 00:02:00,650
What you can do is see CNN since you're using this object still, as you can clear that failure out

23
00:02:00,650 --> 00:02:02,030
by using the dot clear.

24
00:02:02,030 --> 00:02:09,080
So this says OK, we notice we failed, go ahead and clear that fail so we can continue doing stuff.

25
00:02:11,730 --> 00:02:14,880
So then what we can do is have.

26
00:02:16,850 --> 00:02:30,230
A scene in Dot Ignore is this other thing that basically says, OK, like we cleared the failure, but

27
00:02:30,230 --> 00:02:34,520
what we're going to do is we're going to ignore this like.

28
00:02:35,420 --> 00:02:41,090
However, many characters of failed input came in in this case, we just have this.

29
00:02:42,130 --> 00:02:49,870
One character right here, right, which is a B when we expected it in, and so if I go see and ignore

30
00:02:50,740 --> 00:02:52,180
and I put a one in there.

31
00:02:53,780 --> 00:02:58,520
It's going to ignore this B and then kind of keep going.

32
00:02:59,790 --> 00:03:04,080
So let's go ahead and see what happens when we just leave it like this.

33
00:03:04,710 --> 00:03:06,480
So I'm going to go ahead and save.

34
00:03:09,270 --> 00:03:17,130
I want to run this a 2.7, b 10, so you notice that it still is kind of messed up here.

35
00:03:19,690 --> 00:03:25,120
So let's kind of see what happens if we were to read this in afterwards.

36
00:03:27,310 --> 00:03:36,700
So I'm just going to put these three right here, and then I'm going to put this scene in two afterwards.

37
00:03:39,750 --> 00:03:42,780
And so what I'm going to do is.

38
00:03:44,720 --> 00:03:47,000
Let's see, I'll go ahead and.

39
00:03:50,210 --> 00:03:51,350
Comment things out.

40
00:03:59,690 --> 00:04:02,390
So I run this you notice it still has a garbage value.

41
00:04:02,580 --> 00:04:04,700
And go ahead and I uncomment this.

42
00:04:14,180 --> 00:04:15,530
And now what happens?

43
00:04:16,280 --> 00:04:17,630
Pretty interesting, right?

44
00:04:18,350 --> 00:04:21,320
So it had a zero.

45
00:04:21,650 --> 00:04:25,580
Still, because this was like a failure, so it still failed.

46
00:04:25,580 --> 00:04:30,230
But then what happened is we cleared the failure out so we could continue collecting input.

47
00:04:30,590 --> 00:04:33,680
Then we said, OK, ignore that failed be.

48
00:04:34,680 --> 00:04:42,750
And then afterwards, we went ahead and we tried to then take in this eye to so read in the eye, too,

49
00:04:43,080 --> 00:04:46,320
which was the 10 that was remaining on the keyboard buffer, right?

50
00:04:47,250 --> 00:04:51,240
This was actually Romanian on the keyboard before as a failed kind of thing.

51
00:04:51,240 --> 00:04:53,460
So we kind of we ignored it.

52
00:04:53,460 --> 00:04:55,500
But then we did want to read this and write.

53
00:04:59,120 --> 00:05:05,590
So pretty interesting, so what we did was after we cleared this failure and then got rid and ignore

54
00:05:05,600 --> 00:05:11,300
of this other thing, then it was successfully able to read in the ten here and we can just test this

55
00:05:11,300 --> 00:05:12,660
again with another value too.

56
00:05:12,680 --> 00:05:18,980
So if I was a, you know, eight point four or eighty nine point eighty eight point four, it can be

57
00:05:18,980 --> 00:05:19,620
anything.

58
00:05:20,090 --> 00:05:23,990
And then I just put it like, you know, age and then I put like 123.

59
00:05:25,400 --> 00:05:32,330
So you notice it still does the reason the character, it reads in our float and then it failed on the

60
00:05:32,360 --> 00:05:32,910
page.

61
00:05:33,290 --> 00:05:41,120
But then it was able to clear that, and then it was able to ignore the age and then continue on with

62
00:05:41,120 --> 00:05:46,460
this line where it successfully read this off of the existing keyboard buffer.

63
00:05:47,690 --> 00:05:53,540
And if I was to put something after this, so I have i3 up here still, right?

64
00:05:54,650 --> 00:06:00,710
So now it will actually be able to prompt me if I compile and run this again.

65
00:06:01,460 --> 00:06:06,720
Let's go ahead and do the same things on the, say, a any eight point four age and one twenty three.

66
00:06:08,330 --> 00:06:10,880
And so says oeufs and failed.

67
00:06:11,180 --> 00:06:16,540
But now what happens is it's read this off the keyboard buffer and now it got to here.

68
00:06:16,550 --> 00:06:25,670
And since we have satisfied, you know, all of the stuff that we've asked for already with this input,

69
00:06:25,970 --> 00:06:30,770
then it goes ahead and pauses and starts for us to enter something else.

70
00:06:31,190 --> 00:06:34,670
Because you noticed that we had we basically asked for four things.

71
00:06:34,670 --> 00:06:36,050
So here's one two three.

72
00:06:37,010 --> 00:06:38,930
Then you noticed this one failed, right?

73
00:06:38,930 --> 00:06:39,680
But we cleared it.

74
00:06:39,680 --> 00:06:41,000
We ignored that character.

75
00:06:41,000 --> 00:06:44,660
And then we read this other thing off the keyboard.

76
00:06:44,660 --> 00:06:46,610
So we asked for four things.

77
00:06:46,910 --> 00:06:48,890
One, two, three four.

78
00:06:49,250 --> 00:06:52,460
And we gave it four things one two, three four.

79
00:06:53,150 --> 00:06:58,970
So since we gave it the same amount of stuff and asked for now, when it asks us for a new thing, it

80
00:06:58,970 --> 00:07:03,740
stores ways for us to enter it, which I can just put, you know, whatever.

81
00:07:05,330 --> 00:07:07,580
And then it goes ahead and it finishes.

82
00:07:07,580 --> 00:07:11,650
Of course, we're not printing out this i3 anymore.

83
00:07:13,010 --> 00:07:14,930
You know, I could uncomment this.

84
00:07:16,250 --> 00:07:18,640
I could save this compile.

85
00:07:19,200 --> 00:07:27,200
And again, to a a let's just do seventy eight point four eight point twenty three, then I could do

86
00:07:27,200 --> 00:07:32,180
this forty five and you notice that now that forty five gets printed out, actually.

87
00:07:32,180 --> 00:07:35,540
So it went ahead and did this, dealt with the air.

88
00:07:35,540 --> 00:07:39,230
Read this Off the keyboard buffer, it printed all this stuff out.

89
00:07:39,680 --> 00:07:44,840
Then it was able to read in our forty five and print this out.

90
00:07:47,370 --> 00:07:57,150
So pretty cool this year and ignore it, can have some more functionality, you can put some other things

91
00:07:57,150 --> 00:08:01,470
that tell it to go up to the end of the line and stuff.

92
00:08:01,860 --> 00:08:04,920
We're going to get a little more into that stuff later.

93
00:08:04,920 --> 00:08:13,770
So we'll look into kind of making more complex programs with not only reading stuff in from the console,

94
00:08:13,770 --> 00:08:15,630
but we'll read stuff in from files.

95
00:08:16,380 --> 00:08:22,860
When we do that, we're going to kind of expand on this knowledge here, but I wanted to give you enough

96
00:08:22,860 --> 00:08:27,330
of an introduction to it where you felt like you knew it pretty well and you at least understood what

97
00:08:27,330 --> 00:08:28,200
was happening.

98
00:08:28,410 --> 00:08:33,350
When people are entering things here on the console and it's being read into the program.

99
00:08:34,740 --> 00:08:42,810
So just like I said, if you can't remember all of these, like fail clear and ignore just, you know,

100
00:08:42,960 --> 00:08:48,060
if you just remember what seeAnd fail does, you know that's enough of a of a success.

101
00:08:48,060 --> 00:08:54,150
But the main thing to take away from this lecture and the previous lecture is that you kind of are able

102
00:08:54,150 --> 00:09:01,200
to understand what happens when you put these in a different, a different order.

103
00:09:01,410 --> 00:09:05,040
So some interesting things can happen.

104
00:09:05,220 --> 00:09:07,680
Actually, I might do another quick example.

105
00:09:07,680 --> 00:09:17,670
So because I want to kind of want to show you what happens when you read in a CHA- like, let's say,

106
00:09:17,670 --> 00:09:24,810
after a float or something, we'll just switch these around out for an integer and then I'll put a cha.

107
00:09:26,090 --> 00:09:27,440
And then I'll put a float.

108
00:09:30,550 --> 00:09:32,200
Yeah, and then.

109
00:09:33,320 --> 00:09:37,910
We're actually learning to float here, so integer and a float and then a cha.

110
00:09:40,890 --> 00:09:48,840
So I'm going to kind of show you just some different things, just so we can drill it in, it's another

111
00:09:48,840 --> 00:09:50,940
example before we finish up here.

112
00:09:52,110 --> 00:09:53,010
So.

113
00:09:54,660 --> 00:09:55,770
Now I have it.

114
00:09:56,160 --> 00:10:01,980
I saved it and compiled it, and it has and the integer first and then a float and then a char.

115
00:10:02,550 --> 00:10:03,030
So.

116
00:10:04,650 --> 00:10:13,440
If we can do enter some input in an interesting way, if I put a two point seven here.

117
00:10:16,120 --> 00:10:23,110
And then I put let's say I did that instead of an integer, I actually accidentally entered two point

118
00:10:23,110 --> 00:10:23,740
seven.

119
00:10:26,140 --> 00:10:29,420
And then I did like a three point five or something like that.

120
00:10:32,050 --> 00:10:33,250
And then I did a B.

121
00:10:33,950 --> 00:10:35,560
Let's let's see what happens with this.

122
00:10:37,510 --> 00:10:40,030
So I'm going to run this.

123
00:10:43,410 --> 00:10:43,860
So.

124
00:10:45,060 --> 00:10:52,890
What happens is I'm actually, yeah, actually this is out of order, so let me let me put this in a

125
00:10:52,890 --> 00:10:58,050
different order now, so I'm actually going to say and.

126
00:11:02,030 --> 00:11:08,090
And then float, I got to make sure to put the spaces over for an extra space, actually.

127
00:11:10,820 --> 00:11:13,100
And I might want to actually put my integer.

128
00:11:14,300 --> 00:11:16,400
So then I'll put float and I'll put the.

129
00:11:17,720 --> 00:11:21,600
And then I will put Cha.

130
00:11:21,890 --> 00:11:23,510
And then I'll put the see.

131
00:11:23,780 --> 00:11:24,480
So let's just do.

132
00:11:24,500 --> 00:11:25,210
Let's just do this.

133
00:11:25,220 --> 00:11:26,030
I'm going to save it.

134
00:11:26,330 --> 00:11:27,590
Ignore that example.

135
00:11:28,130 --> 00:11:31,520
I'm going to compile this and run this.

136
00:11:31,880 --> 00:11:32,570
So let's do it.

137
00:11:32,600 --> 00:11:33,280
Let's do this.

138
00:11:33,290 --> 00:11:35,150
We have this 2.7, right?

139
00:11:35,930 --> 00:11:44,030
So I accidentally enter a float instead of an integer and then now I enter a float as well, and then

140
00:11:44,030 --> 00:11:44,750
I enter a b.

141
00:11:48,290 --> 00:11:51,380
So what we see here is that.

142
00:11:53,130 --> 00:11:59,100
We get a two for the integer, because what happened is that.

143
00:12:00,250 --> 00:12:09,370
It saw this, too, and even though there was a point seven since it had this to was a valid integer,

144
00:12:09,460 --> 00:12:11,560
the point wasn't a valid part of the integer.

145
00:12:11,560 --> 00:12:16,270
Then it basically stopped and it read this to in for the end, which is totally valid.

146
00:12:17,110 --> 00:12:24,610
Then what happened is the float didn't end up being, you know, two point seven or three point five.

147
00:12:24,910 --> 00:12:29,410
It actually saw the next thing on the keyboard buffer, which was the point seven.

148
00:12:29,830 --> 00:12:35,010
So it turned that into a float and it put a zero instead of just zero point seven intact on this zero

149
00:12:35,010 --> 00:12:36,160
four zero point seven.

150
00:12:37,840 --> 00:12:43,930
Then what happened was we had a char and we expected it to be the B, but it wasn't.

151
00:12:43,930 --> 00:12:46,510
In fact, I remember a number can be a valid char.

152
00:12:46,510 --> 00:12:53,620
Remember, in the last lecture, we had it labeled the rectangle as the number eight because numbers

153
00:12:53,620 --> 00:12:54,900
are valid chars.

154
00:12:54,910 --> 00:12:58,600
You know, you might like want that as a piece like an actual character.

155
00:12:58,600 --> 00:13:03,130
If you think you like the ASCII table, you know numbers can be valid characters as well.

156
00:13:04,570 --> 00:13:09,400
It's not seen as a no, it's just seen as a character, because maybe it was like a name of something,

157
00:13:09,400 --> 00:13:12,670
you know, like building eight or something, not just like.

158
00:13:13,740 --> 00:13:16,440
A number, so it reads that it is a cha.

159
00:13:17,940 --> 00:13:20,520
And then afterwards, you know it.

160
00:13:21,690 --> 00:13:27,540
Basically kind of leaves the rest of this on the keyboard buffer.

161
00:13:29,010 --> 00:13:33,450
The next thing we had was this I, too, which is supposed to be an integer.

162
00:13:36,430 --> 00:13:45,880
So and then we have this last end, so we're not really printing out the eye to actually actually comment

163
00:13:45,880 --> 00:13:46,260
to out.

164
00:13:46,630 --> 00:13:50,560
But, you know, the integer basically tried to read in whatever came after this char.

165
00:13:54,050 --> 00:13:58,700
You know, that was read in after the check for the sea and fail, so it failed, but it didn't really

166
00:13:58,700 --> 00:13:59,540
know that it failed.

167
00:13:59,540 --> 00:14:01,670
So I'm going to go ahead and just comment that out.

168
00:14:01,670 --> 00:14:03,350
So it's not extra confusing.

169
00:14:03,800 --> 00:14:06,080
But then this last one was garbage, right?

170
00:14:07,430 --> 00:14:11,240
Because it wasn't really able to properly read into it because it failed.

171
00:14:12,020 --> 00:14:16,100
And also, you know, we had a car here anyways afterwards.

172
00:14:16,100 --> 00:14:20,630
So but it failed on this when it was trying to read that into it to.

173
00:14:23,760 --> 00:14:27,930
So, you know, I can comment this out, and now we just have this.

174
00:14:28,440 --> 00:14:29,340
Go ahead and.

175
00:14:30,740 --> 00:14:31,640
Get rid of this.

176
00:14:31,760 --> 00:14:38,390
But we can put something else, let's see, instead of seeing to a three, I'll put a.

177
00:14:40,410 --> 00:14:42,150
Let's see into

178
00:14:44,820 --> 00:14:56,040
let's make like some other Char, so I can say like Char B or something like that, and I go ahead and

179
00:14:56,040 --> 00:15:08,280
I read into this char b, go ahead and delete this and then I'll actually see out a second char.

180
00:15:12,190 --> 00:15:17,410
And I will put this be right.

181
00:15:19,870 --> 00:15:23,620
I'm also going to put it in line at the end of this month.

182
00:15:25,390 --> 00:15:27,920
So now let's let's kind of go through the same example.

183
00:15:27,940 --> 00:15:33,820
I'm just doing, you know, quite a few examples just so we can really like understand what's going

184
00:15:33,820 --> 00:15:34,090
on.

185
00:15:34,120 --> 00:15:37,620
So I'm going to say that I'm going to compile it and write it again.

186
00:15:37,630 --> 00:15:39,550
So let me try and enter the same stuff.

187
00:15:39,550 --> 00:15:44,770
We'll do this two point seven three point five So we're just pretending like, Oh, let's I forgot it's

188
00:15:44,770 --> 00:15:49,780
in and I'm just going to enter two point seven and then I'll continue on unless if I'm reading my float

189
00:15:49,780 --> 00:15:52,060
in and then I'll put a B.

190
00:15:53,990 --> 00:15:54,650
Right here.

191
00:15:56,670 --> 00:16:01,560
So let's see what happens, so what it does is it still does the same thing, right?

192
00:16:01,590 --> 00:16:03,420
We haven't changed the kind of the initial part.

193
00:16:04,080 --> 00:16:09,870
It reads in the integer two since there's a point after it's like, Oh, I'm just going to read it in

194
00:16:09,870 --> 00:16:15,050
this integer two because it's supposed to mean and then the float ended up being this 0.7.

195
00:16:15,070 --> 00:16:16,830
That was the next thing on the keyboard buffer.

196
00:16:18,880 --> 00:16:24,070
And then this was the next thing that was in the keyword buffer was this like valid char, which is

197
00:16:24,070 --> 00:16:24,640
three.

198
00:16:25,860 --> 00:16:32,000
The next thing on the keyboard buffer, it was all this stuff, but the exact next thing was this dot.

199
00:16:32,840 --> 00:16:39,230
So what happened was this dot was seen as a valid car and it was read into the B.

200
00:16:39,770 --> 00:16:41,870
So the period was read into the B.

201
00:16:42,910 --> 00:16:45,850
And so that's why it printed that period out right here.

202
00:16:46,540 --> 00:16:50,230
The rest of the stuff, you know, it actually failed.

203
00:16:51,790 --> 00:16:58,900
So it it didn't it failed kind of after or actually we took it in and the rest is on the keyboard buffer,

204
00:16:58,900 --> 00:17:00,400
so it actually didn't fail.

205
00:17:02,020 --> 00:17:05,620
If we tried to read in further stuff, we actually could.

206
00:17:06,100 --> 00:17:11,740
So I could see in at this point into i3.

207
00:17:13,920 --> 00:17:19,010
And then it should have this five here, so let's go ahead and check that out, right?

208
00:17:19,080 --> 00:17:21,240
Because we're just kind of keeping track of what we've done.

209
00:17:21,660 --> 00:17:23,020
Well, reading in thus far.

210
00:17:23,370 --> 00:17:29,910
So Chas was valid up to here and then this was left over on the keyboard buffer.

211
00:17:30,840 --> 00:17:33,990
So I'm actually going to show you that this won't stall.

212
00:17:34,980 --> 00:17:36,210
So I'm going to copy that.

213
00:17:36,210 --> 00:17:39,210
And what I'm going to do is put put it after this.

214
00:17:39,900 --> 00:17:44,280
So we're going to print this stuff out and then ask it afterwards, and I'll show you that it doesn't

215
00:17:44,280 --> 00:17:44,760
stall.

216
00:17:44,760 --> 00:17:48,180
What it's going to do is actually just read this integer.

217
00:17:48,690 --> 00:17:53,460
Read this as an integer off the keyboard buffer, and it's not going to like pause and wait for us to

218
00:17:53,460 --> 00:17:54,180
enter anything.

219
00:17:58,380 --> 00:18:04,020
So I'll do that same thing, so two point seven, three point five B.

220
00:18:05,940 --> 00:18:12,060
Oh, well, we didn't actually print it out, so let's go ahead and print it out, so we'll do last

221
00:18:13,470 --> 00:18:21,390
last and it's going to be three and we'll do it in line.

222
00:18:23,220 --> 00:18:25,800
OK, so I say that I come highlights.

223
00:18:25,800 --> 00:18:26,440
I run it.

224
00:18:26,460 --> 00:18:27,440
Let's do this again.

225
00:18:27,480 --> 00:18:32,700
2.5, three point five B OK, so and there we go.

226
00:18:32,700 --> 00:18:34,240
We see the five now.

227
00:18:34,470 --> 00:18:35,790
So same thing.

228
00:18:37,300 --> 00:18:41,360
The integer was seems the to the float was seen as eight point five.

229
00:18:41,380 --> 00:18:42,580
I didn't put 0.7 seven.

230
00:18:42,580 --> 00:18:44,170
I guess it was supposed to be 0.7.

231
00:18:44,200 --> 00:18:44,650
I forgot.

232
00:18:45,680 --> 00:18:53,090
So there's point five and then that this was the next thing that it read in was a char, then the next

233
00:18:53,090 --> 00:18:58,820
char that it read in for the second char was this dot, and then this last integer that was I three

234
00:18:59,090 --> 00:19:01,940
will actually read this in and printed that out.

235
00:19:01,940 --> 00:19:04,730
And we have this left over on the keyboard buffer.

236
00:19:07,240 --> 00:19:15,160
OK, so hopefully that was like enough examples for you to understand this.

237
00:19:15,490 --> 00:19:20,290
I kind of was about to finish and I wanted to do this last couple of years.

238
00:19:20,290 --> 00:19:26,350
So thinking that maybe this example wasn't a specific one, we've gone over, so maybe it would help

239
00:19:26,350 --> 00:19:28,150
you understand it even better.

240
00:19:28,780 --> 00:19:29,320
So.

241
00:19:31,070 --> 00:19:34,970
Yeah, just be aware of what's being read into what data type.

242
00:19:35,270 --> 00:19:35,690
Right?

243
00:19:36,830 --> 00:19:41,330
And this stuff, if you if you can remember it, you know that would be good.

244
00:19:41,840 --> 00:19:43,070
We can always use it.

245
00:19:43,400 --> 00:19:49,550
What we're going to be doing is we're going to notice that we're going to need to use it in the near

246
00:19:49,550 --> 00:19:50,210
future.

247
00:19:50,570 --> 00:19:56,990
When we look at a another type of getting input with something called get line, which gets an entire

248
00:19:56,990 --> 00:19:59,780
line all at once rather than separate.

249
00:19:59,960 --> 00:20:03,680
I know this was all in the same line, so it kind of gets a whole line all at once.

250
00:20:03,680 --> 00:20:09,410
But the fact is is that we had to we had to use multiple of these operators, right?

251
00:20:09,410 --> 00:20:16,760
And we were separately reading into different variables, whereas you can actually read an entire line

252
00:20:16,760 --> 00:20:23,240
into like a string and stuff like that with scene and also this thing called get line.

253
00:20:23,960 --> 00:20:25,940
So that's what we're going to learn in the near future.

254
00:20:25,940 --> 00:20:30,710
And we're going to notice that if we're using a combination of seeing and get line, it's actually useful

255
00:20:30,710 --> 00:20:38,540
to know these things, the ignore and the clear and stuff like that, and also really get to know to

256
00:20:38,540 --> 00:20:43,320
be able to check for a fail as well because you can do other stuff when it fails like you.

257
00:20:43,460 --> 00:20:46,790
You know, here we printed a message out like, oops and failed.

258
00:20:49,550 --> 00:20:54,230
So it's just good to know to know this, and we will kind of elaborate on this in the future.

259
00:20:54,290 --> 00:20:58,860
Like I was saying, so if this is too confusing, you know, don't worry too much.

260
00:20:58,880 --> 00:21:02,260
We're going to be using them in some next lectures and stuff.

261
00:21:02,270 --> 00:21:08,690
But main important thing that I want to you take away at this point is the fact that, you know, the

262
00:21:08,690 --> 00:21:19,520
type of the variable that you're trying to read into really is very dependent on the type of input that's

263
00:21:19,520 --> 00:21:20,210
being entered.

264
00:21:20,220 --> 00:21:22,370
Like you notice here when we entered a float.

265
00:21:23,250 --> 00:21:27,620
Notice what it did, it just only captured the two as an integer.

266
00:21:28,700 --> 00:21:34,610
And then for the float, it just read the next thing and the keyword buffer when we might have thought

267
00:21:34,610 --> 00:21:38,360
that it would have just looked at this whole thing and been like, Oh, an integer, it'll just say

268
00:21:38,360 --> 00:21:38,900
two, maybe.

269
00:21:38,900 --> 00:21:40,250
But then the flow will be this.

270
00:21:40,280 --> 00:21:40,940
No, no, no.

271
00:21:41,970 --> 00:21:44,940
This is what's next on the keyboard buffer, that's why it showed up here.

272
00:21:45,120 --> 00:21:51,420
So understanding what the keyboard buffer is, understanding how the data types have to the data types

273
00:21:51,420 --> 00:21:56,760
here and the variables have to do with the data types you're entering on the keyboard, the characters,

274
00:21:56,760 --> 00:21:58,800
how those are interpreted as a data type.

275
00:21:59,550 --> 00:22:02,910
So just keep that in mind, that's the main takeaway.

276
00:22:03,300 --> 00:22:03,600
All right.

277
00:22:03,600 --> 00:22:04,680
So I think that's enough.

278
00:22:05,460 --> 00:22:10,740
So with that, I will see you in the next lecture when we kind of build upon this knowledge with some

279
00:22:10,740 --> 00:22:12,180
other types of input stuff.