1
00:00:00,000 --> 00:00:00,493

2
00:00:00,493 --> 00:00:09,860
>> [השמעת מוסיקה]

3
00:00:09,860 --> 00:00:13,520
>> ZAMYLA צ'אן: היית מעדיף לקבל
10 מיליון דולרים עכשיו או לקבל

4
00:00:13,520 --> 00:00:17,460
פרוטות בכל יום בחודש, שבי
בכל יום שלאחר מכן, אתה מקבל

5
00:00:17,460 --> 00:00:21,280
להכפיל את כמות פרוטותיך
קיבל ביום שלפני?

6
00:00:21,280 --> 00:00:24,010
בפרוטות, אנחנו הולכים
להוכיח למה אתה צריך

7
00:00:24,010 --> 00:00:27,000
בהחלט לקחת את הפרוטות.

8
00:00:27,000 --> 00:00:29,130
התפקיד שלך הוא לכתוב pennies.c--

9
00:00:29,130 --> 00:00:33,330
תכנית ששואלת את המשתמש ראשון איך
יש ימים רבים בחודש ו

10
00:00:33,330 --> 00:00:38,780
ואז שואל כמה פרוטות המשתמש
יקבל ביום הראשון.

11
00:00:38,780 --> 00:00:41,780
התכנית צריכה אז לחשב את
סכום שהמשתמש יצטרך

12
00:00:41,780 --> 00:00:46,530
שנצבר בסוף
חודש ולהציג אותו.

13
00:00:46,530 --> 00:00:49,670
>> אנחנו יכולים לשבור את התכנית הזו
לכמה משימות.

14
00:00:49,670 --> 00:00:52,830
אנחנו נצטרך לבקש
תשומות משתמשים מרובות -

15
00:00:52,830 --> 00:00:55,510
ימים וחודשים, ופרוטות
ביום הראשון.

16
00:00:55,510 --> 00:00:59,390
אנחנו צריכים לעקוב אחר כמה כסף
יש למשתמש ולעדכן אותו בכל

17
00:00:59,390 --> 00:01:03,060
יום, מכפיל את כמות
פרוטות שהם מקבלים.

18
00:01:03,060 --> 00:01:06,710
ולבסוף, אנו להדפיסם
סך סופי, בדולרים.

19
00:01:06,710 --> 00:01:08,570
>> בואו להתמודד עם קלט המשתמש ראשון.

20
00:01:08,570 --> 00:01:11,560
אני הולך לפתוח את apples.c,
תכנית קצרה העוסקת

21
00:01:11,560 --> 00:01:13,840
עם כניסות ויציאות.

22
00:01:13,840 --> 00:01:17,310
בחלק העליון כאן, צירפתי כמה
מהספריות שאני צריך -

23
00:01:17,310 --> 00:01:20,450
הספרייה של CS50 וסטנדרטי
I / O ספרייה.

24
00:01:20,450 --> 00:01:24,310
אני מדפיס באמצעות הפקודה
פונקצית printf מ

25
00:01:24,310 --> 00:01:25,660
ספריית קלט / פלט סטנדרטי.

26
00:01:25,660 --> 00:01:29,740
אבל הנחיה בפועל של המשתמש
קורה בשורה הבאה עם זה

27
00:01:29,740 --> 00:01:33,650
פונקצית GetInt בספריית CS50.

28
00:01:33,650 --> 00:01:38,300
>> GetInt מקבל קלט מהמשתמש ו
מבטיח שהקלט הוא מספר שלם.

29
00:01:38,300 --> 00:01:45,160
אז לאחסן הקלט של המשתמש למספר שלם
אני, להחסיר 1 מ-i, ולאחר מכן

30
00:01:45,160 --> 00:01:47,610
להדפיס את הערך החדש אם אני.

31
00:01:47,610 --> 00:01:53,050
לאחר הקומפילציה apples.c באמצעות
הפקודה "להפוך את התפוחים," יש לי

32
00:01:53,050 --> 00:01:55,770
תפוחי קובץ הפעלה.

33
00:01:55,770 --> 00:01:58,760
פועל ש, אני קלט 1.

34
00:01:58,760 --> 00:02:02,600
התכנית אומרת לי ש
יש לי 0 תפוחים שנותרו.

35
00:02:02,600 --> 00:02:05,480
וכך שעבד כמצופה.

