1
00:00:00,000 --> 00:00:00,285

2
00:00:00,285 --> 00:00:03,030
>> דוד י מלאן: נתחיל בכתיבה
כמה תנאים מורכבים יותר.

3
00:00:03,030 --> 00:00:06,530
בפרט, בואו נכתוב תכנית
שמבקש מהמשתמש מספר שלם,

4
00:00:06,530 --> 00:00:09,460
אומר, בין 1 ל 10, ולאחר מכן
עושה קצת ניתוח.

5
00:00:09,460 --> 00:00:14,530
אבל דיווח זה זמן אם כי
המספר קטן או בינוני או גדול ב

6
00:00:14,530 --> 00:00:17,480
גודל, ציור הבחנות אלה
די באופן שרירותי.

7
00:00:17,480 --> 00:00:21,040
>> כדי לעשות זאת, אני הולך להסתמך על גט
int, פונקציה שמCS50

8
00:00:21,040 --> 00:00:22,860
ספרייה שעושה בדיוק את זה.

9
00:00:22,860 --> 00:00:24,350
ואני גם הולך ל
f הדפסת מינוף.

10
00:00:24,350 --> 00:00:28,530
אז אני הולך להתחיל
על ידי כולל cs50.h כמו

11
00:00:28,530 --> 00:00:31,880
גם io.h. סטנדרטי כמו

12
00:00:31,880 --> 00:00:36,460
>> והולך ואז להכריז עיקרי ב
דרך מקובלת, void main int, מתולתל פתוחה

13
00:00:36,460 --> 00:00:38,440
סד, סד מתולתל קרוב.

14
00:00:38,440 --> 00:00:41,240
ואז אני הולך לאנחה
המשתמש למספר שלם.

15
00:00:41,240 --> 00:00:48,340
f הדפסה, אנא תני לי
int בין 1 ל 10.

16
00:00:48,340 --> 00:00:52,640
>> עכשיו בואו לקבל int שעל ידי הכרזה
משתנים בשם, נניח, n והקצאה

17
00:00:52,640 --> 00:00:55,520
זה ערך ההחזרה של int גט.

18
00:00:55,520 --> 00:00:57,300
עכשיו בואו נעשה קצת ניתוח.

19
00:00:57,300 --> 00:01:04,500
>> אם n הוא גדול או שווה ל -0 ו
n הוא קטן או שווה, נניח, 3,

20
00:01:04,500 --> 00:01:12,560
אז אנחנו הולכים קדימה והדפסה
אותך לקח int קטן.

21
00:01:12,560 --> 00:01:15,730
>> אחר, אם המשתמש בוחר, למשל,
ערך בגודל בינוני, בוא

22
00:01:15,730 --> 00:01:16,960
לבדוק שכדלקמן.

23
00:01:16,960 --> 00:01:23,360
אחר אם n הוא גדול או שווה ל,
נניח, 4 ו n ​​הוא פחות או שווה ל,

24
00:01:23,360 --> 00:01:31,850
נניח, 7, ולאחר מכן אני הולך להדפיס
אותך לקח int בינוני.

25
00:01:31,850 --> 00:01:36,490
>> לבסוף, אני הולך להניח שאם
הערך הוא בין 8 ל 10, הם

26
00:01:36,490 --> 00:01:37,550
הרים int גדול.

27
00:01:37,550 --> 00:01:44,140
אז כדי להביע את זה, אני הקלדה, אחר אם
n הוא גדול או שווה ל -8 וn

28
00:01:44,140 --> 00:01:53,590
הוא פחות או שווה ל10, קדימה
ולהדפיס לך הרים int גדול.

29
00:01:53,590 --> 00:01:55,720
>> אחר, יש תנאי רביעי כאן.

30
00:01:55,720 --> 00:01:59,520
אם המשתמש לא שיתף פעולה, ובמקום
הקלדת ערך זה פחות מ

31
00:01:59,520 --> 00:02:04,430
0 או גדול מ 10, אני רוצה
פשוט כדי לנזוף בם.

32
00:02:04,430 --> 00:02:12,490
אחר להדפיס, בחרת
int לא חוקי.

33
00:02:12,490 --> 00:02:13,950
>> בואו לשמור את הקובץ.

34
00:02:13,950 --> 00:02:17,580
לקמפל אותו עם האיפור שאינו בורר.

35
00:02:17,580 --> 00:02:21,650
חזרה בשורה שלי, אני הולך לרוץ
אותו עם נקודת סלאש שאינו בורר.

36
00:02:21,650 --> 00:02:23,320
ובואו ננסה כמה ערכים.

37
00:02:23,320 --> 00:02:26,110
>> ראשית, בואו נהיה לא משתף פעולה
והקלד ב1 שלילי.

38
00:02:26,110 --> 00:02:30,970
למרבה המזל, שזוהה על ידי
סניף סופי במצב כזה.

39
00:02:30,970 --> 00:02:36,530
בואו ננסה שוב עם לוכסן נקודה
אינו בורר, הפעם זה נותן 1.

40
00:02:36,530 --> 00:02:37,900
אני אכן הרמתי int קטן.

41
00:02:37,900 --> 00:02:43,250
>> בואו נעשה את זה שוב עם לוכסן נקודה
אינו בורר, הפעם לקטוף, נניח, 5.

42
00:02:43,250 --> 00:02:44,590
וזה int בינוני.

43
00:02:44,590 --> 00:02:48,200
בואו עכשיו אין שוב מנקדים
סלאש שאינו בורר.

44
00:02:48,200 --> 00:02:52,650
ולתת לו ערך של 10, אשר
אכן int גדול.

45
00:02:52,650 --> 00:02:55,310
>> עכשיו זה ראוי לציין כי תכנית זו
היה יכול להיות מיושם ב

46
00:02:55,310 --> 00:02:56,840
כל מספר הדרכים.

47
00:02:56,840 --> 00:03:00,160
קודם כל, זה היה לגמרי
שרירותי שציירתי את הקווים שאני

48
00:03:00,160 --> 00:03:03,290
עשה בין קטן, בינוני,
וints הגדול.

49
00:03:03,290 --> 00:03:05,230
היינו יכולים להסיק אותם
גבולות בכל מקום.

50
00:03:05,230 --> 00:03:08,930
>> אבל יותר מעניין, לא היו לי
להביע בכל אלה בעצמי

51
00:03:08,930 --> 00:03:13,440
גדול או שווה ל או פחות
או שווה לסימנים.

52
00:03:13,440 --> 00:03:18,880
הייתי יכול, למשל, לכתוב מחדש אם
n הוא גדול או שווה ל 4 ו

53
00:03:18,880 --> 00:03:24,760
n הוא קטן או שווה ל -7, כמו במקום
אם n גדול מ 3 וn

54
00:03:24,760 --> 00:03:29,130
הוא פחות מ 8, ולאחר מכן להדפיס את
בחרת int בינוני.

55
00:03:29,130 --> 00:03:33,360
>> אחרי הכל, אם הקלט של המשתמש, על ידי
טבעו של int גט, הוא מספר שלם, אנחנו

56
00:03:33,360 --> 00:03:37,580
יכול גם בדיקה אם הערך שהוא גדול
מ 3 או גדול או

57
00:03:37,580 --> 00:03:38,740
שווה ל 4.

58
00:03:38,740 --> 00:03:43,130
ואנחנו גם יכולים לבדוק אם זה
ערך פחות מ 8 או פחות

59
00:03:43,130 --> 00:03:44,590
או שווה ל 7.

60
00:03:44,590 --> 00:03:45,860