1
00:00:00,000 --> 00:00:00,440

2
00:00:00,440 --> 00:00:03,440
>> SPEAKER 1: בפעם האחרונה שנתחנו
מספרים שלמים, זוכרים שהיינו קצת

3
00:00:03,440 --> 00:00:07,810
ביטויים בוליאנית כדי לבדוק אם של משתמש
קלט n היה בין מספרים

4
00:00:07,810 --> 00:00:11,580
כמו 0 ו 3, 4 ו 7 ו -8 ו10.

5
00:00:11,580 --> 00:00:14,990
ובכן, עשינו זאת באמצעות אם של ואחר
אם, אבל מתברר שאתה יכול

6
00:00:14,990 --> 00:00:17,990
ליישם אותו ההיגיון באמצעות
מבנה תכנות שונה

7
00:00:17,990 --> 00:00:21,400
לגמרי תוך השגת
בדיוק את אותה התוצאה.

8
00:00:21,400 --> 00:00:25,000
למעשה, אנו יכולים להציג משהו
נקרא מתג המאפשר לנו

9
00:00:25,000 --> 00:00:28,660
לעבור את התנהגותנו בהתאם
הערך של כמה משתנה.

10
00:00:28,660 --> 00:00:29,840
>> בואו לתת את זה לנסות.

11
00:00:29,840 --> 00:00:35,730
כדי לעשות זאת, אני הולך ראשון לכלול
ספריית cs50 בדרך של cs50.h.

12
00:00:35,730 --> 00:00:39,960
אני גם הולך לכלול את התקן
ספרייה בדרך לסטנדרטים שלי / O.h.

13
00:00:39,960 --> 00:00:44,540
ואני הולך להכריז עיקרי ב
הדרך המקובלת, int חלל ראשי.

14
00:00:44,540 --> 00:00:45,650
פתח סד מתולתל.

15
00:00:45,650 --> 00:00:47,100
סגור סד מתולתל.

16
00:00:47,100 --> 00:00:49,720
ועכשיו אני הולך לשאול
משתמש למספר שלם.

17
00:00:49,720 --> 00:00:56,990
>> Printf, תן לי int
בין 1 ל 10.

18
00:00:56,990 --> 00:00:59,310
ועכשיו אני הולך לקבל
שint באמצעות cs50

19
00:00:59,310 --> 00:01:01,590
ספריות לתפקד, GetInt.

20
00:01:01,590 --> 00:01:06,140
Int, בואו נקראים לזה n, שווה GetInt.

21
00:01:06,140 --> 00:01:08,500
ועכשיו אני הולך לעשות קצת
מניתוח על המספר שלם.

22
00:01:08,500 --> 00:01:13,120
במידה מסוימת באופן שרירותי, אבל עם זה
מבנה חדש המכונה מתג.

23
00:01:13,120 --> 00:01:16,530
הפעל את הערך של n באופן הבא.

24
00:01:16,530 --> 00:01:23,240
>> במקרה שn שווה 1, או ב
מקרה זה n שווה 2, או במקרה

25
00:01:23,240 --> 00:01:28,150
n ששווה 3, קדימה
ביצוע הקו הזה של קוד.

26
00:01:28,150 --> 00:01:34,480
Printf שבחרת int, הפסקה קטנה.

27
00:01:34,480 --> 00:01:37,610
עכשיו, אני צריך ליישם את המקבילה
של ELT פשוט על ידי

28
00:01:37,610 --> 00:01:40,990
ספירת כמה מקרים נוספים.

29
00:01:40,990 --> 00:01:47,180
>> במקרה שn שווה 4, או ב
מקרה זה n שווה 5, או במקרה

30
00:01:47,180 --> 00:01:53,830
n ששווה 6, או במקרה שn
שווה 7, אתם מוזמנים להדפיס אותך

31
00:01:53,830 --> 00:01:58,000
הרים Int בינוני.

32
00:01:58,000 --> 00:01:59,490
לשבור.

33
00:01:59,490 --> 00:02:02,300
עכשיו במקרה שהמשתמש לקח
מספר גדול, בוא

34
00:02:02,300 --> 00:02:04,940
לזהות שכדלקמן.

35
00:02:04,940 --> 00:02:08,900
>> במקרה שהמשתמש לקח שמונה
או במקרה שהמשתמש בוחר

36
00:02:08,900 --> 00:02:14,110
תשע, או במקרה שהמשתמש בוחר
10, קדימה ולהדפיס אותך

37
00:02:14,110 --> 00:02:17,830
הרים Int גדול.

38
00:02:17,830 --> 00:02:19,180
לשבור.

39
00:02:19,180 --> 00:02:23,970
ELT, אם משתמש לא בחר מספר
שנופל לתוך כל 10 מקרים אלה,

40
00:02:23,970 --> 00:02:25,520
בואו לקבל קצת התנהגות ברירת מחדל.

41
00:02:25,520 --> 00:02:27,870
אשר במקרה זה יהיה כדלקמן.

42
00:02:27,870 --> 00:02:32,860
>> ברירת מחדל, printf, שבחרת
Int לא חוקי.

43
00:02:32,860 --> 00:02:36,100

44
00:02:36,100 --> 00:02:38,220
לשבור.

45
00:02:38,220 --> 00:02:42,870
עכשיו, אם אני שומר לקמפל קובץ זה
זה עם להפוך את המתג.

46
00:02:42,870 --> 00:02:44,870
להפעיל אותו עם. מתג נטוי.

47
00:02:44,870 --> 00:02:46,770
בואו נעשה כמה בדיקות שפיות.

48
00:02:46,770 --> 00:02:48,440
אני אאסוף Int של 1.

49
00:02:48,440 --> 00:02:50,110
ומזהה הרים int קטן.

50
00:02:50,110 --> 00:02:52,240
>> בואו עכשיו לעשות. לקצץ מתג.

51
00:02:52,240 --> 00:02:54,514
והקלד בתניח, 1 שלילי.

52
00:02:54,514 --> 00:02:56,900
ומזהה הרים int לא חוקי.

53
00:02:56,900 --> 00:02:59,560
בסופו של היום, הבורר
לבנות לא מאפשר לך לעשות

54
00:02:59,560 --> 00:03:03,320
כל דבר שאתה לא יכול לעשות כבר
עם מוכר יותר, אם, אם אחר,

55
00:03:03,320 --> 00:03:04,530
אחר לבנות.

56
00:03:04,530 --> 00:03:07,470
אבל אם יש לך רשימה סופית של ערכים
כי אתה בודק ל,

57
00:03:07,470 --> 00:03:09,820
הצהרה הבורר מאוד ייתכן
גם להפוך את הקוד שלך יותר

58
00:03:09,820 --> 00:03:11,310
מפורש, או קריא יותר.

59
00:03:11,310 --> 00:03:12,910