36
00:02:05,480 --> 00:02:09,740
>> אז בואו נריץ את זה שוב
וקלט שלילי 1.

37
00:02:09,740 --> 00:02:13,950
עכשיו, שיש לו סכום שלילי של תפוחים
לא ממש הגיוני, אבל

38
00:02:13,950 --> 00:02:18,370
התכנית מקבלת אותה, משום שלילי
1, כן, זה הוא מספר שלם.

39
00:02:18,370 --> 00:02:22,740
ועכשיו את התכנית או את המפלצת
בתוך התכנית אוכלת שלילית

40
00:02:22,740 --> 00:02:26,250
תפוח, ועכשיו יש לי
2 תפוחים שליליים.

41
00:02:26,250 --> 00:02:28,610
הממ, אז זה שיעור אחד -

42
00:02:28,610 --> 00:02:32,965
למרות שהפונקציה וGetInt
פונקציות נלוות, כמו GetFlow או

43
00:02:32,965 --> 00:02:38,100
GetString לקבל את סוג הנתונים הנכון, אתה
יש לוודא כי הקלט עושה

44
00:02:38,100 --> 00:02:41,430
הגיוני עבור התכנית שלך.

45
00:02:41,430 --> 00:02:45,500
>> בפרוטות, זה לא יעשה בדיוק את הפקודה
למספר שלם, אתה צריך לעשות

46
00:02:45,500 --> 00:02:49,550
בטוח שתשומות המשתמש שלם
זה הגיוני בהתחשב בהקשר.

47
00:02:49,550 --> 00:02:55,690
חודש יכול להיות 28 בלבד,
29, 30, או 31 ימים.

48
00:02:55,690 --> 00:02:59,160
אנחנו רוצים לדרוש ברציפות
מספר שלם חוקי.

49
00:02:59,160 --> 00:03:03,240
אם הם מחוץ קלט מספר שלם שלנו
גבולות מקובלים, אנו ינחו אותם

50
00:03:03,240 --> 00:03:07,190
שוב ושוב, עד שאתה
לתת לנו מספר שלם חוקי.

51
00:03:07,190 --> 00:03:10,070
>> כזכור, "חזור עד"
לחסום בסריטות?

52
00:03:10,070 --> 00:03:13,070
אתה יכול לעשות את מבנה דומה
ב-C באמצעות לולאה ", ואילו"

53
00:03:13,070 --> 00:03:14,830
או "עשה ואילו" לולאה.

54
00:03:14,830 --> 00:03:18,280
יש את מבנה הלולאה ואילו מצבו
כי צריך להתקיים על

55
00:03:18,280 --> 00:03:20,160
גוף של לולאה לביצוע.

56
00:03:20,160 --> 00:03:23,080
>> זה אמור להיראות קצת דומה,
בגלל המצב הוא בדיוק כמו

57
00:03:23,080 --> 00:03:25,970
לוקי התחלה עם הזוויות
ונכנס לסוגריים

58
00:03:25,970 --> 00:03:27,950
של הלולאה ", ואילו".

59
00:03:27,950 --> 00:03:30,600
אז התנאי שיבדוק אם
השלם הוא בתוך

60
00:03:30,600 --> 00:03:32,680
הגבולות מקובלים.

61
00:03:32,680 --> 00:03:36,620
אתה יכול להנחות את GetInt באמצעות המספר השלם
ולאחר מכן לבצע "תוך" שלך

62
00:03:36,620 --> 00:03:41,030
לולאה, חוזר על הבקשה והדפסה
הוראות, ואילו קלט

63
00:03:41,030 --> 00:03:43,470
אינו חוקי.

64
00:03:43,470 --> 00:03:47,610
>> דרך נוספת להבטיח קלט משתמש נכון
הוא באמצעות "עשה ואילו" לולאה,

65
00:03:47,610 --> 00:03:50,400
אשר דומה מאוד ללולאה בזמן.

66
00:03:50,400 --> 00:03:54,950
"עשה ואילו" לולאה מבצעת את הקוד
בתוך אלה הגוף ולאחר מכן בודק

67
00:03:54,950 --> 00:03:57,150
אם התנאי מתקיים או לא.

68
00:03:57,150 --> 00:04:00,590
זה שימושי לקבלת קלט משתמש,
כי אתה יודע שאתה צריך

