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

2
00:00:00,330 --> 00:00:03,230
>> דובר: בואו ליישם תכנית ה
מבקש מהמשתמש מספר שלם

3
00:00:03,230 --> 00:00:05,850
אבל ממשיך שגרם להם
עבור מספר שלם נוסף עד

4
00:00:05,850 --> 00:00:07,590
המספר השלם שהוא חיובי.

5
00:00:07,590 --> 00:00:16,760
ובכן, בואו לכתוב את זה, כולל cs50.h,
כולל שעות נקודת io סטנדרטי, int

6
00:00:16,760 --> 00:00:18,010
[חלל] ראשי.

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

8
00:00:20,000 --> 00:00:23,200
עכשיו בואו למעשה נתחיל להנחות את
משתמש עבור מספר שלם זה תוך כדי שמירה על

9
00:00:23,200 --> 00:00:25,570
אכפת שאנחנו רוצים reprompt
אותם עד ש

10
00:00:25,570 --> 00:00:26,860
המספר הוא חיובי דווקא.

11
00:00:26,860 --> 00:00:30,160
>> אז אני רוצה סוג כלשהו של לולאות
לבנות, אבל לולאה שמבצעת ב

12
00:00:30,160 --> 00:00:31,200
לפחות פעם אחת.

13
00:00:31,200 --> 00:00:34,810
ולהיזכר עשה תוך הלולאה מאפשרת
לנו לעשות בדיוק את זה.

14
00:00:34,810 --> 00:00:36,140
בואו לקודד את זה.

15
00:00:36,140 --> 00:00:39,210
>> בואו נכריז int הראשון - אנחנו
קורא לזה n - שבו לאחסון

16
00:00:39,210 --> 00:00:41,030
המספר השלם של המשתמש.

17
00:00:41,030 --> 00:00:44,250
עכשיו בואו נעשה את הדברים הבאים.

18
00:00:44,250 --> 00:00:51,292
Printf, אנא תן לי int חיובי.

19
00:00:51,292 --> 00:00:54,470
בואו עכשיו לקבל את זה int באמצעות
GetInt של ספריית CS50

20
00:00:54,470 --> 00:00:59,110
פונקציה, n מקבל GetInt.

21
00:00:59,110 --> 00:01:02,610
ועכשיו שנסיים לעשות משהו,
אבל אנחנו הולכים לרוצים לעשות את זה

22
00:01:02,610 --> 00:01:04,580
ואילו n הוא -

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

24
00:01:05,480 --> 00:01:09,370
פחות מ 1, אם אכן
רוצה מספר שלם חיובי.

25
00:01:09,370 --> 00:01:11,670
>> בואו נלך קדימה עכשיו ולהדפיס.

26
00:01:11,670 --> 00:01:17,590
אם הכל טוב, תודה
עבור int החיובי,

27
00:01:17,590 --> 00:01:19,360
פסיק, שמור את הקובץ.

28
00:01:19,360 --> 00:01:21,480
בואו עכשיו לקמפל ולהריץ.

29
00:01:21,480 --> 00:01:25,550
>> הפוך לוכסן נקודה חיובי חיובי.

30
00:01:25,550 --> 00:01:27,470
ועכשיו אני שאתבקש
עבור int חיובי.

31
00:01:27,470 --> 00:01:29,630
הרשה לי לשתף פעולה עם 1.

32
00:01:29,630 --> 00:01:31,330
תודה על int החיובי.

33
00:01:31,330 --> 00:01:33,650
>> בואו עכשיו להפעיל מחדש את התכנית
ולא תשתף פעולה.

34
00:01:33,650 --> 00:01:35,260
תן לי בבקשה int חיובי.

35
00:01:35,260 --> 00:01:37,300
מה דעתך על 1 שלילי?

36
00:01:37,300 --> 00:01:37,910
מעניין.

37
00:01:37,910 --> 00:01:40,460
התכנית כבר reprompted
שלי עבור int.

38
00:01:40,460 --> 00:01:43,170
>> בואו נהיה קצת יותר
קשה עם 0.

39
00:01:43,170 --> 00:01:46,310
עדיין לא int חיובי, אז בוא
לשתף פעולה והפעם

40
00:01:46,310 --> 00:01:48,280
לספק, שוב, 1.

41
00:01:48,280 --> 00:01:49,990
תודה על int החיובי.

42
00:01:49,990 --> 00:01:54,300
>> עכשיו זה חשוב לציין שאני
הכריז n משתנה על קו 6,

43
00:01:54,300 --> 00:01:56,510
מחוץ לעשה תוך הלולאה.

44
00:01:56,510 --> 00:02:01,030
אם הייתי במקום שהוכרז n הפנימי שלי
עשה תוך לולאה, במיוחד על, נניח,

45
00:02:01,030 --> 00:02:06,230
קו 10, שבו אני גם מקבל int מ
למשתמש, כי n int היה רק

46
00:02:06,230 --> 00:02:09,904
קיימים בתחומי המתולתל
פלטה שנמצאות בשלב זה

47
00:02:09,904 --> 00:02:12,320
קו 8 ועל קו 11.

48
00:02:12,320 --> 00:02:16,570
>> במילים אחרות, n יהיה scoped ל
בתוך שעשתה תוך לולאה.

49
00:02:16,570 --> 00:02:20,390
אבל הבעיה היא שאנחנו גם
רוצה להשתמש n בקו 12

50
00:02:20,390 --> 00:02:21,900
בתוך המצב.

51
00:02:21,900 --> 00:02:26,120
אז למרות שזה לא נראה כך
די, זה הרבה יותר מכוון מאוד כי

52
00:02:26,120 --> 00:02:28,210
n מוכרז מחוץ
עשה תוך לולאה זו.

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