1
00:00:00,000 --> 00:00:00,330

2
00:00:00,330 --> 00:00:03,230
>> SPRECHER: Wir implementieren ein Programm, das
fordert den Benutzer für eine ganze Zahl

3
00:00:03,230 --> 00:00:05,850
aber weiterhin veranlasst sie
für eine andere ganze Zahl bis

4
00:00:05,850 --> 00:00:07,590
dass ganze Zahl ist positiv.

5
00:00:07,590 --> 00:00:16,760
Nun, lassen Sie uns dies schreibe, sind cs50.h,
gehören Standard-io Punkt h, int

6
00:00:16,760 --> 00:00:18,010
Haupt [nichtig].

7
00:00:18,010 --> 00:00:20,000

8
00:00:20,000 --> 00:00:23,200
Lassen Sie uns jetzt tatsächlich beginnen zu veran die
Benutzer für diese ganze Zahl während in

9
00:00:23,200 --> 00:00:25,570
daran, dass wir Erneut auffordern wollen
, bis dass

10
00:00:25,570 --> 00:00:26,860
Anzahl ist eigentlich positiv.

11
00:00:26,860 --> 00:00:30,160
>> Also werde ich eine Art Looping wollen
Konstrukt, sondern eine Schleife ausführt, die auf

12
00:00:30,160 --> 00:00:31,200
mindestens einmal.

13
00:00:31,200 --> 00:00:34,810
Und erinnern an die do-while-Schleife können
uns, genau das zu tun.

14
00:00:34,810 --> 00:00:36,140
Lassen Sie uns diese bis zu codieren.

15
00:00:36,140 --> 00:00:39,210
>> Lassen Sie uns zuerst einen int erklären - wir werden
nennen es n - in dem zum Speichern der

16
00:00:39,210 --> 00:00:41,030
ganzzahligen Benutzers.

17
00:00:41,030 --> 00:00:44,250
Lassen Sie uns jetzt die folgenden.

18
00:00:44,250 --> 00:00:51,292
Printf, bitte geben Sie mir eine positive int.

19
00:00:51,292 --> 00:00:54,470
Lassen Sie uns nun mit bekommen, dass int
der CS50 Bibliothek GetInt

20
00:00:54,470 --> 00:00:59,110
Funktion, n bekommt GetInt.

21
00:00:59,110 --> 00:01:02,610
Und jetzt sind wir fertig, etwas zu tun,
aber wir werden dies tun zu wollen

22
00:01:02,610 --> 00:01:04,580
während n -

23
00:01:04,580 --> 00:01:05,480
was? -

24
00:01:05,480 --> 00:01:09,370
weniger als 1, wenn wir in der Tat
wollen eine positive ganze Zahl.

25
00:01:09,370 --> 00:01:11,670
>> Lassen Sie uns jetzt voran gehen und ausdrucken.

26
00:01:11,670 --> 00:01:17,590
Wenn alles gut geht, danke
für die positive int,

27
00:01:17,590 --> 00:01:19,360
Semikolon, speichern Sie die Datei.

28
00:01:19,360 --> 00:01:21,480
Lassen Sie uns jetzt kompilieren und ausführen.

29
00:01:21,480 --> 00:01:25,550
>> Machen Sie positive Punktstrich positiv.

30
00:01:25,550 --> 00:01:27,470
Und jetzt bin ich aufgefordert wird
für eine positive int.

31
00:01:27,470 --> 00:01:29,630
Lassen Sie mich mit ein kooperieren.

32
00:01:29,630 --> 00:01:31,330
Vielen Dank für das positive int.

33
00:01:31,330 --> 00:01:33,650
>> Lassen Sie uns nun dieses Programm erneut
und nicht zu kooperieren.

34
00:01:33,650 --> 00:01:35,260
Bitte geben Sie mir eine positive int.

35
00:01:35,260 --> 00:01:37,300
Wie wäre es mit minus 1?

36
00:01:37,300 --> 00:01:37,910
Interessante.

37
00:01:37,910 --> 00:01:40,460
Das Programm ist bereits reprompted
mich für eine int.

38
00:01:40,460 --> 00:01:43,170
>> Seien wir etwas mehr
schwer mit 0.

39
00:01:43,170 --> 00:01:46,310
Immer noch nicht positive int, also lassen
zusammenarbeiten und dieses Mal

40
00:01:46,310 --> 00:01:48,280
stellen wiederum 1.

41
00:01:48,280 --> 00:01:49,990
Vielen Dank für das positive int.

42
00:01:49,990 --> 00:01:54,300
>> Jetzt ist es wichtig zu beachten, dass ich
erklärte meine Variable n auf der Linie 6,

43
00:01:54,300 --> 00:01:56,510
außerhalb der do-while-Schleife.

44
00:01:56,510 --> 00:02:01,030
Hätte ich stattdessen erklärt n Innenseite meiner
do-while-Schleife, die speziell auf, sagen wir,

45
00:02:01,030 --> 00:02:06,230
Zeile 10, wo ich auch die von int
der Benutzer, dass int n haben nur

46
00:02:06,230 --> 00:02:09,904
innerhalb der Grenzen der geschweiften bestanden
Klammern, die sich gerade befinden

47
00:02:09,904 --> 00:02:12,320
Linie 8 und auf der Linie 11.

48
00:02:12,320 --> 00:02:16,570
>> Mit anderen Worten, n zu eingeschränkt werden
das Innere dieser do-while-Schleife.

49
00:02:16,570 --> 00:02:20,390
Aber das Problem ist, dass wir auch
will n in Zeile 12 zu verwenden

50
00:02:20,390 --> 00:02:21,900
innerhalb der Bedingung.

51
00:02:21,900 --> 00:02:26,120
Also auch wenn es nicht so aussieht, so
recht, es ist sehr viel, dass bewusste

52
00:02:26,120 --> 00:02:28,210
n außerhalb erklärt
diese do-while-Schleife.

53
00:02:28,210 --> 00:02:29,838