69
00:04:00,590 --> 00:04:02,980
כדי להנחות אותם לפחות פעם אחת.

70
00:04:02,980 --> 00:04:07,200
אם התנאי אינו מתקיים, התכנית
תבצע את הקו לאחר

71
00:04:07,200 --> 00:04:08,530
"עשה ואילו" הלולאה.

72
00:04:08,530 --> 00:04:13,230
אם התנאי שהוא נפגש,
הלולאה תחזור

73
00:04:13,230 --> 00:04:17,490
>> לולאה "עשה ואילו" לאימות משתמש
קלט נראה משהו כזה.

74
00:04:17,490 --> 00:04:24,530
אני מצהיר n משתנה, GetInt, ו
לאחר מכן חזור עד n הוא חוקי.

75
00:04:24,530 --> 00:04:28,040
והתהליך הזה, הסברתי, הייתי משתמש
הסוג שלם-נתונים, אשר

76
00:04:28,040 --> 00:04:29,820
תוכל להשתמש לימי החודש.

77
00:04:29,820 --> 00:04:33,560
אבל אנחנו יודעים שמספר פרוטות
יהיה להיערם במהירות, ולכן על מנת

78
00:04:33,560 --> 00:04:39,160
לאחסן מספרים גדולים יותר, השתמש בסוג הנתונים
LongLong, אך יש לזכור אותו

79
00:04:39,160 --> 00:04:42,590
עיקרון האימות חל.

80
00:04:42,590 --> 00:04:47,070
>> מדהים, אז ברגע שיש לנו שניים בתוקף
תשומות מהמשתמש -

81
00:04:47,070 --> 00:04:49,530
ימים בחודש ואת הפרוטות
ביום הראשון -

82
00:04:49,530 --> 00:04:52,870
אנחנו יכולים להעביר על גבי הבאים
חלק מהתכנית.

83
00:04:52,870 --> 00:04:56,680
ביום הראשון, המשתמש מתחיל עם
פרוטות אולם רבות הם המפורטים

84
00:04:56,680 --> 00:05:00,370
והסכום של פרוטות שהם
תקבל ביום שלמחרת הוא הוכפל.

85
00:05:00,370 --> 00:05:03,130
אז זה הגיוני כדי לעקוב אחר
משני סכומים אלה -

86
00:05:03,130 --> 00:05:08,890
כמה כסף יש לו את המשתמש ואיך
פרוטות רבות הם יהיו נתון.

87
00:05:08,890 --> 00:05:13,760
>> עכשיו, עושה משהו במשך 28 עד 31 ימים
הוא חוזר על עצמו, אז בואו נשתמש "עבור"

88
00:05:13,760 --> 00:05:18,220
לולאה כדי לעבור על פני הימים ב
חודש, עדכון כולל ואגורה

89
00:05:18,220 --> 00:05:21,010
תעמוד בכל פעם.

90
00:05:21,010 --> 00:05:23,550
"עבור" תחביר לולאה מכיל
הבא -

91
00:05:23,550 --> 00:05:27,510
אתחול, תנאי,
ועדכון.

92
00:05:27,510 --> 00:05:29,590
הלולאה "עבור" שלך תהיה לאתחל
משתנה, כאשר הוא

93
00:05:29,590 --> 00:05:31,380
הראשון נכנס ללולאה.

94
00:05:31,380 --> 00:05:34,860
אם התנאי מתקיים, הגוף
של הלולאה יבצע.

95
00:05:34,860 --> 00:05:36,860
לאחר מכן, יבצע את העדכון.

96
00:05:36,860 --> 00:05:40,900
אם התנאי עדיין מתקיים,
הלולאה תבצע ולעדכן, ו

97
00:05:40,900 --> 00:05:45,820
לחזור כל זמן שהמצב שלך,
מוערך נכון.

98
00:05:45,820 --> 00:05:51,080
>> הנה לולאה "עבור" שחלק
עמ '2 על ידי שלם בסך הכל 10 פעמים.

99
00:05:51,080 --> 00:05:55,380
שימו לב איך אני הכריז עמ 'השלם
מחוץ ללולאה "עבור" שלי, כך ש

100
00:05:55,380 --> 00:05:59,850
מספר שלם יכול להיות נגיש
מחוץ ללולאה "עבור".

101
00:05:59,850 --> 00:06:03,620
אחרי החודש עבר, זה זמן
כדי לספר את המשתמש כמה כסף

102
00:06:03,620 --> 00:06:04,790
הם קיבל.

103
00:06:04,790 --> 00:06:08,740
למפרט, אתה צריך לספר את המשתמש
כמה דולרים, לא כמה

104
00:06:08,740 --> 00:06:10,780
פרוטות, יש להם.

105
00:06:10,780 --> 00:06:14,620
אבל עד כה, שעקבת אחר
סך הכל ואת פרוטות באמצעות LongLongs,

106
00:06:14,620 --> 00:06:16,640
שהם מספרים שלמים.

107
00:06:16,640 --> 00:06:20,560
>> ישנם 100 פרוטות ל 1 $, אז אלא אם כן
מספר פרוטות הוא

108
00:06:20,560 --> 00:06:24,860
מכפיל של 100, תצטרך
מייצגים מקומות אחרי נקודה עשרונית.

109
00:06:24,860 --> 00:06:28,060
Autotype הוכפל מאפשר
לך לעשות את זה.

110
00:06:28,060 --> 00:06:32,790
אז איך להמיר מהייצוג
פרוטות לדולרים?

111
00:06:32,790 --> 00:06:35,330
>> בואו נסתכל pi.c.

112
00:06:35,330 --> 00:06:41,690
תכנית זו לוקחת big_pi וLongLong
חלק על ידי 100,000, ומדפיס

113
00:06:41,690 --> 00:06:44,270
את התוצאה לחמישה מקומות אחרי נקודה עשרונית.

114
00:06:44,270 --> 00:06:48,560
אם אנחנו רוצים להציג ארבע עשרוניות
מקומות, אז אנחנו יכולים פשוט להחליף את זה

115
00:06:48,560 --> 00:06:49,760
מספר כאן.

116
00:06:49,760 --> 00:06:58,370
אז בואו נחסוך, לקמפל PI, ו
לאחר מכן רואה את התוצאה, שאנו

117
00:06:58,370 --> 00:07:02,240
מצפה להיות 3.1415 -

118
00:07:02,240 --> 00:07:04,540
חמש הספרות הראשונות של פיי.

119
00:07:04,540 --> 00:07:06,300
>> זה לא כאילו.

120
00:07:06,300 --> 00:07:07,390
ולמה?

121
00:07:07,390 --> 00:07:11,920
ובכן, כי big_pi הוא LongLong,
שהוא מספר שלם, שלא

122
00:07:11,920 --> 00:07:13,740
לעקוב אחר שברים עשרוניים.

123
00:07:13,740 --> 00:07:16,850
השינוי שאני צריך
לעשות הוא בליגה.

124
00:07:16,850 --> 00:07:23,300
אני צריך להטיל לכאן לפני כפול
החלוקה, משום שזוגות לא יכולים לשמור

125
00:07:23,300 --> 00:07:25,260
אחר מקומות אחרי נקודה עשרונית.

126
00:07:25,260 --> 00:07:28,080
ואני הולך להוסיף שורה חדשה
כאן לעיצוב טוב יותר.

127
00:07:28,080 --> 00:07:33,090

128
00:07:33,090 --> 00:07:34,230
>> וכאן יש לנו את זה -

129
00:07:34,230 --> 00:07:37,660
3.1416.

130
00:07:37,660 --> 00:07:43,520
ייתכן שתבחין שהוא מדפיס 3.1416
במקום 3.1415 כצפוי.

131
00:07:43,520 --> 00:07:47,550
זה בגלל שזה במהלך סיבובים
תהליך החלוקה, בניגוד לרק

132
00:07:47,550 --> 00:07:50,490
מקצץ את הערך.

133
00:07:50,490 --> 00:07:53,710
עכשיו אתה צריך להיות מסוגל להדפיס
סך סופי בצורה נכונה, שמסיים את

134
00:07:53,710 --> 00:07:54,870
את התכנית.

135
00:07:54,870 --> 00:07:55,930
>> מזל טוב.

136
00:07:55,930 --> 00:07:57,340
השם שלי הוא Zamyla.

137
00:07:57,340 --> 00:07:58,720
וזה היה פרוטות.

138
00:07:58,720 --> 00:08:05,589
>> [השמעת מוסיקה]