1
00:00:00,000 --> 00:00:00,940

2
00:00:00,940 --> 00:00:05,440
>> [השמעת מוסיקה]

3
00:00:05,440 --> 00:00:11,577

4
00:00:11,577 --> 00:00:12,660
דוד י מלאן: בסדר.

5
00:00:12,660 --> 00:00:15,590
זה CS50, וזה
הוא ההתחלה של שבוע שני.

6
00:00:15,590 --> 00:00:19,120
אז הבה ותתחילו היום עם באג.

7
00:00:19,120 --> 00:00:20,974
באג, כמובן, הוא
טעות בתכנית,

8
00:00:20,974 --> 00:00:22,890
ותקבל מאוד
מכיר את המושג הזה

9
00:00:22,890 --> 00:00:26,050
אם אף פעם לא מתוכנתים
לפני. pset0 ועכשיו pset1.

10
00:00:26,050 --> 00:00:29,280
אבל בואו נשקול משהו
קטן ופשוט בהתחלה.

11
00:00:29,280 --> 00:00:32,189
תכנית זו כאן שאני
זרק יחד מראש,

12
00:00:32,189 --> 00:00:37,280
ואני טוען שזה צריך להדפיס
10 כוכבים על המסך באמצעות printf,

13
00:00:37,280 --> 00:00:41,020
אבל זה ככל הנראה מרכבה בדרך כלשהי.

14
00:00:41,020 --> 00:00:45,370
>> בהתחשב במפרט ש
זה צריך להדפיס 10 כוכבים,

15
00:00:45,370 --> 00:00:50,230
אבל זה לא כנראה, מה ש
היית טוען הוא באג?

16
00:00:50,230 --> 00:00:52,004
כן?

17
00:00:52,004 --> 00:00:54,420
אז זה את ידי שגיאה אחת,
ומה אתה מתכוון לעשות את זה?

18
00:00:54,420 --> 00:01:00,991

19
00:01:00,991 --> 00:01:01,490
אישור.

20
00:01:01,490 --> 00:01:09,820

21
00:01:09,820 --> 00:01:10,410
מצוין.

22
00:01:10,410 --> 00:01:13,930
אז יש לנו שצוינו
להתחיל ערך של אפס עבור i,

23
00:01:13,930 --> 00:01:18,399
ואנחנו כבר צוינו ערך n של 10,
אבל אנחנו כבר בשימוש פחות או שווה ל.

24
00:01:18,399 --> 00:01:21,190
והסיבה שזה שתי
תווים ולא רק סמל אחד,

25
00:01:21,190 --> 00:01:22,630
כמו בספר מתמטיקה,
הוא שאין לך

26
00:01:22,630 --> 00:01:24,880
דרך להביע
שווה ערך תו אחד.

27
00:01:24,880 --> 00:01:28,450
>> אז זה אומר פחות מ, אבל
אם אתה מתחיל לספור על אפס,

28
00:01:28,450 --> 00:01:31,690
אבל אתה סופר את כל הדרך
דרך ושווה ל10,

29
00:01:31,690 --> 00:01:34,170
אתה כמובן הולך
לספור 11 דברים בסך הכל.

30
00:01:34,170 --> 00:01:35,900
ואז אתה הולך להדפיס 11 כוכבים.

31
00:01:35,900 --> 00:01:37,990
אז מה יכול להיות לתקן את זה?

32
00:01:37,990 --> 00:01:39,970
כן?

33
00:01:39,970 --> 00:01:43,980
>> אז פשוט להתאים את פחות מ
או שווה רק כדי להיות פחות מ,

34
00:01:43,980 --> 00:01:46,250
ויש, אני טוען, אולי
פתרון אחר, גם.

35
00:01:46,250 --> 00:01:47,210
מה שאתה יכול לעשות דבר אחר?

36
00:01:47,210 --> 00:01:48,590
כן?

37
00:01:48,590 --> 00:01:53,660
>> אז תתחיל שווה את זה ל1, ו
להשאיר פחות או שווה ל.

38
00:01:53,660 --> 00:01:56,187
ולמען אמת אני טוען
כי, לאדם טיפוסי,

39
00:01:56,187 --> 00:01:57,770
זה כנראה יותר פשוט.

40
00:01:57,770 --> 00:02:00,280
מתחיל לספור ב1 ו
לספור דרך 10.

41
00:02:00,280 --> 00:02:01,690
בעיקרו של דבר לעשות את מה שאתה מתכוון.

42
00:02:01,690 --> 00:02:04,010
>> אבל המציאות היא ב
תכנות, כפי שראינו,

43
00:02:04,010 --> 00:02:07,598
מדעני מחשב ומתכנתים
בדרך כלל מתחיל לספור על אפס.

44
00:02:07,598 --> 00:02:09,389
וכך זה בסדר פעם אחת
אתה מתרגל לזה.

45
00:02:09,389 --> 00:02:12,640
המצב שלך, בדרך כלל, יהיה
משהו כמו פחות מ.

46
00:02:12,640 --> 00:02:14,910
אז פשוט הגיוני
שגיאה שאנחנו יכולים עכשיו

47
00:02:14,910 --> 00:02:17,990
לתקן וסופו של דבר להדר מחדש
זה ולקבל רק 10.

48
00:02:17,990 --> 00:02:19,610
>> ובכן מה דעתך על הבאג הזה כאן?

49
00:02:19,610 --> 00:02:24,200
כאן, שוב, אני טוען שיש לי
מטרה של הדפסת 10 stars--

50
00:02:24,200 --> 00:02:28,140
אחת בכל שורה הפעם, אבל זה לא.

51
00:02:28,140 --> 00:02:30,940
לפני שנציע את מה ש
התיקון הוא, מה עושה את זה

52
00:02:30,940 --> 00:02:34,640
להדפיס מבחינה ויזואלית אם הייתי לקמפל
והפעל תכנית זו, לדעתך?

53
00:02:34,640 --> 00:02:35,140
כן?

54
00:02:35,140 --> 00:02:38,360

55
00:02:38,360 --> 00:02:38,860
>> כוכבים.

56
00:02:38,860 --> 00:02:41,690
אז כל הכוכבים על
אותו קו הוא מה ששמעתי,

57
00:02:41,690 --> 00:02:43,391
ולאחר מכן את אופי הקו החדש.

58
00:02:43,391 --> 00:02:44,140
אז בואו ננסה את זה.

59
00:02:44,140 --> 00:02:48,710
אז להפוך את המרכבה-1, להיכנס,
ואני רואה את פקודת הצלצול

60
00:02:48,710 --> 00:02:50,090
שדיברנו עליו בפעם האחרונה.

61
00:02:50,090 --> 00:02:55,180
./buggy-1, ואכן אני רואה את כל 10 כוכבים
על אותו הקו למרות שאני טוען

62
00:02:55,180 --> 00:02:58,690
במפרט שלי רק הערה על גבי
הקוד שאני מתכוון לעשות לאחד

63
00:02:58,690 --> 00:02:59,230
שורה.

64
00:02:59,230 --> 00:03:00,580
אבל זה נראה תקין.

65
00:03:00,580 --> 00:03:04,620
>> עכשיו שורה 15 זה נראה כאילו אני
הדפסת כוכב, ולאחר מכן שורה 16

66
00:03:04,620 --> 00:03:06,620
זה נראה כאילו אני הדפסה
אופי קו חדש,

67
00:03:06,620 --> 00:03:09,560
והם שניהם כל כך מסוכסך
אני פנימי של הלולאה באופן ברור.

68
00:03:09,560 --> 00:03:13,610
אז לא צריך אני עושה כוכב, חדש
קו, כוכב, קו חדש, כוכב, קו חדש?

69
00:03:13,610 --> 00:03:14,110
כן?

70
00:03:14,110 --> 00:03:18,430

71
00:03:18,430 --> 00:03:21,240
>> כן, בניגוד לשפה כמו
פייתון, אם אתה מכיר,

72
00:03:21,240 --> 00:03:23,540
כניסה לא
משנה למחשב.

73
00:03:23,540 --> 00:03:25,280
זה רק חשוב לאדם.

74
00:03:25,280 --> 00:03:29,860
אז קווים ואילו כאן אני כבר המצאתי
15 ו16-- שנראים יפה,

75
00:03:29,860 --> 00:03:31,330
אבל לא אכפת לי המחשב.

76
00:03:31,330 --> 00:03:34,640
המחשב אכפת
יש בעצם סוגריים מסולסלים

77
00:03:34,640 --> 00:03:36,310
סביב שורות הקוד הללו.

78
00:03:36,310 --> 00:03:39,520
>> אז שזה clear-- בדיוק כמו ב
Scratch-- ששני קווים אלו של קוד

79
00:03:39,520 --> 00:03:40,450
צריך להיות מוצא להורג.

80
00:03:40,450 --> 00:03:44,390
כמו אחד מהפאזל הצהוב Scratch אלה
חתיכות שוב ושוב ושוב.

81
00:03:44,390 --> 00:03:50,920
>> זה אז עכשיו אם אני להפעיל מחדש
program-- ./buggy-2-- Hm.

82
00:03:50,920 --> 00:03:51,770
יש לי שגיאה עכשיו.

83
00:03:51,770 --> 00:03:54,212
מה שכחתי לעשות?

84
00:03:54,212 --> 00:03:55,420
כן, אז אני לא לקמפל אותו.

85
00:03:55,420 --> 00:03:56,740
אז להפוך את המרכבה-2.

86
00:03:56,740 --> 00:03:59,840
אין קובץ כזה, כי אני לא
למעשה לקמפל את הגרסה השנייה.

87
00:03:59,840 --> 00:04:04,860
אז עכשיו מעניין
לא מוצהר variable-- לא 2.

88
00:04:04,860 --> 00:04:05,510
אנחנו עושים 1.

89
00:04:05,510 --> 00:04:11,050
הפוך ./buggy-1-- כרכרה-1-- ועכשיו
כל אחד מהם הוא על אותו הקו.

90
00:04:11,050 --> 00:04:13,880
>> עכשיו יש חריג ל
התביעה אמורה הזה שלי

91
00:04:13,880 --> 00:04:15,520
שאתה צריך סוגריים המסולסלים האלה.

92
00:04:15,520 --> 00:04:20,160
מתי זה בעצם OK-- אם יש לך
שם לב שבסעיף או textbooks--

93
00:04:20,160 --> 00:04:22,130
להשמיט את הסוגריים המסולסלים?

94
00:04:22,130 --> 00:04:22,630
כן?

95
00:04:22,630 --> 00:04:26,290

96
00:04:26,290 --> 00:04:26,870
>> בדיוק.

97
00:04:26,870 --> 00:04:28,940
כאשר יש רק אחד
שורת קוד ש

98
00:04:28,940 --> 00:04:32,830
רוצה להיות מזוהים עם
לולאה כמו בדוגמא הראשונה שלנו.

99
00:04:32,830 --> 00:04:36,380
זה לגיטימי לחלוטין
להשמיט את הסוגריים המסולסלים

100
00:04:36,380 --> 00:04:40,310
בדיוק כמו סוג של נוחות
מהמהדר לך.

101
00:04:40,310 --> 00:04:40,810
כן?

102
00:04:40,810 --> 00:04:43,347

103
00:04:43,347 --> 00:04:43,930
שאלה טובה.

104
00:04:43,930 --> 00:04:45,500
האם זה ייחשב שגיאה בסגנון?

105
00:04:45,500 --> 00:04:49,340
היינו promote-- כמו בCS50
מדריך סגנון, את כתובת האתר שעבורו

106
00:04:49,340 --> 00:04:51,926
הוא בpset1-- שתמיד
להשתמש בסוגריים המסולסלים.

107
00:04:51,926 --> 00:04:53,550
בוודאי אם אתה חדש בתכנות.

108
00:04:53,550 --> 00:04:56,800
המציאות היא שאנחנו לא
הולך לאסור אותך

109
00:04:56,800 --> 00:04:58,680
מלעשות נוחות אלה.

110
00:04:58,680 --> 00:05:00,846
אבל אם אתה רק מתחיל
לתנופה של דברים,

111
00:05:00,846 --> 00:05:04,020
בהחלט פשוט תמיד להשתמש במתולתל
פלטה עד שאתה מקבל את העניין.

112
00:05:04,020 --> 00:05:04,640
שאלה טובה.

113
00:05:04,640 --> 00:05:05,320
>> בסדר.

114
00:05:05,320 --> 00:05:07,660
כך שלאחר מכן היה באג.

115
00:05:07,660 --> 00:05:09,190
לפחות במשהו פשוט למדי.

116
00:05:09,190 --> 00:05:11,260
ובכל זאת אתה חושב שאולי זה
הוא בסיסי למדי, נכון?

117
00:05:11,260 --> 00:05:13,635
זה סוג של השבוע הראשון
להסתכל על השפה

118
00:05:13,635 --> 00:05:14,890
כמו, רואה באגים שלך בו.

119
00:05:14,890 --> 00:05:17,250
אבל אלה המציאות הם
נציג למעשה

120
00:05:17,250 --> 00:05:20,310
של כמה בעיות די מפחידות
שיכול להתעורר בעולם האמיתי.

121
00:05:20,310 --> 00:05:23,530
>> אז כמה מכם אולי זוכרים
אם אתה מבין את חדשות טק,

122
00:05:23,530 --> 00:05:25,740
או אולי אפילו נתפס
רוח של זה בחודש פברואר

123
00:05:25,740 --> 00:05:29,434
של השנה האחרונה שהיה לי אפל
עשה קצת טעות בשני iOS,

124
00:05:29,434 --> 00:05:31,350
מערכת ההפעלה על
הטלפונים שלהם, וגם

125
00:05:31,350 --> 00:05:34,220
Mac OS, מערכת ההפעלה
על המחשבים השולחניים והניידים שלהם.

126
00:05:34,220 --> 00:05:36,480
ואתה ראה את כותרות כמו זו.

127
00:05:36,480 --> 00:05:41,120
ולאחר מכן, אפל
הבטחתי לתקן את הבאג הזה,

128
00:05:41,120 --> 00:05:45,950
ועשה מהר מאוד לתקן את זה בiOS,
אבל אז סופו של דבר זה קבוע בMac OS

129
00:05:45,950 --> 00:05:46,810
גם כן.

130
00:05:46,810 --> 00:05:50,370
>> עכשיו אף אחד מהכותרות הללו לבד באמת
לגלות מה הייתה הבעיה הבסיסית,

131
00:05:50,370 --> 00:05:55,640
אבל באג הופחת סופו של דבר ל
באג בSSL, שכבת שקעים מאובטחים.

132
00:05:55,640 --> 00:05:57,390
וסיפור ארוך קצר,
זו היא התוכנה

133
00:05:57,390 --> 00:06:01,030
שהדפדפנים שלנו ואחרים
תוכנה המשמשת לעשות את מה?

134
00:06:01,030 --> 00:06:04,090

135
00:06:04,090 --> 00:06:06,860
>> אם אמרתי שSSL הוא
מעורב, בכל פעם שאתה

136
00:06:06,860 --> 00:06:13,920
לבקר URL המתחילה בHTTPS,
מה אז אולי SSL להיות קשור ל?

137
00:06:13,920 --> 00:06:14,580
הצפנה.

138
00:06:14,580 --> 00:06:16,470
אז נדבר על
זה בימים הקרובים.

139
00:06:16,470 --> 00:06:18,750
הצפנה, האמנות
ערבול מידע.

140
00:06:18,750 --> 00:06:22,200
>> אבל סיפור ארוך קצרה, אפל
מתישהו לפני שעשה טעות

141
00:06:22,200 --> 00:06:25,970
ביישומם של SSL,
תוכנה שסופו של דבר מיישמת

142
00:06:25,970 --> 00:06:30,120
כתובות אתרים כמו HTTPS או מקסימום
גם קשרים שיש.

143
00:06:30,120 --> 00:06:32,850
התוצאה שלה היא ש
חיבורים עלולים

144
00:06:32,850 --> 00:06:33,920
ניתן ליירט.

145
00:06:33,920 --> 00:06:37,130
ואת הקשרים שלך היו
אינו מוצפן בהכרח

146
00:06:37,130 --> 00:06:40,350
אם היה לך איזה בחור רע בבין
אתה ואתר היעד ש

147
00:06:40,350 --> 00:06:42,170
ידע איך לנצל את זה.

148
00:06:42,170 --> 00:06:45,090
>> עכשיו אפל פורסם סופו של דבר
לתקן לזה סוף סוף,

149
00:06:45,090 --> 00:06:46,920
והתיאור
של תיקונם היה זה.

150
00:06:46,920 --> 00:06:49,878
תחבורה מאובטחת לא הצליחה לאמת
האותנטיות של החיבור.

151
00:06:49,878 --> 00:06:52,920
הנושא טופל על ידי
שחזור צעדי אימות חסר.

152
00:06:52,920 --> 00:06:57,250
>> אז זה הסבר גלי מאוד יד
עבור פשוט אומר שאנחנו דפוקים.

153
00:06:57,250 --> 00:07:00,920
יש פשוטו כמשמעו אחד
שורת קוד שהיה מרכבה

154
00:07:00,920 --> 00:07:05,130
ביישומם של SSL, ו
אם אתם גולשים באינטרנט ולחפש את זה

155
00:07:05,130 --> 00:07:07,210
למעשה אתה יכול למצוא
קוד המקור המקורי.

156
00:07:07,210 --> 00:07:11,960
לדוגמא, מדובר בצילום מסך של
רק חלק מקובץ גדול למדי,

157
00:07:11,960 --> 00:07:15,965
אבל זה פונקציה שנקראת ככל הנראה
SSL לאמת החלפת מפתחות שרת סימן.

158
00:07:15,965 --> 00:07:17,840
וזה לוקח חבורה של
טיעונים ותשומות.

159
00:07:17,840 --> 00:07:20,298
ואנחנו לא מתכוונים להתמקד
יותר מדי על הפרטים הקטנים שם,

160
00:07:20,298 --> 00:07:24,390
אבל אם אתה מתמקד בקוד בתוך
של עליון שfunction-- בואו

161
00:07:24,390 --> 00:07:25,590
להתמקד על ש.

162
00:07:25,590 --> 00:07:28,140
ייתכן שכבר חושדים
מה עלול השגיאה

163
00:07:28,140 --> 00:07:31,230
אפילו אם אין לך מושג
סופו של דבר מה שאתה מחפש ב.

164
00:07:31,230 --> 00:07:35,924
יש סוג של אנומליה
כאן, וזה מה ש?

165
00:07:35,924 --> 00:07:38,940
>> כן, אני לא ממש אוהב
המראה של שני goto נכשל.

166
00:07:38,940 --> 00:07:42,060
למען האמת, אני לא ממש יודע מה goto
להיכשל אמצעים, אבל יש שניים מהם

167
00:07:42,060 --> 00:07:42,810
גב אל גב.

168
00:07:42,810 --> 00:07:45,290
זה פשוט סוג של משפשף אותי
מבחינה אינטלקטואלית בצורה לא נכונה,

169
00:07:45,290 --> 00:07:48,910
ואכן אם להתמקד על
רק את השורות האלה, זה הוא ג

170
00:07:48,910 --> 00:07:52,220
>> אז הרבה קוד של אפל
הוא עצמו נכתב בC,

171
00:07:52,220 --> 00:07:55,780
וזה, ככל הנראה,
הוא באמת equivalent--

172
00:07:55,780 --> 00:07:59,060
לא שלכניסה היפה
גרסה, אבל אם אתה מכיר בעובדה

173
00:07:59,060 --> 00:08:02,560
שאין סוגריים מסולסלים, מה ש
Apple באמת כתב היה קוד שנראה

174
00:08:02,560 --> 00:08:03,540
כמו זה.

175
00:08:03,540 --> 00:08:07,080
אז אני כבר זנקתי החוצה ואני פשוט
קבוע הזחה במובן

176
00:08:07,080 --> 00:08:10,690
כי אם אין סוגריים מסולסלים, ש
goto השני ייכשל כי הוא בצהוב

177
00:08:10,690 --> 00:08:12,500
הוא הולך לבצע ולא משנה מה.

178
00:08:12,500 --> 00:08:15,540
זה לא קשור עם
אם המצב מעליו.

179
00:08:15,540 --> 00:08:19,590
>> אז גם שוב, אם אתה עושה לא ממש
להבין מה זה אולי יכול

180
00:08:19,590 --> 00:08:23,230
להיות עושים, יודע שכל אחד מאלה
conditions-- כל אחד מהקווים הללו

181
00:08:23,230 --> 00:08:26,180
הוא צעד חשוב מאוד
בתהליך של בדיקה

182
00:08:26,180 --> 00:08:28,350
אם הנתונים שלך הוא למעשה מוצפן.

183
00:08:28,350 --> 00:08:31,710
אז מדלג על אחד מאלה
צעדים, לא הרעיון הכי טוב.

184
00:08:31,710 --> 00:08:34,840
>> אבל בגלל שיש לנו את זה
goto השני ייכשל בצהוב,

185
00:08:34,840 --> 00:08:36,840
וכי ברגע שאנו
סוג של בחינה אסתטית

186
00:08:36,840 --> 00:08:40,480
להזיז אותו לצד השמאל שבו
מבחינה לוגית הוא ברגע, מה ש

187
00:08:40,480 --> 00:08:43,230
זה אומר עבור הקו
של קוד שלהלן שgoto השני

188
00:08:43,230 --> 00:08:46,480
להיכשל היית חושב?

189
00:08:46,480 --> 00:08:48,860
זה תמיד הולך להיות דילוג.

190
00:08:48,860 --> 00:08:52,100
אז GOTOs בדרך כלל בעין יפה
מסיבות שלא ממש ייכנסו ל,

191
00:08:52,100 --> 00:08:54,940
ואכן בCS50 אנו נוטים שלא
ללמדך לעמוד הצהרה זו,

192
00:08:54,940 --> 00:08:58,130
אבל אתה יכול לחשוב על goto
להיכשל כקפיצת דרכי משמעות

193
00:08:58,130 --> 00:08:59,600
לחלק אחר של הקוד.

194
00:08:59,600 --> 00:09:03,120
>> במילים אחרות לקפוץ מעל
השורה האחרונה זה לגמרי,

195
00:09:03,120 --> 00:09:07,420
ולכן התוצאה של זה טיפש
טעות פשוטה שרק הייתה

196
00:09:07,420 --> 00:09:10,330
תוצאה של כנראה מישהו
העתקה והדבקה של אחד יותר מדי

197
00:09:10,330 --> 00:09:14,150
פעמים רבות היו שכל
ביטחון של iOS ומערכת ההפעלה Mac OS

198
00:09:14,150 --> 00:09:18,240
היה פגיע ליירוט
על ידי הרעים די הרבה זמן.

199
00:09:18,240 --> 00:09:19,940
עד Apple לבסוף קבוע זה.

200
00:09:19,940 --> 00:09:23,100
>> עכשיו, אם חלק מכם הוא למעשה
בם פועלים גרסאות ישנות של iOS או Mac OS,

201
00:09:23,100 --> 00:09:27,250
אתה יכול ללכת לgotofail.com ש
הוא אתר אינטרנט שמישהו הקים

202
00:09:27,250 --> 00:09:29,190
כדי לקבוע במהות
תיכנותי

203
00:09:29,190 --> 00:09:30,980
אם המחשב שלך הוא עדיין פגיע.

204
00:09:30,980 --> 00:09:33,600
ולמען אמת, אם הוא,
זה כנראה רעיון טוב

205
00:09:33,600 --> 00:09:36,870
כדי לעדכן את הטלפון שלך או
Mac שלך בשלב זה.

206
00:09:36,870 --> 00:09:40,120
אבל יש, רק עדות לעד כמה
הערכה של רמה הנמוכה אלה

207
00:09:40,120 --> 00:09:42,400
פרטים ודי
רעיונות פשוטים יכול באמת

208
00:09:42,400 --> 00:09:44,590
לתרגם החלטות
ובעיות ש

209
00:09:44,590 --> 00:09:47,320
affected-- בcase-- זה
מיליוני אנשים.

210
00:09:47,320 --> 00:09:49,107
>> עכשיו מילה על ממשל.

211
00:09:49,107 --> 00:09:50,690
סעיף יתחיל ביום ראשון הקרוב.

212
00:09:50,690 --> 00:09:53,360
אתה תקבל הודעת דוא"ל על ידי
סוף שבוע על סעיף, ובשלב זה

213
00:09:53,360 --> 00:09:55,290
תהליך resectioning
יתחיל אם יש לך

214
00:09:55,290 --> 00:09:56,998
הבנתי עכשיו שיש לך
כמה קונפליקטים חדשים.

215
00:09:56,998 --> 00:10:00,180
אז זה קורה כל שנה, ואנחנו
יהיה להתאים בימים הבאים.

216
00:10:00,180 --> 00:10:02,430
>> משרד hours-- לעשות לשמור
עין על לוח הזמנים הזה כאן.

217
00:10:02,430 --> 00:10:05,100
משנה קצת השבוע,
במיוחד את שעת ההתחלה

218
00:10:05,100 --> 00:10:08,180
והמיקום, אז אל תתייעץ
שלפני היציאה לשעתי עבודה

219
00:10:08,180 --> 00:10:09,520
כל אחת מארבעה הלילות הבאים.

220
00:10:09,520 --> 00:10:12,680
ועכשיו מילה על הערכה,
במיוחד כפי שאתה לצלול לתוך בעיה

221
00:10:12,680 --> 00:10:14,350
קובע אחת ומעבר.

222
00:10:14,350 --> 00:10:17,070
>> אז למפרט,
אלה הם בדרך כלל

223
00:10:17,070 --> 00:10:20,360
הצירים שלאורכו
אנו מעריכים את העבודה שלך.

224
00:10:20,360 --> 00:10:23,170
היקף מתייחס למה
כלי הקוד שלך במידה

225
00:10:23,170 --> 00:10:25,690
התכונות הנדרשות
על ידי המפרט שלנו.

226
00:10:25,690 --> 00:10:28,290
במילים אחרות, עד כמה
סט חתיכה עשה לך לנגוס.

227
00:10:28,290 --> 00:10:30,440
האם אתה עושה שליש ממנו,
חצי ממנו, ממנו 100%.

228
00:10:30,440 --> 00:10:33,000
גם אם זה לא נכון,
כמה עשה לך לנסות?

229
00:10:33,000 --> 00:10:35,290
כדי שלוכד את הרמה
מאמץ והסכום

230
00:10:35,290 --> 00:10:38,260
שאליו אתה נגסת
הבעיות של מערכת בעיה.

231
00:10:38,260 --> 00:10:40,690
>> Correctness-- זה אחד, ל
באיזו מידה, הוא הקוד שלך

232
00:10:40,690 --> 00:10:43,150
עולה בקנה אחד עם שלנו
מפרטים וללא באגים.

233
00:10:43,150 --> 00:10:44,770
אז זה עובד בצורה נכונה?

234
00:10:44,770 --> 00:10:48,700
אם אנחנו נותנים לו קצת קלט, עושה את זה
לתת לנו את התפוקה שאנחנו מצפים?

235
00:10:48,700 --> 00:10:52,570
Design-- עכשיו זה הוא ראשון מ
במיוחד איכותיים אלה,

236
00:10:52,570 --> 00:10:56,180
או את אלה שדורשים שיקול דעת אנושית.

237
00:10:56,180 --> 00:10:59,690
ואכן, זו הסיבה שיש לנו צוות
של עמיתי הוראה כל כך הרבה וכמובן

238
00:10:59,690 --> 00:11:00,350
עוזרים.

239
00:11:00,350 --> 00:11:03,480
באיזו מידה היא שלך
קוד כתוב היטב?

240
00:11:03,480 --> 00:11:05,810
>> ושוב, זה מאוד
הערכה איכותית

241
00:11:05,810 --> 00:11:09,100
שיעבוד איתך על
דו directionally בשבועות קרוב.

242
00:11:09,100 --> 00:11:12,060
כך שכאשר אתה מקבל לא
רק ציונים מספריים, אלא גם

243
00:11:12,060 --> 00:11:16,682
ציונים שנכתבו, או משוב שהוקלד,
או בכתב משוב במילים באנגלית.

244
00:11:16,682 --> 00:11:19,640
זה מה שאנחנו נשתמש להסיע אותך
כיוון בעצם כתיבת קוד טוב יותר.

245
00:11:19,640 --> 00:11:23,320
ובהרצאה וסעיף, ננסה
להצביע לעתים קרובות ככל שאנו can-- out--

246
00:11:23,320 --> 00:11:26,420
מה שעושה את תכנית לא רק
נכון וטוב מבחינה תפקודית,

247
00:11:26,420 --> 00:11:28,200
אבל גם מתוכנן היטב.

248
00:11:28,200 --> 00:11:31,850
היעילה ביותר זה יכול להיות, או
אפילו היפה ביותר שהוא יכול להיות.

249
00:11:31,850 --> 00:11:33,100
>> מה שמוביל אותנו לסגנון.

250
00:11:33,100 --> 00:11:36,876
סגנון סופו של דבר הוא
שיפוט אסתטי.

251
00:11:36,876 --> 00:11:38,750
האם לבחור בטוב
שמות למשתנים שלך?

252
00:11:38,750 --> 00:11:40,330
האם מסוכסך הקוד שלך כמו שצריך?

253
00:11:40,330 --> 00:11:44,010
זה נראה טוב, ולכן,
זה קל לאדם אחר

254
00:11:44,010 --> 00:11:46,550
לקרוא בהתאמה שלך
תקינותה.

255
00:11:46,550 --> 00:11:50,300
>> עכשיו, בדרך כלל, ללימודים, אנו להבקיע
את הדברים האלה בסולם של חמש נקודות.

256
00:11:50,300 --> 00:11:53,640
ותן לי פטיש בית הנקודה
כי שלוש הוא אכן טוב.

257
00:11:53,640 --> 00:11:55,550
לעשות מהר מאוד אנשים
להתחיל לעשות חשבון.

258
00:11:55,550 --> 00:11:58,133
כשהם מגיעים שלוש מתוך
חמש על נכונות לכמה pset

259
00:11:58,133 --> 00:12:02,040
והם חושבים לעזאזל, אני הולך 60%
שהיא במהות D או E.

260
00:12:02,040 --> 00:12:03,980
>> זה לא הדרך בה אנו
חושב על המספרים האלה.

261
00:12:03,980 --> 00:12:06,880
שלושה הוא אכן טובים, ומה שאנו
בדרך כלל מצפים בתחילת

262
00:12:06,880 --> 00:12:09,820
במונח זה הוא שאם אתה מקבל
חבורה של three's-- אולי כמה

263
00:12:09,820 --> 00:12:12,540
ירידים, כמה fours-- או
כמה זוגות, כמה fours--

264
00:12:12,540 --> 00:12:13,748
זה מקום טוב להתחיל.

265
00:12:13,748 --> 00:12:16,320
וכל כך הרבה זמן כפי שאנו רואים
מסלול כלפי מעלה לאורך זמן,

266
00:12:16,320 --> 00:12:18,540
אתה במקום טוב במיוחד.

267
00:12:18,540 --> 00:12:20,752
>> נוסחתו אנו משתמשים כדי
דברים במשקל הוא למעשה

268
00:12:20,752 --> 00:12:22,710
זה לתכנית הלימודים,
אשר רק אומר שאנחנו

269
00:12:22,710 --> 00:12:24,750
לתת משקל רב יותר לתקינות.

270
00:12:24,750 --> 00:12:27,930
כי זה מאוד לעתים קרובות תקינות
שלוקח את רוב הזמן.

271
00:12:27,930 --> 00:12:28,760
תאמין לי עכשיו.

272
00:12:28,760 --> 00:12:31,190
אתה find-- לפחות
בpset-- אחד שאתה

273
00:12:31,190 --> 00:12:36,790
לבלות 90% מהזמן שלך
עובד על 10% מהבעיה.

274
00:12:36,790 --> 00:12:39,320
>> וכל מה שסוג של עובד
למעט אחד או שניים באגים,

275
00:12:39,320 --> 00:12:41,570
ואלה הם באגים ש
אשמור אותך ער עד מאוחר בלילה.

276
00:12:41,570 --> 00:12:43,380
אלה הם אלה ש
סוג של בריחתך.

277
00:12:43,380 --> 00:12:45,560
אבל אחרי השינה על זה,
או ללמוד בשעות עבודה

278
00:12:45,560 --> 00:12:48,844
או לשאול שאלות באינטרנט, הוא
כשאתה מגיע למטרה ש100%,

279
00:12:48,844 --> 00:12:50,760
וזו הסיבה שאנו במשקל
התקינות ביותר.

280
00:12:50,760 --> 00:12:54,102
עיצוב קצת פחות, ו
סגנון קצת פחות מזה.

281
00:12:54,102 --> 00:12:56,060
אבל לשמור על סגנון mind--
אולי הקל ביותר

282
00:12:56,060 --> 00:12:58,890
אלה כדי לנגוס
כמו לכל מדריך הסגנון.

283
00:12:58,890 --> 00:13:01,580
>> ועכשיו, יותר רציני
לב על יושר אקדמי.

284
00:13:01,580 --> 00:13:05,000
יש CS50 ההבחנה המצערת של
להיות היצרנית הגדולה ביותר של מודעות לוח

285
00:13:05,000 --> 00:13:07,330
מקרים כמעט בכל שנה מבחינה היסטורית.

286
00:13:07,330 --> 00:13:11,012
זה לא בגלל תלמידים לרמות ב
CS50 כל, יותר מכל כיתה אחרת,

287
00:13:11,012 --> 00:13:13,720
אלא משום שעל ידי אופי העבודה,
העובדה שזה אלקטרוני,

288
00:13:13,720 --> 00:13:16,636
העובדה שאנחנו מחפשים אותו, ו
העובדה שאנחנו מדעני מחשב,

289
00:13:16,636 --> 00:13:20,570
אני יכול לומר שאנחנו, למרבה הצער
טוב מאוד באיתורו.

290
00:13:20,570 --> 00:13:22,710
>> אז מה זה אומר במונחים ריאליים?

291
00:13:22,710 --> 00:13:24,820
אז זה, לתכנית הלימודים,
הפילוסופיה של הקורס

292
00:13:24,820 --> 00:13:28,090
באמת מסתכם להיות סביר.

293
00:13:28,090 --> 00:13:31,684
יש את הקו הזה שבין
עושה את העבודה של אחד בעצמך

294
00:13:31,684 --> 00:13:34,100
ומקבל קצת
עזרה סבירה מידיד,

295
00:13:34,100 --> 00:13:38,020
ועל הסף עושה את העבודה עבורך
חבר, או שולח לו או לה את הקוד שלך

296
00:13:38,020 --> 00:13:41,080
כך שפשוט שהוא או היא יכולה
לקחת או ללוות אותה נכונה.

297
00:13:41,080 --> 00:13:43,580
וזה חוצה את הקו
שצוירנו בכיתה.

298
00:13:43,580 --> 00:13:45,410
>> ראה, תכנית הלימודים
סופו של דבר לקווים

299
00:13:45,410 --> 00:13:48,209
כי אנו מפנים כסבירים
והתנהגות בלתי סבירה,

300
00:13:48,209 --> 00:13:50,000
אבל זה באמת עושה רתיחה
עד למהות

301
00:13:50,000 --> 00:13:53,980
העבודה שלך צורך
להיות שלך בסופו של הדבר.

302
00:13:53,980 --> 00:13:56,230
כעת, עם שאמרו,
יש היוריסטי.

303
00:13:56,230 --> 00:13:58,980
כי כמו שאתה עלול imagine--
משעתי עבודה והחזותיות

304
00:13:58,980 --> 00:14:01,060
וקטעי הווידאו יש לנו
CS50 כך far-- מוצג

305
00:14:01,060 --> 00:14:04,530
נועד אכן להיות כשיתופי
ושיתופי וכחברתי כ

306
00:14:04,530 --> 00:14:06,450
ככל האפשר.

307
00:14:06,450 --> 00:14:08,570
כשיתוף פעולה כפי שהוא קפדני.

308
00:14:08,570 --> 00:14:11,314
>> אבל עם זה אמר, היוריסטי,
כפי שתראה בתכנית הלימודים,

309
00:14:11,314 --> 00:14:12,980
הוא שכאשר אתה נתקלת בבעיה כלשהי.

310
00:14:12,980 --> 00:14:16,470
יש לך כמה באגים בקוד שלך שאתה
לא יכול לפתור, זה סביר בשבילך

311
00:14:16,470 --> 00:14:18,039
כדי להראות את הקוד שלך למישהו אחר.

312
00:14:18,039 --> 00:14:21,080
חבר גם בכיתה, חבר
יושב לידך בשעתי עבודה,

313
00:14:21,080 --> 00:14:22,680
או חבר צוות.

314
00:14:22,680 --> 00:14:25,810
אבל הם לא יכולים להציג את הקוד שלהם אליך.

315
00:14:25,810 --> 00:14:27,710
>> במילים אחרות,
לענות לquestion-- שלך

316
00:14:27,710 --> 00:14:29,940
אני צריך help-- לא הו, הנה הקוד שלי.

317
00:14:29,940 --> 00:14:32,440
תסתכל על זה ו
להסיק מזה איך שתרצה.

318
00:14:32,440 --> 00:14:34,580
עכשיו, כמובן, יש
דרך ברורה למשחק

319
00:14:34,580 --> 00:14:37,760
מערכת זו לפיה אני אראה לך
הקוד שלי לפני שיש שאלה.

320
00:14:37,760 --> 00:14:40,150
אתה תראה לי את הקוד שלך שלי
לפני שיש שאלה.

321
00:14:40,150 --> 00:14:45,870
אבל לראות את הסילבוס שוב ל
פרטים עדינים של איפה הקו הזה הוא.

322
00:14:45,870 --> 00:14:50,606
>> רק עכשיו לצייר את התמונה ו
לשתף כשקוף ככל האפשר

323
00:14:50,606 --> 00:14:53,480
איפה אנחנו נמצאים בשנים האחרונות,
זה מספר מקרי מודעות לוח

324
00:14:53,480 --> 00:14:56,260
CS50 שיש לו מעל
העבר שבע שנים.

325
00:14:56,260 --> 00:14:58,717
עם 14 מקרים נפילה האחרונה זו.

326
00:14:58,717 --> 00:15:01,300
במונחים של התלמידים המעורבים,
זה היה 20 כמה תלמידים מוזרים

327
00:15:01,300 --> 00:15:02,490
בסתיו האחרון.

328
00:15:02,490 --> 00:15:05,670
היה שיא של 33
סטודנטים לפני כמה שנים.

329
00:15:05,670 --> 00:15:08,830
רבים מהם, למרבה הצער
כבר לא כאן בקמפוס.

330
00:15:08,830 --> 00:15:13,100
>> תלמידים מעורבים כאחוז מ
כיתה שנעה מבחינה היסטורית בין 0%

331
00:15:13,100 --> 00:15:17,300
ל5.3%, וזה רק כדי לומר
זו היא שנה אתגר.

332
00:15:17,300 --> 00:15:20,390
ולקראת הסוף ש, מה
אנחנו רוצים לעשות הוא להעביר אחד

333
00:15:20,390 --> 00:15:24,310
שdd-- רק FYI-- להשוות ב
הגינות לתלמידים אלה ש

334
00:15:24,310 --> 00:15:26,520
הם הבאים בתור בהתאם.

335
00:15:26,520 --> 00:15:29,620
אנו עושים להשוות את כל נוכחי
הגשות נגד כל המשימות האחרונות

336
00:15:29,620 --> 00:15:30,840
מהשנים רבות בעבר.

337
00:15:30,840 --> 00:15:33,620
>> אנחנו יודעים גם איך גוגל סביב
ולמצוא מאגרי קוד

338
00:15:33,620 --> 00:15:36,360
פורומים באינטרנט, דיון
אתרי עבודה באינטרנט, באינטרנט.

339
00:15:36,360 --> 00:15:41,580
אם תלמיד יכול למצוא אותו, אנחנו בוודאי יכולים
מוצא את זה הרבה כמו שאנחנו בצער לעשות.

340
00:15:41,580 --> 00:15:45,330
אז מה תראה בתכנית הלימודים
למרות שהוא סעיף החרטה הזה.

341
00:15:45,330 --> 00:15:47,500
בהחלט אני יכול
מעריך, וכולנו יש

342
00:15:47,500 --> 00:15:50,870
צוות שעשה את הקורס כמו
זה, או זה עצמו לאורך זמן,

343
00:15:50,870 --> 00:15:53,997
בהחלט יודעים מה זה כש
חיים מקבלים את הדרך כאשר יש לך

344
00:15:53,997 --> 00:15:56,080
כמה מאוחר בלילה deadline--
לא רק במעמד הזה,

345
00:15:56,080 --> 00:15:58,660
אבל another-- כשאתה
מותש לחלוטין, לחוץ,

346
00:15:58,660 --> 00:16:00,659
יש לי מספר מופרז
של דברים אחרים לעשות.

347
00:16:00,659 --> 00:16:03,660
אתה תעשה בשלב כלשהו ב
חיים בהחלט רעים, אולי מאוחר

348
00:16:03,660 --> 00:16:04,620
החלטת הלילה.

349
00:16:04,620 --> 00:16:06,520
>> אז לכל תכנית הלימודים,
יש סעיף זה,

350
00:16:06,520 --> 00:16:10,629
כך שאם בתוך 72 שעות של עשייה
כמה החלטות גרועות, בבעלות אותך אליו

351
00:16:10,629 --> 00:16:12,670
ולהגיע אליי ו
אחד מהראשים של הקורס

352
00:16:12,670 --> 00:16:14,300
ואהיה לנו שיחה.

353
00:16:14,300 --> 00:16:16,220
אנו אטפל בדברים
באופן פנימי בתקווה

354
00:16:16,220 --> 00:16:18,770
זה הופך להיות יותר של
רגע הוראה או לקח חיים,

355
00:16:18,770 --> 00:16:22,120
ולא משהו עם
השלכות במיוחד דרסטית

356
00:16:22,120 --> 00:16:24,570
כפי שהיה אפשר לראות בתרשימים אלה כאן.

357
00:16:24,570 --> 00:16:26,540
>> אז זה טון רציני מאוד.

358
00:16:26,540 --> 00:16:29,960
בואו נעצור רק לכמה
שניות כדי לשבור את המתח.

359
00:16:29,960 --> 00:16:34,442
>> [השמעת מוסיקה]

360
00:16:34,442 --> 00:17:17,768

361
00:17:17,768 --> 00:17:20,250
>> דוד י מלאן: בסדר,
אז איך זה היה עבור Segue?

362
00:17:20,250 --> 00:17:22,059
לנושאים העיקריים של היום.

363
00:17:22,059 --> 00:17:23,859
הראשון שבם הוא הפשטה.

364
00:17:23,859 --> 00:17:26,900
נוסף של שהולך להיות
ייצוג של נתונים, אשר בכנות

365
00:17:26,900 --> 00:17:31,640
היא באמת דרך יבשה לומר איך אנחנו יכולים
ללכת על פתרון בעיות וחשיבה

366
00:17:31,640 --> 00:17:33,250
על פתרון בעיות?

367
00:17:33,250 --> 00:17:37,285
אז אתה ראית בגירוד, ושיש לך
ראה אולי כבר בpset1 עם C

368
00:17:37,285 --> 00:17:39,930
כי אתה לא יכול להשתמש רק
פונקציות, כמו printf,

369
00:17:39,930 --> 00:17:42,770
שאנשים אחרים ב
שנים האחרונות כתב בשבילך.

370
00:17:42,770 --> 00:17:45,340
אתה יכול גם לכתוב פונקציות משלך.

371
00:17:45,340 --> 00:17:48,440
>> ואף על פי שייתכן שאין לי
עשה את זה בC, ולמען אמת בpset1

372
00:17:48,440 --> 00:17:51,866
אתה לא באמת צריך לכתוב שלך
פונקציה עצמו כי problem--

373
00:17:51,866 --> 00:17:53,990
בעוד אולי מרתיע ב
glance-- הראשון שתראה

374
00:17:53,990 --> 00:17:57,910
סופו של דבר ניתן לפתור עם
לא קווים כל שרבים מקוד.

375
00:17:57,910 --> 00:18:01,140
אבל עם שאמרו, במונחים
כתיבת פונקציה משלך,

376
00:18:01,140 --> 00:18:03,570
מבין שC אין לתת
אתה יכולת זו.

377
00:18:03,570 --> 00:18:06,940
>> אני הולך ללכת בקוד המקור של היום,
שכבר זמין כיום באינטרנט,

378
00:18:06,940 --> 00:18:10,900
ואני הולך קדימה ופתוח
עד תכנית בשם 0.C פונקציה,

379
00:18:10,900 --> 00:18:14,620
ובפונקצית אפס
אנחנו תראו כמה דברים.

380
00:18:14,620 --> 00:18:19,160
בשורות הראשונות 18 דרך
23 היא הפונקציה העיקרית שלי.

381
00:18:19,160 --> 00:18:22,414
ועכשיו שאנחנו מתחילים לקרוא
קוד שאנחנו לא כותבים על לטוס,

382
00:18:22,414 --> 00:18:25,080
אבל במקום שכתבתי מראש
או שאתה בבעיה להגדיר

383
00:18:25,080 --> 00:18:27,910
עשוי לקבל שיש
נכתב מראש.

384
00:18:27,910 --> 00:18:30,040
דרך טובה להתחיל
קריאת קוד של מישהו אחר

385
00:18:30,040 --> 00:18:31,400
הוא לחפש את הפונקציה העיקרית.

386
00:18:31,400 --> 00:18:34,420
להבין איפה כניסה ש
נקודה היא מפעיל את התכנית,

387
00:18:34,420 --> 00:18:36,580
ולאחר מכן בצע אותו באופן לוגי משם.

388
00:18:36,580 --> 00:18:40,190
>> אז תכנית זו הדפסים כנראה
השם שלך ואחריו נקודתיים.

389
00:18:40,190 --> 00:18:42,490
לאחר מכן אנו משתמשים בGetString
מספריית CS50

390
00:18:42,490 --> 00:18:46,050
כדי לקבל מחרוזת, או מילה או צירוף מילים
מהמשתמש במקלדת.

391
00:18:46,050 --> 00:18:48,390
ואז יש את זה
PrintName here-- דבר.

392
00:18:48,390 --> 00:18:51,420
>> עכשיו PrintName הוא לא
פונקציה שמגיעה עם ג

393
00:18:51,420 --> 00:18:52,970
זה לא בio.h. הסטנדרטי

394
00:18:52,970 --> 00:18:55,570
זה לא בCS50.h.

395
00:18:55,570 --> 00:18:57,880
זה די באותו הקובץ.

396
00:18:57,880 --> 00:19:01,000
שים לב אם אני לגלול למטה
קווי bit-- 25 ל27--

397
00:19:01,000 --> 00:19:05,330
זה פשוט דרך יפה של להעיר
הקוד שלך באמצעות הכוכבים וחתכים.

398
00:19:05,330 --> 00:19:07,320
זהו קו רב
להגיב, וזה רק

399
00:19:07,320 --> 00:19:10,570
התיאור שלי בכחול של
מה הפונקציה הזו עושה.

400
00:19:10,570 --> 00:19:14,530
>> כי בקווי 28 דרך 31 ב,
אני כתבתי פונקצית סופר פשוטה

401
00:19:14,530 --> 00:19:16,280
ששמה PrintName.

402
00:19:16,280 --> 00:19:19,560
זה לוקח כמה
טיעונים הייתם אומרים?

403
00:19:19,560 --> 00:19:25,120
אז argument-- אחד כי יש אחד
טיעון מופיע בתוך הסוגריים.

404
00:19:25,120 --> 00:19:27,000
סוג שהוא מחרוזת.

405
00:19:27,000 --> 00:19:30,240
כלומר PrintName
הוא כמו קופסא שחורה זה

406
00:19:30,240 --> 00:19:32,910
או פונקציה שלוקחת
כקלט מחרוזת.

407
00:19:32,910 --> 00:19:35,730
>> ואת השם של מחרוזת ש
נוח יהיה שם.

408
00:19:35,730 --> 00:19:37,840
לא S, לא N, אבל שם.

409
00:19:37,840 --> 00:19:41,090
אז מה עושה PrintName לעשות?

410
00:19:41,090 --> 00:19:42,210
זה פשוט נחמד.

411
00:19:42,210 --> 00:19:45,390
בדיוק כמו שורת קוד אחת ל
printf, אבל כנראה שזה

412
00:19:45,390 --> 00:19:47,950
מדפיס את "שלום," כך וכך.

413
00:19:47,950 --> 00:19:50,070
איפה כך וכך
מגיע מהטיעון.

414
00:19:50,070 --> 00:19:52,300
>> עכשיו זה לא חדשנות עצומה כאן.

415
00:19:52,300 --> 00:19:56,710
באמת, אני כבר לקחתי תכנית שיכלה
נכתב עם שורה אחת של קוד

416
00:19:56,710 --> 00:20:00,190
על ידי הצבת זה כאן,
ושיניתי אותו למשהו

417
00:20:00,190 --> 00:20:04,920
שיש בו כשישה או שבע או משהו כזה
שורות קוד כל הדרך למטה כאן.

418
00:20:04,920 --> 00:20:08,190
>> אבל זה התרגול של
העיקרון הידוע כהפשטה.

419
00:20:08,190 --> 00:20:12,550
סוג של מתמצת בתוך חדש
פונקציה שיש לו שם, וטוב יותר

420
00:20:12,550 --> 00:20:14,590
עדיין שם שממש
אומר מה שהוא עושה.

421
00:20:14,590 --> 00:20:16,880
אני מתכוון printf-- זה לא
במיוחד תיאורים.

422
00:20:16,880 --> 00:20:18,932
אם אני רוצה ליצור
פיסת הפאזל, או אם אני

423
00:20:18,932 --> 00:20:21,140
רוצה ליצור פונקציה
שמדפיס את שמו של מישהו,

424
00:20:21,140 --> 00:20:23,230
היופי של עושה את זה
הוא שאני באמת יכול

425
00:20:23,230 --> 00:20:27,170
לתת פונקציה ששם
שמתאר את מה שהיא עושה.

426
00:20:27,170 --> 00:20:29,844
>> עכשיו זה לוקח בקלט ש
אני כבר נקרא באופן שרירותי את השם,

427
00:20:29,844 --> 00:20:32,760
אבל גם זה בצורה נפלאה תיאורים
במקום להיות קצת יותר

428
00:20:32,760 --> 00:20:36,140
כללי כמו ס 'ו
חלל, לעת עתה, רק אומר

429
00:20:36,140 --> 00:20:38,330
שפונקציה זו אינה
למסור לי את דבר.

430
00:20:38,330 --> 00:20:41,127
זה לא כמו GetString ש
פשוטו כמשמעו מושיט לי חזרה מחרוזת

431
00:20:41,127 --> 00:20:43,960
כמו שעשינו עם פיסות נייר
עם החברים לכיתה שלך בשבוע שעבר,

432
00:20:43,960 --> 00:20:45,990
אלא פשוט יש תופעת לוואי.

433
00:20:45,990 --> 00:20:48,080
היא מדפיסה משהו על המסך.

434
00:20:48,080 --> 00:20:53,880
>> אז בסופו של היום, אם אני
עושה פונקציה-0, ./function-0,

435
00:20:53,880 --> 00:20:55,450
אנחנו תראו שהוא מבקש את השם שלי.

436
00:20:55,450 --> 00:20:58,150
אני מקליד דוד, וזה סוגים את השם שלי.

437
00:20:58,150 --> 00:21:01,080
אם אני עושה את זה שוב עם רוב,
זה הולך לומר "שלום, רוב."

438
00:21:01,080 --> 00:21:04,280
אז רעיון פשוט, אבל אולי
להסיק מזה נפשי

439
00:21:04,280 --> 00:21:06,750
שהתוכניות שלך לקבל
קצת יותר מסובך,

440
00:21:06,750 --> 00:21:10,290
ואתה רוצה לכתוב נתח של
קוד ושיחה שcode-- Invoke

441
00:21:10,290 --> 00:21:13,270
code-- שעל ידי כמה תיאורים
שם כמו PrintName,

442
00:21:13,270 --> 00:21:15,600
C עושה להרשות לנו את היכולת הזו.

443
00:21:15,600 --> 00:21:17,660
>> הנה עוד דוגמא פשוטה.

444
00:21:17,660 --> 00:21:22,940
לדוגמא, אם אני פותח את
להגיש מהיום נקרא return.c,

445
00:21:22,940 --> 00:21:24,270
שים לב למה שעשיתי כאן.

446
00:21:24,270 --> 00:21:26,330
רוב הפונקציה העיקרית זו הוא printf.

447
00:21:26,330 --> 00:21:30,360
אני ראשון באופן שרירותי לאתחל
משתנה בשם x למספר 2.

448
00:21:30,360 --> 00:21:34,110
אני מכן להדפיס את "x הוא עכשיו
% I "עוברים בערכו של x.

449
00:21:34,110 --> 00:21:35,500
כל כך פשוט שאני אומר מה שזה.

450
00:21:35,500 --> 00:21:37,208
>> עכשיו אני רק באומץ
טענה עם printf.

451
00:21:37,208 --> 00:21:42,050
אני cubing שx הערך, ואני
עושה זאת על ידי קורא לפונקציה

452
00:21:42,050 --> 00:21:45,590
נקרא חולף קובייה
בx כטיעון,

453
00:21:45,590 --> 00:21:49,300
ולאחר מכן לשמור את הפלט
במשתנה עצמו, x.

454
00:21:49,300 --> 00:21:51,340
אז אני מחצתי את הערך של x.

455
00:21:51,340 --> 00:21:53,380
אני דריסה
ערך של x עם כל מה ש

456
00:21:53,380 --> 00:21:56,510
התוצאה של קריאה
פונקצית קובייה זו היא.

457
00:21:56,510 --> 00:21:59,530
ואז אני פשוט להדפיס את חלק
דברים רכים כאן ואומרים את מה שעשיתי.

458
00:21:59,530 --> 00:22:01,600
>> אז מה אז היא קובייה?

459
00:22:01,600 --> 00:22:03,510
שים לב מה ביסודו
שונה כאן.

460
00:22:03,510 --> 00:22:05,540
אני נתתי את הפונקציה
שם כמו קודם.

461
00:22:05,540 --> 00:22:08,270
אני כבר צוין שם לויכוח.

462
00:22:08,270 --> 00:22:11,650
הפעם זה נקרא n במקום שם,
אבל אני יכול לקרוא לזה מה שאני רוצה.

463
00:22:11,650 --> 00:22:12,650
אבל פעם זה שונה.

464
00:22:12,650 --> 00:22:14,080
הדבר הזה בצד השמאל.

465
00:22:14,080 --> 00:22:16,290
בעבר זה היה מה מילת המפתח?

466
00:22:16,290 --> 00:22:16,870
בנים.

467
00:22:16,870 --> 00:22:18,580
עכשיו זה ברור int.

468
00:22:18,580 --> 00:22:20,630
>> אז מה אולי לקחת?

469
00:22:20,630 --> 00:22:24,090
בעוד מסמל חלל סוג של
האין, וזה היה המקרה.

470
00:22:24,090 --> 00:22:25,970
PrintName חזר שום דבר.

471
00:22:25,970 --> 00:22:27,942
זה עשה משהו, אבל
זה לא נותן לי גב

472
00:22:27,942 --> 00:22:30,650
משהו שאני יכול לשים על
צדו השמאלי של סימן שוויון

473
00:22:30,650 --> 00:22:32,460
כמו שעשיתי כאן על קו 22.

474
00:22:32,460 --> 00:22:36,780
>> אז אם אני אומר לעל קו 30,
מה שכנראה רומז

475
00:22:36,780 --> 00:22:38,610
על מה קובייה עושה לי?

476
00:22:38,610 --> 00:22:41,110
כן?

477
00:22:41,110 --> 00:22:42,310
זה מחזיר מספר שלם.

478
00:22:42,310 --> 00:22:44,590
אז זה מחזיר לי, ל
למשל, פיסת נייר

479
00:22:44,590 --> 00:22:46,580
שבו כתב את התשובה.

480
00:22:46,580 --> 00:22:50,130
2 קוביות, או 3 קוביות, או 4
cubed-- כל מה שאני עובר ב,

481
00:22:50,130 --> 00:22:51,540
ואיך אני לא ליישם את זה?

482
00:22:51,540 --> 00:22:54,810
ובכן, רק n פעמים n פעמים n
איך אני יכול קוביית ערך.

483
00:22:54,810 --> 00:22:57,110
אז שוב, סופר פשוט
רעיון, אבל הפגנתי

484
00:22:57,110 --> 00:23:00,100
עכשיו איך אנחנו יכולים לכתוב פונקציות
כי בעצם לא הייתה לנו בחזרה

485
00:23:00,100 --> 00:23:02,380
ערכים שעשויות להיות מעניין.

486
00:23:02,380 --> 00:23:05,740
>> בואו נסתכל על דוגמא אחת האחרונה
כאן נקרא פונקציה אחת.

487
00:23:05,740 --> 00:23:08,530
בדוגמא זו, הוא מתחיל
כדי לקבל יותר משכנע.

488
00:23:08,530 --> 00:23:12,400
אז בפונקציה אחת, זה
הודעת program-- סופו של דבר

489
00:23:12,400 --> 00:23:14,920
קורא פונקציה שנקראת GetPositiveInt.

490
00:23:14,920 --> 00:23:17,800
GetPositiveInt הוא לא
פונקציה בספריית CS50,

491
00:23:17,800 --> 00:23:20,400
אבל החלטנו שאנחנו
היית רוצה שזה קיים.

492
00:23:20,400 --> 00:23:24,550
>> אז אם אנחנו לגלול למטה מאוחר יותר בקובץ,
שימו לב כיצד הלכתי על יישום

493
00:23:24,550 --> 00:23:26,560
לקבל int החיובי, ואני
אומר שזה יותר משכנע

494
00:23:26,560 --> 00:23:28,992
בגלל זה הוא הגון
מספר שורות קוד.

495
00:23:28,992 --> 00:23:30,700
זה לא רק טיפשי
תכנית צעצוע קטנה.

496
00:23:30,700 --> 00:23:33,870
זה בעצם יש כמה בדיקת שגיאות
ועושה משהו מועיל יותר.

497
00:23:33,870 --> 00:23:38,470
>> אז אם כבר לא ראה את ההדרכה
קטעי וידאו שיש לנו מוטבע בpset1,

498
00:23:38,470 --> 00:23:42,350
יודע שזה סוג של
לולאה בC, דומה ברוח

499
00:23:42,350 --> 00:23:44,270
למיני סריטות דברים יכולים לעשות.

500
00:23:44,270 --> 00:23:46,320
ולעשות אומר לעשות את זה.

501
00:23:46,320 --> 00:23:47,500
להדפיס את זה.

502
00:23:47,500 --> 00:23:51,860
אז קדימה ולקבל n--
לקבל int ולאחסן אותו בn,

503
00:23:51,860 --> 00:23:55,760
ולהמשיך לעשות את זה שוב ושוב ו
שוב, כל עוד n הוא פחות מאחוז אחד.

504
00:23:55,760 --> 00:23:58,720
>> אז n הולך להיות פחות מאחד
רק אם האדם לא משתף פעולה.

505
00:23:58,720 --> 00:24:01,980
אם הוא או היא היא להקליד
ב0 או -1 או -50,

506
00:24:01,980 --> 00:24:04,790
לולאה זה הולכת לשמור
ביצוע שוב ושוב.

507
00:24:04,790 --> 00:24:07,549
וסופו של דבר שמתי לב, אני
פשוט להחזיר את הערך.

508
00:24:07,549 --> 00:24:09,590
אז עכשיו יש לנו פונקציה
כי כבר היה נחמד

509
00:24:09,590 --> 00:24:14,040
אם CS50 היה ליישם ב
CS50.h וCS50.c בשבילך,

510
00:24:14,040 --> 00:24:16,520
אבל כאן אנחנו יכולים עכשיו
ליישם את זה לעצמנו.

511
00:24:16,520 --> 00:24:19,230
>> אבל שתי הערות על כמה פרטים חשובים.

512
00:24:19,230 --> 00:24:24,390
One-- למה אני מצהיר int
n, אתה חושב ש, על קו 29

513
00:24:24,390 --> 00:24:27,139
במקום רק עושה
זה כאן, שהוא

514
00:24:27,139 --> 00:24:28,930
מתיישב יותר עם
מה שעשינו בשבוע שעבר?

515
00:24:28,930 --> 00:24:29,430
כן?

516
00:24:29,430 --> 00:24:34,485

517
00:24:34,485 --> 00:24:35,110
מחשבה טובה.

518
00:24:35,110 --> 00:24:37,080
אז אם היינו לשים את זה
כאן, זה כאילו שאנחנו

519
00:24:37,080 --> 00:24:39,110
לשמור הכריז עליו שוב ושוב.

520
00:24:39,110 --> 00:24:42,000
שבפני עצמו הוא
לא בעייתי, כשלעצמה,

521
00:24:42,000 --> 00:24:43,940
כי אנחנו צריכים רק
הערך פעם אחת ולאחר מכן

522
00:24:43,940 --> 00:24:45,330
אנחנו הולכים לקבל אחד חדש בכל מקרה.

523
00:24:45,330 --> 00:24:45,940
אבל מחשבה טובה.

524
00:24:45,940 --> 00:24:46,440
כן?

525
00:24:46,440 --> 00:24:52,770

526
00:24:52,770 --> 00:24:53,330
>> לסגור.

527
00:24:53,330 --> 00:24:59,030
אז בגלל שאני כבר הכריז n על
שורה 29 מחוץ ללולאה,

528
00:24:59,030 --> 00:25:01,390
זה נגיש בכל רחבי
כל פונקציה זו.

529
00:25:01,390 --> 00:25:05,400
לא פונקציות אחרות כי
n הוא עדיין בתוך מתולתל אלה

530
00:25:05,400 --> 00:25:06,470
פלטות כאן.

531
00:25:06,470 --> 00:25:07,940
So-- בטוח.

532
00:25:07,940 --> 00:25:12,430

533
00:25:12,430 --> 00:25:12,940
>> בדיוק.

534
00:25:12,940 --> 00:25:14,356
אז זה עוד יותר לנקודה.

535
00:25:14,356 --> 00:25:18,600
אם אנחנו במקום שהוכרזו
n ממש כאן על קו 32,

536
00:25:18,600 --> 00:25:22,340
זה בעייתי כי ניחוש
איפה עוד אני צריך לגשת אליו?

537
00:25:22,340 --> 00:25:25,620
על קו 34, ו
כלל אצבע פשוט הוא

538
00:25:25,620 --> 00:25:30,060
כי אתה יכול להשתמש רק משתנה
בתוך הסוגריים המסולסלים האחרונים

539
00:25:30,060 --> 00:25:31,420
שבו אתה הכריז עליה.

540
00:25:31,420 --> 00:25:35,230
>> למרבה הצער, שורה 34
היא שורה אחת מאוחר מדי,

541
00:25:35,230 --> 00:25:38,560
כי אני כבר סגור
הסד המתולתל על קו 33

542
00:25:38,560 --> 00:25:41,220
שמתאים ל
סד מתולתל על קו 30.

543
00:25:41,220 --> 00:25:44,180
ואז זה דרך לומר
שint משתנה זה scoped,

544
00:25:44,180 --> 00:25:46,970
אם אפשר לומר כך, רק בתוך
של סוגריים המסולסלים אלה.

545
00:25:46,970 --> 00:25:48,910
זה פשוט לא קיים מחוץ להם.

546
00:25:48,910 --> 00:25:51,580
>> אז אכן, אם אני עושה את זה
בסדר, תן לי לשמור את הקוד

547
00:25:51,580 --> 00:25:53,530
כפי שis-- באופן שגוי שנכתב.

548
00:25:53,530 --> 00:25:57,990
תן לי ללכת קדימה ועושים
פונקציה-1, ושגיאת notice--.

549
00:25:57,990 --> 00:26:03,502
שימוש בn מזהה לא מוצהר
על קו 35, שנמצא ממש כאן.

550
00:26:03,502 --> 00:26:05,210
ואם אנחנו לגלול מעלה
נוסף, עוד אחד.

551
00:26:05,210 --> 00:26:08,750
שימוש בלא מוצהר
n מזהה על קו 34.

552
00:26:08,750 --> 00:26:11,200
>> אז מהדר, קלאנג,
הוא שם לב שזה פשוט

553
00:26:11,200 --> 00:26:13,720
לא קיימת למרות ש
ברור שהוא שם מבחינה ויזואלית.

554
00:26:13,720 --> 00:26:16,090
אז פשוט לתקן מכריז אותו שם.

555
00:26:16,090 --> 00:26:18,790
>> עכשיו תנו לי לגלול ל
החלק העליון של הקובץ.

556
00:26:18,790 --> 00:26:21,080
מה קופץ עליך כ
להיות קצת שונה

557
00:26:21,080 --> 00:26:23,070
מהדברים שאנחנו נראים בשבוע שעבר?

558
00:26:23,070 --> 00:26:26,990
יש לי שם, לא רק לעשות לא רק
יש לי קצת חד כולל למעלה,

559
00:26:26,990 --> 00:26:29,340
יש לי משהו שאני
קורא אב טיפוס.

560
00:26:29,340 --> 00:26:36,100
עכשיו זה נראה נורא דומה למה ש
ראינו רק לפני רגע על קו 27.

561
00:26:36,100 --> 00:26:39,230
>> אז בואו להסיק משונה
הודעת שגיאה למה עשיתי את זה.

562
00:26:39,230 --> 00:26:42,050
תן לי ללכת קדימה ו
למחוק את השורות האלה יש.

563
00:26:42,050 --> 00:26:44,240
וכך אנו לא יודעים כלום על אב טיפוס.

564
00:26:44,240 --> 00:26:45,430
מהדורה מחודשת בקובץ זה.

565
00:26:45,430 --> 00:26:46,890
הפוך פונקציה אחת.

566
00:26:46,890 --> 00:26:48,090
ועכשיו, לעזאזל, ארבע שגיאות.

567
00:26:48,090 --> 00:26:50,220
בואו לגלול עד ראשון.

568
00:26:50,220 --> 00:26:55,070
>> הצהרה סמויה של פונקציה
לקבל int החיובי הוא לא חוקי בC99.

569
00:26:55,070 --> 00:26:57,780
C99 רק אומר 1999
גרסה של השפה

570
00:26:57,780 --> 00:26:59,710
C, וזה מה שאנחנו משתמשים אכן.

571
00:26:59,710 --> 00:27:01,050
אז מה זה אומר?

572
00:27:01,050 --> 00:27:05,250
ובכן C-- ובאופן ספציפי יותר C
compilers-- תוכניות די טפשים.

573
00:27:05,250 --> 00:27:07,420
הם יודעים רק את מה שיש לך
אמר להם, וזה

574
00:27:07,420 --> 00:27:08,960
נושאיות למעשה משבוע שעבר.

575
00:27:08,960 --> 00:27:12,910
>> הבעיה היא שאם אני הולך
על יישום שם עד כאן,

576
00:27:12,910 --> 00:27:17,640
ואני קורא לפונקציה שנקראת
GetPositiveInt כאן על קו 20,

577
00:27:17,640 --> 00:27:22,520
הפונקציה שעושה מבחינה טכנית לא
קיימים עד מהדר רואה שורה 27.

578
00:27:22,520 --> 00:27:25,450
לרוע המזל, מהדר הוא
עושה דברים העליונים, למטה, שמאלה, ימינה,

579
00:27:25,450 --> 00:27:29,580
כך משום שהוא לא ראה את
יישום GetPositiveInt,

580
00:27:29,580 --> 00:27:32,400
אבל זה רואה אותך מנסה
כדי להשתמש בו עד כאן,

581
00:27:32,400 --> 00:27:35,810
זה פשוט הולך bail-- לצעוק על
אולי לך עם שגיאת message--

582
00:27:35,810 --> 00:27:38,440
נסתר, ולא ממש
לקמפל את הקובץ.

583
00:27:38,440 --> 00:27:41,940
>> אז אב טיפוס עד שנקרא
כאן הוא אמנם מיותר.

584
00:27:41,940 --> 00:27:47,870
פשוטו כמשמעו, הלכתי לכאן והעתקתי
ולהדביק את זה, ואני אשים אותה כאן.

585
00:27:47,870 --> 00:27:51,020
Void יהיה נכון יותר, כך יהיו לנו
פשוטו כמשמעו להעתיק ולהדביק את זה הפעם.

586
00:27:51,020 --> 00:27:52,854
אני ממש להעתיק ולהדביק אותו.

587
00:27:52,854 --> 00:27:54,270
באמת רק ככמו פירור לחם.

588
00:27:54,270 --> 00:27:56,260
>> רמז קטן למהדר.

589
00:27:56,260 --> 00:27:58,860
אני לא יודע מה זה עושה
עדיין, אבל אני מבטיח לך

590
00:27:58,860 --> 00:28:00,260
שזה יהיה קיים סופו של דבר.

591
00:28:00,260 --> 00:28:04,010
וזה למה זה line-- ב
שורת 16-- מסתיימת בנקודת פסיק.

592
00:28:04,010 --> 00:28:05,486
זה מיותר על ידי עיצוב.

593
00:28:05,486 --> 00:28:05,986
כן?

594
00:28:05,986 --> 00:28:11,340

595
00:28:11,340 --> 00:28:14,360
>> אם לא לקשר את הספרייה שלך
לthe-- הו, שאלה טובה.

596
00:28:14,360 --> 00:28:17,350
שארפ כולל תכלילים קובץ הכותרת.

597
00:28:17,350 --> 00:28:20,040
צריך be-- צריך כמעט
תמיד להיות בחלקו העליון

598
00:28:20,040 --> 00:28:23,270
של הקובץ לsimilar-- ל
בדיוק מאותה הסיבה, כן.

599
00:28:23,270 --> 00:28:26,430
מכיוון שבתקן
io.h הוא, פשוטו כמשמעו, קו

600
00:28:26,430 --> 00:28:30,560
כמו זה, אבל עם המילה printf, ו
עם הטיעונים שלה וטיפוס ההחזרה שלה.

601
00:28:30,560 --> 00:28:33,310
וזאת על ידי עושה חד לכלול עד
כאן, מה שאתה ממש עושה

602
00:28:33,310 --> 00:28:36,380
הוא העתקה והדבקה של התוכן
של מישהו אחר כתב למעלה.

603
00:28:36,380 --> 00:28:39,660
כך cluing את הקוד שלך ל
עובדה שפונקציות אלה אכן קיימות.

604
00:28:39,660 --> 00:28:40,160
כן?

605
00:28:40,160 --> 00:28:47,520

606
00:28:47,520 --> 00:28:48,260
>> בהחלט.

607
00:28:48,260 --> 00:28:51,690
אז מאוד חכם ונכון
פתרון יהיה, אתה יודע מה?

608
00:28:51,690 --> 00:28:53,760
אני לא יודע מה
אב טיפוס הוא, אבל אני יודע ש

609
00:28:53,760 --> 00:28:56,390
אם אני מבין את זה C הוא רק
מטומטם וrethinks מלמעלה למטה.

610
00:28:56,390 --> 00:28:57,820
ובכן בואו לתת לו מה שהוא רוצה.

611
00:28:57,820 --> 00:29:01,650
בואו לחתוך קוד ש, להדביק אותו
עליון, ועכשיו לדחוף עיקרי למטה.

612
00:29:01,650 --> 00:29:03,470
גם זה יפתור את הבעיה.

613
00:29:03,470 --> 00:29:07,409
>> אבל אתה יכול מאוד בקלות לבוא עם
תרחיש שבו צריך לקרוא ב ',

614
00:29:07,409 --> 00:29:10,075
ואולי B מתקשר בחזרה לא זה
הוא משהו שנקרא רקורסיה,

615
00:29:10,075 --> 00:29:11,370
ואנחנו נחזור לזה.

616
00:29:11,370 --> 00:29:13,911
וזה יכול או לא יכול להיות טוב
דבר, אבל אתה בהחלט יכול

617
00:29:13,911 --> 00:29:15,110
לשבור את הפתרון הזה.

618
00:29:15,110 --> 00:29:17,690
>> ויותר מכך, הייתי
טוען סגנונית,

619
00:29:17,690 --> 00:29:20,760
במיוחד כאשר התוכניות שלך
להיות כל כך הרבה זמן וכל כך הרבה זמן,

620
00:29:20,760 --> 00:29:23,064
זה פשוט סופר נוח
לשים ראשי בחלק העליון

621
00:29:23,064 --> 00:29:25,730
כי זה הדבר הכי
מתכנתים הולכים אכפת.

622
00:29:25,730 --> 00:29:28,150
ואז זה קצת יותר נקי,
ניתן לטעון, לעשות את זה בדרך

623
00:29:28,150 --> 00:29:30,380
אני במקור עשיתי את זה
עם אב טיפוס אפילו

624
00:29:30,380 --> 00:29:33,396
למרות שזה נראה קצת
מיותר במבט ראשון.

625
00:29:33,396 --> 00:29:33,895
כן?

626
00:29:33,895 --> 00:29:36,472

627
00:29:36,472 --> 00:29:37,680
מצטער, אתה יכול להגיד את זה בקול רם?

628
00:29:37,680 --> 00:29:45,650

629
00:29:45,650 --> 00:29:49,580
>> אם תעבור את מיקומם של
יישום ואב הטיפוס?

630
00:29:49,580 --> 00:29:51,270
כך שזו שאלה טובה.

631
00:29:51,270 --> 00:29:53,780
אם אתה מחדש להכריז על זה למטה
כאן, בואו לראות מה קורה.

632
00:29:53,780 --> 00:29:55,530
אז אם אני מניח את זה
כאן, אתה אומר.

633
00:29:55,530 --> 00:29:57,860

634
00:29:57,860 --> 00:29:58,360
אה, סליחה.

635
00:29:58,360 --> 00:29:58,859
בקול רם יותר?

636
00:29:58,859 --> 00:30:02,000

637
00:30:02,000 --> 00:30:04,011
אפילו בקול רם יותר.

638
00:30:04,011 --> 00:30:04,760
אה, שאלה טובה.

639
00:30:04,760 --> 00:30:05,860
האם זה יבטל את הפונקציה?

640
00:30:05,860 --> 00:30:08,901
אתה יודע, אחרי כל השנים האלה, אני
מעולם לא הכניס את אב טיפוס לאחר מכן.

641
00:30:08,901 --> 00:30:13,810
אז בואו לעשות לעשות פונקציה-1
אחרי עושה את זה.

642
00:30:13,810 --> 00:30:15,279
>> [ממלמל]

643
00:30:15,279 --> 00:30:16,320
דוד י מלאן: אה, רגע.

644
00:30:16,320 --> 00:30:17,944
עדיין יש לנו לשים את הכל למעלה.

645
00:30:17,944 --> 00:30:21,400
אז בואו נעשה את זה כאן, אם אני
הבנת השאלה שלך בצורה נכונה.

646
00:30:21,400 --> 00:30:24,700
אני שם את הכל, כולל
אב הטיפוס מעל עיקרי,

647
00:30:24,700 --> 00:30:28,180
אבל אני שם את אב הטיפוס
מתחת ליישום.

648
00:30:28,180 --> 00:30:33,190
>> אז אם אני עושה אחד, אני מקבל
בחזרה n משתנה שאינו בשימוש error--.

649
00:30:33,190 --> 00:30:37,280

650
00:30:37,280 --> 00:30:37,860
אה, יש.

651
00:30:37,860 --> 00:30:38,360
תודה לך.

652
00:30:38,360 --> 00:30:39,430
בואו נראה, שנפטרנו מזה.

653
00:30:39,430 --> 00:30:41,304
זה באג שונה,
אז בואו נתעלם מכך.

654
00:30:41,304 --> 00:30:43,910
בואו באמת מחדש במהירות זו.

655
00:30:43,910 --> 00:30:48,100
>> אוקיי, אז ויכוח לא נתונים
בשימוש על ידי מחרוזת פורמט

656
00:30:48,100 --> 00:30:52,310
n-- הו, זה בגלל ש
שיניתי לאלה כאן.

657
00:30:52,310 --> 00:30:55,885
בסדר, אנחנו יודעים מה התשובה
הולך to-- בסדר, הנה זה באנו.

658
00:30:55,885 --> 00:31:00,560
אה, תודה על החיובית.

659
00:31:00,560 --> 00:31:03,430
בסדר, אני אסדר את הקוד הזה
after-- להתעלם באג המסוים הזה

660
00:31:03,430 --> 00:31:08,300
מאז זה was-- זה עובד הוא התשובה.

661
00:31:08,300 --> 00:31:11,560
>> אז זה לא לדרוס
מה בדיוק עשית.

662
00:31:11,560 --> 00:31:14,800
אני חושד מהדר
כתוב בצורה כזאת

663
00:31:14,800 --> 00:31:18,420
שהוא מתעלם מאב הטיפוס שלך
מכיוון שהגוף, אם אפשר לומר כך,

664
00:31:18,420 --> 00:31:20,922
של הפונקציה יש כבר
יושם עד גבוה.

665
00:31:20,922 --> 00:31:23,380
הייתי צריך להתייעץ למעשה
המדריך של המהדר

666
00:31:23,380 --> 00:31:26,171
כדי להבין אם יש אחר
משמעות, אבל במבט הראשון

667
00:31:26,171 --> 00:31:29,290
רק על ידי מנסה ומתנסים,
נראה שיש לא הייתה השפעה.

668
00:31:29,290 --> 00:31:30,730
שאלה טובה.

669
00:31:30,730 --> 00:31:33,660
>> אז בואו לפרוץ קדימה עכשיו, נעו
מתופעות לוואי ש

670
00:31:33,660 --> 00:31:36,660
הן פונקציות שעושות דבר כזה
מבחינה ויזואלית על המסך עם printf,

671
00:31:36,660 --> 00:31:38,090
אבל לא מחזיר ערך.

672
00:31:38,090 --> 00:31:41,550
ויש פונקציות שתמורה
ערכים כמו שרק ראו כמה.

673
00:31:41,550 --> 00:31:45,350
אנחנו כבר ראינו את המושג הזה של היקף,
ואנו רואים את זה שוב ושוב.

674
00:31:45,350 --> 00:31:47,210
אבל לעת עתה, שוב,
להשתמש כלל אצבע

675
00:31:47,210 --> 00:31:51,410
שמשתנה יכול לשמש רק
בתוך נפתח לאחרונה

676
00:31:51,410 --> 00:31:54,350
וסוגריים מסולסלים סגורים כפי שאנו
ראה בדוגמא מסוימת ש.

677
00:31:54,350 --> 00:31:56,910
>> וכפי שציינת,
יש ability--

678
00:31:56,910 --> 00:32:00,040
אתה יכול לפתור חלק מבעיות אלה
על ידי הצבת משתנה ברחבי העולם

679
00:32:00,040 --> 00:32:01,290
בחלקו העליון של קובץ.

680
00:32:01,290 --> 00:32:03,630
אבל כמעט בכל המקרים
היינו זעפתי על ש,

681
00:32:03,630 --> 00:32:06,170
ואפילו אכן לא ללכת
לפתרון כי לעת עתה.

682
00:32:06,170 --> 00:32:09,890
אז לעת עתה, טייק אוויי היא ש
יש לי משתנים רעיון זה של היקף.

683
00:32:09,890 --> 00:32:13,430
>> אבל עכשיו בואו נסתכל על עוד
דרך יבשה של מחפש למעשה

684
00:32:13,430 --> 00:32:15,810
בחלק מעניין למדי
פרטי יישום.

685
00:32:15,810 --> 00:32:17,810
איך אנחנו יכולים לייצג מידע.

686
00:32:17,810 --> 00:32:20,370
ואנחנו כבר הסתכלנו על זה
בשבוע של המחלקה הראשונה.

687
00:32:20,370 --> 00:32:23,320
כאשר מסתכל על קבצים בינאריים, ו
להזכיר לעצמנו של עשרוני.

688
00:32:23,320 --> 00:32:28,310
>> אבל זוכר משבוע שעבר שC יש
סוגי נתונים שונים ואשכולות יותר,

689
00:32:28,310 --> 00:32:30,600
אבל השימושי ביותר
לעת עתה עשוי להיות אלה.

690
00:32:30,600 --> 00:32:36,030
Char, או אופי, וזה קורה
להיות בית אחד, או בסך הכל פיסות שמונה.

691
00:32:36,030 --> 00:32:40,060
וזה אומר שהגודל
של char הוא רק בית אחד.

692
00:32:40,060 --> 00:32:45,370
בתים הוא שמונה סיביות, ולכן זה אומר ש
אנחנו יכולים לייצג תווים כמה.

693
00:32:45,370 --> 00:32:47,320
כמה אותיות או
סימנים במקלדת

694
00:32:47,320 --> 00:32:49,210
אם יש לנו בית אחד או שמונה סיביות.

695
00:32:49,210 --> 00:32:51,546
היזכר בשבוע שאפס.

696
00:32:51,546 --> 00:32:53,420
אם יש לך שמונה סיביות,
כמה ערכים מוחלט

697
00:32:53,420 --> 00:32:55,503
אתה יכול לייצג עם
דפוסים של אפסים ואחדים?

698
00:32:55,503 --> 00:32:58,170

699
00:32:58,170 --> 00:33:00,260
One-- יותר מזה.

700
00:33:00,260 --> 00:33:03,490
אז 256 סך הכל אם אתה
תתחיל לספור מאפס.

701
00:33:03,490 --> 00:33:07,120
אז אם יש לך שמונה bits-- כך שאם אנחנו
היה לי הנורות בינארי שלנו כאן שוב,

702
00:33:07,120 --> 00:33:12,180
אנחנו יכולים להפוך את הנורות אלה על
ואת בכל 256 דפוסים ייחודיים.

703
00:33:12,180 --> 00:33:13,640
>> עכשיו זה קצת בעייתי.

704
00:33:13,640 --> 00:33:16,857
לא כל כך הרבה לאנגלית ו
שפות רומנטיקה, אבל בהחלט

705
00:33:16,857 --> 00:33:19,190
כאשר אתה מציג, ל
למשל, שפות אסיאניות, ש

706
00:33:19,190 --> 00:33:22,580
יש הרבה יותר סימנים מאשר כמו
26 אותיות האלפבית.

707
00:33:22,580 --> 00:33:24,390
אנחנו בעצם אולי צריכים
יותר מ ייט אחד.

708
00:33:24,390 --> 00:33:28,240
ותודה לאל ב
יש שנים האחרונות חברה

709
00:33:28,240 --> 00:33:31,040
סטנדרטים אחרים אימצו המשתמשים
בתים יותר מפעם אחת לכל תשלום.

710
00:33:31,040 --> 00:33:34,210
>> אבל לעת עתה בC, ברירת המחדל
רק בית אחד או שמונה סיביות.

711
00:33:34,210 --> 00:33:38,195
שלם, בינתיים, הוא ארבעה
בתים, הידוע גם ב32 סיביות.

712
00:33:38,195 --> 00:33:41,320
מה שאומר מה הגדול ביותר האפשרי
מספר שאנחנו יכולים לייצג עם int

713
00:33:41,320 --> 00:33:41,820
ככל הנראה?

714
00:33:41,820 --> 00:33:44,426

715
00:33:44,426 --> 00:33:45,050
עם מיליארדים.

716
00:33:45,050 --> 00:33:46,760
אז זה ארבעה מיליארדים פחות או יותר.

717
00:33:46,760 --> 00:33:49,840
2 בחזקת 32th, אם
תניח שלא מספרים שליליים

718
00:33:49,840 --> 00:33:52,530
ורק להשתמש בכל חיובי
מספרים, שזה ארבעה מליארד

719
00:33:52,530 --> 00:33:53,730
לתת או לקחת אפשרויות.

720
00:33:53,730 --> 00:33:57,890
לצוף, בינתיים, הוא סוג שונה
מסוג הנתונים ב C. זה עדיין מספר,

721
00:33:57,890 --> 00:33:58,990
אבל זה מספר אמיתי.

722
00:33:58,990 --> 00:34:00,660
משהו עם נקודה עשרונית.

723
00:34:00,660 --> 00:34:03,000
ומתברר ש
C גם משתמש בארבעה בתים

724
00:34:03,000 --> 00:34:05,340
לייצג ערכי נקודה צפו.

725
00:34:05,340 --> 00:34:09,420
>> לרוע המזל כמה צף
ערכי נקודה יש ​​בעולם?

726
00:34:09,420 --> 00:34:11,582
כמה מספרים ממשיים יש?

727
00:34:11,582 --> 00:34:13,540
יש אינסוף
מספר, ולצורך עניין

728
00:34:13,540 --> 00:34:15,164
יש מספר אינסופי של מספרים שלמים.

729
00:34:15,164 --> 00:34:18,070
אז אנחנו כבר סוג של
לחפור לעצמנו בור כאן.

730
00:34:18,070 --> 00:34:21,780
לפי הנראה בcomputers-- ב
תוכניות לפחות נכתבו בC ב them--

731
00:34:21,780 --> 00:34:24,110
רק יכול לסמוך גבוה ככל
ארבעה מיליארדים פחות או יותר,

732
00:34:24,110 --> 00:34:26,260
וערכי נקודה צפה
רק יכול, ככל הנראה,

733
00:34:26,260 --> 00:34:28,330
יש כמות סופית של דיוק.

734
00:34:28,330 --> 00:34:30,810
רק ספרות כל כך הרבה אחרי
הנקודה העשרונית שלהם.

735
00:34:30,810 --> 00:34:32,822
>> כי, כמובן, אם
יש לך רק 32 סיביות,

736
00:34:32,822 --> 00:34:36,030
אני לא יודע איך אנחנו הולכים ללכת על
מייצג אחר מספרים אמיתיים כנראה

737
00:34:36,030 --> 00:34:37,409
עם סוגים שונים של דפוסים.

738
00:34:37,409 --> 00:34:40,030
אבל יש בוודאי סופי
מספר הדפוסים כאלה,

739
00:34:40,030 --> 00:34:41,830
אז הנה, גם זה בעייתי.

740
00:34:41,830 --> 00:34:43,710
>> עכשיו אנחנו יכולים למנוע את הבעיה במקצת.

741
00:34:43,710 --> 00:34:45,710
אם אתה לא משתמש במצוף,
אתה יכול להשתמש כפול

742
00:34:45,710 --> 00:34:50,230
בC, אשר נותן לך שמונה בתים, ש
הוא דרך עוד דפוסים אפשריים של אפסים

743
00:34:50,230 --> 00:34:50,730
ואלה.

744
00:34:50,730 --> 00:34:55,199
אבל זה עדיין סופי, שהוא הולך
להיות בעייתי אם אתה כותב תוכנה

745
00:34:55,199 --> 00:34:57,670
לגרפיקה או למפואר
נוסחות מתמטיות.

746
00:34:57,670 --> 00:35:00,410
אז ייתכן שבאמת רוצה
לספור עד יותר גדול מזה.

747
00:35:00,410 --> 00:35:05,640
Named-- ארוך long-- טיפשות
גם שמונה בתים, או 64 סיביות,

748
00:35:05,640 --> 00:35:10,260
וזה פעמיים כל עוד int,
וזה למספר שלם ארוך.

749
00:35:10,260 --> 00:35:15,655
>> fact-- כיף אם int הוא ארבעה בתים,
כמה זמן הוא ארוך בC בדרך כלל?

750
00:35:15,655 --> 00:35:18,290

751
00:35:18,290 --> 00:35:21,560
גם ארבעה בתים, אבל
ארוך ארוך הוא שמונה בתים,

752
00:35:21,560 --> 00:35:23,050
וזה מסיבות היסטוריות.

753
00:35:23,050 --> 00:35:26,450
>> אבל האוכל המוכן עכשיו
רק יש לו נתונים ש

754
00:35:26,450 --> 00:35:29,625
להיות מיוצג בcomputer-- זה
מכשיר פיזי עם חשמל,

755
00:35:29,625 --> 00:35:32,190
זה בדרך כלל נוהג
אלה אפסים וones--

756
00:35:32,190 --> 00:35:34,320
עם כמויות מוגבלת של דיוק.

757
00:35:34,320 --> 00:35:35,620
אז מה הבעיה אם כך?

758
00:35:35,620 --> 00:35:37,480
>> ובכן יש בעיה
של גלישת מספר שלם.

759
00:35:37,480 --> 00:35:39,780
לא רק בC, אבל ב
מחשבים באופן כללי.

760
00:35:39,780 --> 00:35:42,590
לדוגמא, אם זה
הוא בתים בשווי bit--

761
00:35:42,590 --> 00:35:45,120
כך שאם זה שמונה כל bit--
מהם המספר אחד.

762
00:35:45,120 --> 00:35:47,300
מה מספר זה
מייצג אם נניח

763
00:35:47,300 --> 00:35:50,730
זה כל הערכים החיוביים בינארי?

764
00:35:50,730 --> 00:35:54,410
>> 255, וזה לא 256, כי
אפס הוא המספר הנמוך ביותר.

765
00:35:54,410 --> 00:35:56,760
אז 255 הוא הגבוהים ביותר
אחד, אבל הבעיה

766
00:35:56,760 --> 00:36:00,330
הוא מניח שאני רוצה
להגדיל משתנה זה ש

767
00:36:00,330 --> 00:36:04,030
משתמש שמונה סיביות יסתכם
אם אני רוצה להגדיל אותו.

768
00:36:04,030 --> 00:36:07,160
>> ובכן ברגע שאני מוסיף
אחד לכל אלה אלה,

769
00:36:07,160 --> 00:36:10,500
אולי אתה יכול לדמיין visually-- רק
כמו שנשא את אחד באמצעות decimals--

770
00:36:10,500 --> 00:36:12,300
משהו הולך לזרום לשמאל.

771
00:36:12,300 --> 00:36:15,590
ואכן, אם אני מוסיף את המספר
אחד לזה, מה שקורה בינארי

772
00:36:15,590 --> 00:36:17,670
הוא שזה עולה על גדותיו בחזרה לאפס.

773
00:36:17,670 --> 00:36:21,730
>> אז אם אתה use-- לא רק int,
אבל לבית אחד לספור מספרים שלמים

774
00:36:21,730 --> 00:36:27,170
בתכנית, על ידי default-- בהקדם
אתה מקבל 250, 251, 252, 253, 254,

775
00:36:27,170 --> 00:36:32,710
255-- 0 מגיע לאחר 255,
שהוא כנראה לא מה ש

776
00:36:32,710 --> 00:36:34,790
משתמש הוא הולך לצפות.

777
00:36:34,790 --> 00:36:39,620
>> עכשיו בינתיים בצפתי עולם נקודה,
גם יש לך בעיה דומה.

778
00:36:39,620 --> 00:36:42,670
לא כל כך הרבה עם number-- הגדול
למרות שזה עדיין בעיה.

779
00:36:42,670 --> 00:36:45,360
אבל עם הכמות של דיוק
שאתה יכול לייצג.

780
00:36:45,360 --> 00:36:49,490
אז בואו נסתכל על דוגמא זו
כאן גם מcode-- המקור של היום

781
00:36:49,490 --> 00:36:52,070
לצוף-0.c.

782
00:36:52,070 --> 00:36:54,280
>> ותשים לב שזה סופר
תכנית פשוטה ש

783
00:36:54,280 --> 00:36:56,580
כנראה צריך להדפיס את מה הערך?

784
00:36:56,580 --> 00:37:00,777

785
00:37:00,777 --> 00:37:04,110
מה אתה מתערב זה הולך להדפיס
אף על פי שיש קצת של תחביר החדש

786
00:37:04,110 --> 00:37:05,540
כאן?

787
00:37:05,540 --> 00:37:06,700
אז אני מקווה 0.1.

788
00:37:06,700 --> 00:37:10,000
אז המקביל של עשירית
בגלל שאני עושה 1 מחולק ב10.

789
00:37:10,000 --> 00:37:12,430
אני אחסון התשובה
במשתנה שנקרא f.

790
00:37:12,430 --> 00:37:15,850
משתנים זה של הטיפוס float, ש
הוא מילת מפתח אני רק הצעתי היה קיים.

791
00:37:15,850 --> 00:37:18,910
>> אנחנו כבר לא ראינו את זה קודם, אבל
זה הוא סוג של דרך מסודרת בprintf

792
00:37:18,910 --> 00:37:22,110
כדי לציין ספרות כמה אתה
רוצה לראות אחרי נקודה עשרונית.

793
00:37:22,110 --> 00:37:25,020
אז סימון זה רק אומר
כי הנה מציין מיקום.

794
00:37:25,020 --> 00:37:27,900
זה לנקודה צפה
ערך, והו, דרך אגב,

795
00:37:27,900 --> 00:37:31,389
להראות את זה עם הנקודה העשרונית עם
מספר אחד אחרי הנקודה העשרונית.

796
00:37:31,389 --> 00:37:33,180
אז זה המספר
של ספרות משמעותית,

797
00:37:33,180 --> 00:37:34,650
אם אפשר לומר כך, כי ייתכן שתרצו.

798
00:37:34,650 --> 00:37:40,450
>> אז תן לי ללכת ולעשות
להפוך את מצוף-0, ./float-0,

799
00:37:40,450 --> 00:37:46,660
וככל הנראה 1 מחולק ב10 הוא 0.0.

800
00:37:46,660 --> 00:37:47,760
עכשיו למה זה?

801
00:37:47,760 --> 00:37:51,380
>> ובכן שוב, המחשב הוא לוקח
לי באופן מילולי, ואני כתבתי 1

802
00:37:51,380 --> 00:37:56,680
ואני כתבתי 10, ולקחת ניחוש מה
הוא סוג הנתונים הניח לשני אלה

803
00:37:56,680 --> 00:37:58,440
ערכים?

804
00:37:58,440 --> 00:38:00,970
Int, זה מבחינה טכנית
משהו קצת שונה.

805
00:38:00,970 --> 00:38:04,150
זה בדרך כלל זמן רב, אבל זה
סופו של דבר ערך נפרד.

806
00:38:04,150 --> 00:38:06,030
לא ערך נקודה צפה.

807
00:38:06,030 --> 00:38:09,456
>> כלומר שאם זה
הוא int וזה int,

808
00:38:09,456 --> 00:38:11,830
הבעיה היא שהמחשב
אין לו את היכולת

809
00:38:11,830 --> 00:38:13,680
אפילו לאחסון שנקודה עשרונית.

810
00:38:13,680 --> 00:38:16,430
לכן, כאשר אתה עושה 1 מחולק
על ידי 10 מספרים שלמים באמצעות

811
00:38:16,430 --> 00:38:20,950
עבור שניהם המונה ו
מכנה, התשובה צריכה להיות 0.1.

812
00:38:20,950 --> 00:38:24,930
אבל computer-- כי
אלה הם integers--

813
00:38:24,930 --> 00:38:27,430
לא יודע מה לעשות עם 0.1.

814
00:38:27,430 --> 00:38:30,010
>> אז מה הוא עושה בצורה ברורה?

815
00:38:30,010 --> 00:38:33,120
זה פשוט לזרוק אותו,
ומה שאני רואה סופו של דבר

816
00:38:33,120 --> 00:38:38,830
הוא 0.0 רק מפני שהתעקשתי ש
printf להראות לי נקודה עשרונית אחת.

817
00:38:38,830 --> 00:38:41,740
אבל הבעיה היא שאם אתה
לחלק מספר שלם על ידי מספר שלם,

818
00:38:41,740 --> 00:38:44,347
אתה get-- על ידי הגדרה
של C-- מספר שלם.

819
00:38:44,347 --> 00:38:46,680
וזה לא הולך לעשות
משהו נחמד ובנוחות

820
00:38:46,680 --> 00:38:49,040
כמו עגול עד שזה
הקרוב ביותר אחד למעלה או למטה.

821
00:38:49,040 --> 00:38:51,860
זה הולך לחתוך
כל מה שאחרי הנקודה העשרונית.

822
00:38:51,860 --> 00:38:54,030
>> אז רק באופן אינטואיטיבי,
מה כנראה לתקן?

823
00:38:54,030 --> 00:38:55,351
מה התיקון הפשוט כאן?

824
00:38:55,351 --> 00:38:55,850
כן?

825
00:38:55,850 --> 00:39:00,570

826
00:39:00,570 --> 00:39:01,100
בדיוק.

827
00:39:01,100 --> 00:39:04,200
למה אנחנו לא פשוט לטפל באלה כ
ערכי נקודה צפה ביעילות

828
00:39:04,200 --> 00:39:05,860
להפוך אותם לצף או זוגות.

829
00:39:05,860 --> 00:39:10,500
ועכשיו אם אני עושה לעשות צף-0,
או אם אני לקמפל צף-1,

830
00:39:10,500 --> 00:39:12,570
שהוא זהה ל
מה בדיוק הוצע.

831
00:39:12,570 --> 00:39:16,400
ועכשיו אני עושה צף-0, עכשיו אני מקבל 0.1 שלי.

832
00:39:16,400 --> 00:39:17,234
>> עכשיו זה מדהים.

833
00:39:17,234 --> 00:39:19,441
אבל עכשיו אני הולך לעשות
משהו קצת שונה.

834
00:39:19,441 --> 00:39:22,280
אני סקרן לראות מה באמת
קורה מתחת למכסת המנוע,

835
00:39:22,280 --> 00:39:26,050
ואני מתכוון לפרסם את זה
אל 28 מקומות אחרי הנקודה העשרונית.

836
00:39:26,050 --> 00:39:29,730
אני באמת רוצה לראות
0.1000-- infinite--

837
00:39:29,730 --> 00:39:32,710
27 אפסים [לא ברור] לאחר 0.1 ש.

838
00:39:32,710 --> 00:39:34,740
>> ובכן, הבה נראה אם ​​זה
מה שאני אכן אקבל.

839
00:39:34,740 --> 00:39:39,430
הפוך צף-0 אותו קובץ.

840
00:39:39,430 --> 00:39:41,150
./floats-0.

841
00:39:41,150 --> 00:39:44,380
בואו להתמקד על התשובה הדרמטית.

842
00:39:44,380 --> 00:39:49,980
כל הזמן הזה, אתה כבר חושב
1 מחולק ב10 הוא 10%, או 0.1.

843
00:39:49,980 --> 00:39:50,810
זה לא.

844
00:39:50,810 --> 00:39:53,210
לפחות עד כה כ
המחשב של מודאג.

845
00:39:53,210 --> 00:39:57,060
>> עכשיו why-- אישור, זה מלא
שקר 1 מחולק ב10 הוא 0.1.

846
00:39:57,060 --> 00:39:59,710
אבל why-- שאינו
האוכל המוכן היום.

847
00:39:59,710 --> 00:40:04,010
אז למה המחשב חושב,
שלא כמו כל אחד מאיתנו בחדר,

848
00:40:04,010 --> 00:40:06,870
ש1 מחולק ב10 הוא
למעשה כי ערך מטורף?

849
00:40:06,870 --> 00:40:10,620
מה המחשב עושה כנראה?

850
00:40:10,620 --> 00:40:12,490
מה זה?

851
00:40:12,490 --> 00:40:13,785
>> זה לא עולה על גדות, כשלעצמו.

852
00:40:13,785 --> 00:40:15,910
גלישה היא בדרך כלל כאשר
אתה עוטף את ערך.

853
00:40:15,910 --> 00:40:18,970
זה הנושא הזה של חוסר דיוק
בערך נקודה צפה

854
00:40:18,970 --> 00:40:22,220
שבו יש לך רק 32
או אולי אפילו 64 קצת.

855
00:40:22,220 --> 00:40:25,230
אבל אם יש אינסוף
מספר אחר מספרים אמיתיים

856
00:40:25,230 --> 00:40:27,940
מספרים עם נקודות עשרוניות
ומספרי thereafter-- בוודאי

857
00:40:27,940 --> 00:40:29,380
אתה לא יכול לייצג את כולם.

858
00:40:29,380 --> 00:40:32,870
אז המחשב נתן
שלנו את ההתאמה הקרובה ביותר

859
00:40:32,870 --> 00:40:37,090
לשווי זה יכול לייצג באמצעות ש
פיסות רבות הערך אני באמת רוצה,

860
00:40:37,090 --> 00:40:38,690
שהוא 0.1.

861
00:40:38,690 --> 00:40:40,685
>> למרבה הצער, אם אתה
להתחיל לעשות מתמטיקה, או שאתה

862
00:40:40,685 --> 00:40:44,360
להתחיל מעורב מיני צפים אלה
ערכי נקודה בprograms-- החשוב

863
00:40:44,360 --> 00:40:46,770
תוכנה פיננסית,
דבר software-- צבאי

864
00:40:46,770 --> 00:40:49,090
שבו תפיסה היא
די חשוב כנראה.

865
00:40:49,090 --> 00:40:51,520
ואתה מתחיל להוסיף
מספרים כמו זה, והתחלה

866
00:40:51,520 --> 00:40:54,050
פועל תוכנה ש
עם תשומות גדולות באמת

867
00:40:54,050 --> 00:40:56,890
או להרבה שעות או הרבה
של ימים או הרבה שנים,

868
00:40:56,890 --> 00:41:01,060
טעויות קטנטנות האלה
בוודאי יכול להוסיף למעלה לאורך זמן.

869
00:41:01,060 --> 00:41:04,252
>> עכשיו במאמר מוסגר, אם יש לך אי פעם
ראה סופרמן 3 או Office Space

870
00:41:04,252 --> 00:41:05,960
ואתם אולי זוכרים
איך החבר 'ה האלה גנב

871
00:41:05,960 --> 00:41:08,668
הרבה כסף מהמחשב שלהם
על ידי שימוש בערכי נקודה צפו

872
00:41:08,668 --> 00:41:11,290
והוספתי את קטן
שאריות, בתקווה שסרט

873
00:41:11,290 --> 00:41:12,390
עכשיו הגיוני יותר.

874
00:41:12,390 --> 00:41:14,930
זה מה שהם היו
רמזתי בסרט ההוא.

875
00:41:14,930 --> 00:41:16,710
העובדה שרוב
חברות לא היו נראות

876
00:41:16,710 --> 00:41:18,600
לאחר מספר מסוים
מקומות עשרוניים,

877
00:41:18,600 --> 00:41:20,009
אבל אלה הם שברים של סנט.

878
00:41:20,009 --> 00:41:22,550
אז אתה מתחיל להוסיף אותם,
אתה מתחיל לעשות הרבה כסף

879
00:41:22,550 --> 00:41:23,424
בחשבון הבנק שלך.

880
00:41:23,424 --> 00:41:25,160
אז זה שטח המשרד הסביר.

881
00:41:25,160 --> 00:41:28,220
>> עכשיו למרבה הצער מעבר
Office Space, יש

882
00:41:28,220 --> 00:41:31,794
כמה מטריד באופן לגיטימי
ואת השפעות משמעותיות

883
00:41:31,794 --> 00:41:33,710
של מיני אלה
החלטות עיצוב בסיסית,

884
00:41:33,710 --> 00:41:35,990
ואכן אחת הסיבות
אנו משתמשים C בקורס

885
00:41:35,990 --> 00:41:39,640
הוא כל כך שבאמת יש לך קרקע זה
עד הבנה של איך מחשבים לעבוד,

886
00:41:39,640 --> 00:41:42,440
איך תוכנה עובדת, ולא
לקחת שום דבר כמובן מאליו.

887
00:41:42,440 --> 00:41:45,820
>> ואכן, למרבה הצער, אפילו עם
כי הבנה בסיסית,

888
00:41:45,820 --> 00:41:47,370
אנו, בני האדם עושים טעויות.

889
00:41:47,370 --> 00:41:51,310
ומה שחשבתי שאני רוצה לחלוק הוא
וידאו שמונה דקות זה כאן נלקח

890
00:41:51,310 --> 00:41:56,980
מפרק פלאים מודרניים, שהוא
מופע חינוכי על איך דברים עובדים

891
00:41:56,980 --> 00:42:00,370
שמצייר שתי תמונות
מתי שימוש לא ראוי

892
00:42:00,370 --> 00:42:02,540
והבנה של
ערכי נקודה צפה

893
00:42:02,540 --> 00:42:05,610
הוביל לכמה משמעותי
תוצאות מצערות.

894
00:42:05,610 --> 00:42:06,363
בואו נסתכל.

895
00:42:06,363 --> 00:42:07,029
[וידאו השמעה]

896
00:42:07,029 --> 00:42:11,290
עכשיו 'אנחנו חוזרים ל" הנדסה
אסונות "בפלאים מודרניים.

897
00:42:11,290 --> 00:42:12,940
מחשבים.

898
00:42:12,940 --> 00:42:15,580
כולנו כבר למדנו לקבל את
בעיות לעתים קרובות מתסכלות ש

899
00:42:15,580 --> 00:42:20,960
הגעתי עם them-- באגים, וירוסים, ו
תוכנת glitches-- למחירים קטנים

900
00:42:20,960 --> 00:42:23,100
לשלם עבור הנוחות.

901
00:42:23,100 --> 00:42:27,770
אבל בהיי טק ובמהירות גבוהה
יישומים צבאיים ותכנית החלל,

902
00:42:27,770 --> 00:42:32,780
הבעיה הקטנה ביותר יכול
להיות מוגדל לאסון.

903
00:42:32,780 --> 00:42:38,880
>> ב -4 ביוני, 1996, מדענים מוכנים
כדי להפעיל רקטת Ariane 5 לא מאוישת.

904
00:42:38,880 --> 00:42:41,190
זה נשא מדעי
לווינים שנועדו

905
00:42:41,190 --> 00:42:44,570
להקים בדיוק איך
אינטראקציה של השדה המגנטי של כדור הארץ

906
00:42:44,570 --> 00:42:47,380
עם רוחות סולריות.

907
00:42:47,380 --> 00:42:50,580
הרקטה נבנתה עבור
סוכנות החלל האירופית,

908
00:42:50,580 --> 00:42:54,400
והמריא מהמתקן שלה
על החוף של גויאנה הצרפתית.

909
00:42:54,400 --> 00:42:57,520
>> הה כ -37 שניות לתוך
הטיסה, שהם ראשון

910
00:42:57,520 --> 00:42:59,070
משהו שם לב שהשתבש.

911
00:42:59,070 --> 00:43:02,240
כי החרירים היו מסתובבים
בדרך בה הם ממש לא צריכים.

912
00:43:02,240 --> 00:43:06,550
בסביבות 40 שניות לטיסה,
בבירור הרכב היה בצרות,

913
00:43:06,550 --> 00:43:08,820
ואז הם עשו
ההחלטה להרוס אותו.

914
00:43:08,820 --> 00:43:12,370
קצין הבטיחות, עם
אומץ אדיר, לחץ על הכפתור

915
00:43:12,370 --> 00:43:18,030
ופוצץ את הטיל לפני שהוא יכול
הפך סכנה לביטחון הציבור.

916
00:43:18,030 --> 00:43:21,010
>> -זהו היה הנעורים
מסע של 5 אריאן,

917
00:43:21,010 --> 00:43:23,920
וההרס שלה לקח
מקום בגלל הפגם

918
00:43:23,920 --> 00:43:25,932
משובץ בתוכנה של הרקטות.

919
00:43:25,932 --> 00:43:27,640
-The בעיה על
אריאן היה שיש

920
00:43:27,640 --> 00:43:30,500
היה מספר שנדרש
64 סיביות להביע,

921
00:43:30,500 --> 00:43:33,560
והם רצו להמיר
אותו למספר 16 סיביות.

922
00:43:33,560 --> 00:43:36,820
הם הניחו כי המספר
אף פעם לא היה הולך להיות גדול מאוד.

923
00:43:36,820 --> 00:43:40,940
שרוב הספרות אלה ב
מספר 64 סיביות היו אפסים.

924
00:43:40,940 --> 00:43:42,450
הם טעו.

925
00:43:42,450 --> 00:43:45,000
>> -The חוסר יכולת של אחד
תוכנה לקבל

926
00:43:45,000 --> 00:43:49,460
הסוג של מספר שנוצר על ידי
עוד היה בשורש הכישלון.

927
00:43:49,460 --> 00:43:54,260
פיתוח תוכנה נעשה
חלק מאוד יקר של טכנולוגיה חדשה.

928
00:43:54,260 --> 00:43:57,060
הייתה לי רקטת אריאן 4
היה מוצלח מאוד.

929
00:43:57,060 --> 00:44:01,600
כל כך הרבה מהתוכנה שנוצרה עבור
זה היה בשימוש גם באריאן 5.

930
00:44:01,600 --> 00:44:04,790
>> -The בעיה בסיסית
היה שאריאן 5.

931
00:44:04,790 --> 00:44:11,200
היה faster-- מואץ יותר מהר, ו
התוכנה לא היוותה ש.

932
00:44:11,200 --> 00:44:14,910
>> -The הרס של הרקטות
היה אסון פיננסי עצום.

933
00:44:14,910 --> 00:44:18,630
כל עקב שגיאת תוכנת דקות.

934
00:44:18,630 --> 00:44:21,160
אבל זה לא היה ראשון
בעיות המרת נתונים בזמן

935
00:44:21,160 --> 00:44:24,770
הטריד את טכנולוגית טילים מודרנית.

936
00:44:24,770 --> 00:44:28,020
>> ב-1991 עם תחילת
של מלחמת המפרץ הראשונה,

937
00:44:28,020 --> 00:44:30,540
הטילים פטריוטים
חווה סוג דומה

938
00:44:30,540 --> 00:44:32,465
של בעיית גיור מספר.

939
00:44:32,465 --> 00:44:36,760
וכתוצאה מכך 28 people-- 28
soldiers-- האמריקאי נהרגו,

940
00:44:36,760 --> 00:44:39,010
ועל מאה אחרים נפצעו.

941
00:44:39,010 --> 00:44:42,830
כאשר הפטריוט, שהיה אמור
כדי להגן מפני טילי סקאד נכנסים,

942
00:44:42,830 --> 00:44:45,780
לא הצליח לירות טיל.

943
00:44:45,780 --> 00:44:51,610
>> -כאשר עיראק פלשה לכווית, ובאמריקה
השיק סופה במדבר בתחילת 1991,

944
00:44:51,610 --> 00:44:55,720
סוללות טילים פטריוטים נפרסו
כדי להגן על סעודיה וישראל

945
00:44:55,720 --> 00:44:59,180
מהתקפות טילי סקאד עיראקיים.

946
00:44:59,180 --> 00:45:03,080
הפטריוט הוא לטווח בינוני בארה"ב
משטח אל אוויר מערכת

947
00:45:03,080 --> 00:45:06,530
מיוצר על ידי חברת ריית'און.

948
00:45:06,530 --> 00:45:09,500
>> -The גודל של פטריוט
מיירט itself--

949
00:45:09,500 --> 00:45:14,705
זה זמן רב על בערך 20 רגליים,
והוא שוקל כ -2,000 ק"ג.

950
00:45:14,705 --> 00:45:19,090
והיא נושאת ראש נפץ של כ,
אני חושב שזה בערך 150 ק"ג.

951
00:45:19,090 --> 00:45:23,880
וראש הנפץ עצמו הוא
נפץ גבוה, ש

952
00:45:23,880 --> 00:45:26,700
יש שברים סביבו.

953
00:45:26,700 --> 00:45:31,630
אז המעטפת של ראש הנפץ היא
נועד לפעול כמו כדורי עופרת.

954
00:45:31,630 --> 00:45:34,040
>> -The טילים מתבצעים
ארבע למכולה,

955
00:45:34,040 --> 00:45:37,170
ומועברים על ידי קרוון למחצה.

956
00:45:37,170 --> 00:45:44,880
>> -The מערכת נגד טילים פטריוטים
חוזר 20 שנים לפחות עכשיו.

957
00:45:44,880 --> 00:45:48,380
הוא תוכנן במקור
כטילי הגנה אוויריים

958
00:45:48,380 --> 00:45:50,810
להפיל מטוסי אויב.

959
00:45:50,810 --> 00:45:54,410
במלחמת המפרץ הראשונה
כאשר המלחמה שבאה על,

960
00:45:54,410 --> 00:45:59,650
הצבא רצה להשתמש בו כדי
להפיל את הסקאדים, לא מטוסים.

961
00:45:59,650 --> 00:46:03,580
חיל האוויר העירקי היה
לא כל כך הרבה של בעיה,

962
00:46:03,580 --> 00:46:06,590
אבל הצבא היה מודאג לגבי הסקאדים.

963
00:46:06,590 --> 00:46:10,120
וכך הם ניסו
שדרוג הפטריוט.

964
00:46:10,120 --> 00:46:12,740
>> -Intercepting אויב
טילים הנעים במאך 5

965
00:46:12,740 --> 00:46:15,670
הולך להיות מאתגר מספיק.

966
00:46:15,670 --> 00:46:18,440
אבל כאשר הפטריוט
הובהל לשירות,

967
00:46:18,440 --> 00:46:22,580
הצבא לא היה מודע
שינוי עיראקי ש

968
00:46:22,580 --> 00:46:25,880
עשה הסקאדים שלהם כמעט
בלתי אפשרי לזה.

969
00:46:25,880 --> 00:46:30,690
>> 'מה שקרה הוא הסקאדים ש
היו באים בהיו בלתי יציבים.

970
00:46:30,690 --> 00:46:32,000
הם היו רעועים.

971
00:46:32,000 --> 00:46:37,210
הסיבה לכך הייתה Iraqis--
על מנת לקבל 600 קילומטר החוצה

972
00:46:37,210 --> 00:46:41,680
של missile-- טווח 300 קילומטר
לקח משקל מראש הנפץ הקדמי,

973
00:46:41,680 --> 00:46:43,340
ועשה את ראש הנפץ קל יותר.

974
00:46:43,340 --> 00:46:48,490
אז עכשיו הפטריוט של מנסה לבוא
בסקאד, ורוב time--

975
00:46:48,490 --> 00:46:52,880
רובם המכריע של
time-- זה יהיה לטוס רק על ידי סקאד.

976
00:46:52,880 --> 00:46:57,120
>> -Once מפעילי המערכת הפטריוט
הבנתי הפטריוט יחטיא את מטרתו,

977
00:46:57,120 --> 00:47:01,630
הם פוצצו ראש הנפץ של הפטריוט
להימנע מפגיעה אפשרית אם זה

978
00:47:01,630 --> 00:47:04,440
היה מותר לנפול אל הקרקע.

979
00:47:04,440 --> 00:47:08,700
>> -That היה מה שרוב האנשים ראו
ככדורי אש גדולות בשמיים,

980
00:47:08,700 --> 00:47:14,180
וטעות כ
מיירט של ראשי נפץ סקאד.

981
00:47:14,180 --> 00:47:18,020
>> -Although בשמי הלילה, פטריוטס
נראה שהורס בהצלחה

982
00:47:18,020 --> 00:47:23,280
הסקאדים, בדהראן יכולים להיות שיש
אל תטעה את הביצועים שלו.

983
00:47:23,280 --> 00:47:27,930
יש מערכת המכ"ם של הפטריוט
מסלול אבוד של טיל סקאד

984
00:47:27,930 --> 00:47:30,260
ומעולם לא השיק בשל
לפגם תוכנה.

985
00:47:30,260 --> 00:47:34,060

986
00:47:34,060 --> 00:47:38,880
>> זה היה הישראלים שהתגלו לראשונה
שהמערכת כבר לא הייתה על,

987
00:47:38,880 --> 00:47:41,130
גדול יותר את פער הזמן הפך.

988
00:47:41,130 --> 00:47:44,770
בשל שעון המשובץ
במחשב של המערכת.

989
00:47:44,770 --> 00:47:48,190
>> -About שבועיים לפני
הטרגדיה בדהראן,

990
00:47:48,190 --> 00:47:50,720
הישראלים דיווחו ל
משרד ההגנה

991
00:47:50,720 --> 00:47:52,410
שהמערכת הייתה מאבדת זמן.

992
00:47:52,410 --> 00:47:54,410
לאחר כשמונה שעות
של ריצה, הם הבחינו

993
00:47:54,410 --> 00:47:57,690
כי המערכת של ההפיכה
ניכר פחות מדויק.

994
00:47:57,690 --> 00:48:01,850
משרד ההגנה בתגובה
אומר לי כל הסוללות פטריוטים

995
00:48:01,850 --> 00:48:04,800
לא לעזוב את המערכות
על במשך זמן רב.

996
00:48:04,800 --> 00:48:06,980
הם אף פעם לא אמרו את מה שזמן רב היה.

997
00:48:06,980 --> 00:48:09,140
8 שעות, 10 שעות, אלף שעות.

998
00:48:09,140 --> 00:48:11,300
אף אחד לא ידע.

999
00:48:11,300 --> 00:48:13,320
>> -The סוללה הפטריוט
מוצב בצריפים

1000
00:48:13,320 --> 00:48:18,310
בDhahran והפנימי הפגום שלה
שעון היה בבמשך 100 שעות

1001
00:48:18,310 --> 00:48:21,520
בליל של 25 פברואר.

1002
00:48:21,520 --> 00:48:25,792
>> 'זה מעקב זמן לדיוק
של כעשירית משני.

1003
00:48:25,792 --> 00:48:27,950
עכשיו עשירית שני
הוא מספר מעניין

1004
00:48:27,950 --> 00:48:31,850
כי לא ניתן לבטא אותו
בינארי בדיוק, ש

1005
00:48:31,850 --> 00:48:36,500
פירוש לא יכול לבוא לידי ביטוי בדיוק
בכל מחשב דיגיטלי מודרני.

1006
00:48:36,500 --> 00:48:41,070
קשה להאמין, אבל
להשתמש בזה כדוגמא.

1007
00:48:41,070 --> 00:48:43,420
>> בואו ניקח שלישי מספר אחד.

1008
00:48:43,420 --> 00:48:47,330
שליש לא יכול להיות
בא לידי ביטוי בעשרוני בדיוק.

1009
00:48:47,330 --> 00:48:52,060
השלישי הוא 0.333
קורה לאינסוף.

1010
00:48:52,060 --> 00:48:56,420
אין דרך לעשות את זה עם
דיוק מוחלט בעשרוני.

1011
00:48:56,420 --> 00:48:59,530
זה בדיוק הסוג של בעיה
זה קרה בפטריוט.

1012
00:48:59,530 --> 00:49:04,040
עוד המערכת רצה,
גרוע שגיאת הזמן הפכה.

1013
00:49:04,040 --> 00:49:08,840
>> אחרי ככלות של 100 שעות הפעלה,
שגיאה בזמן הייתה רק כשליש

1014
00:49:08,840 --> 00:49:10,440
של שנייה.

1015
00:49:10,440 --> 00:49:14,150
אבל במונחים של מיקוד
טילים הנעים במאך 5,

1016
00:49:14,150 --> 00:49:18,560
זה הביא למעקב
שגיאה של מעל 600 מטרים.

1017
00:49:18,560 --> 00:49:21,870
זה יהיה שגיאה חמורה
לחיילים בדהראן.

1018
00:49:21,870 --> 00:49:28,455
>> 'מה קרה הוא השקת סקאד היה
זוהה על ידי מוקדם לוויני התרעה,

1019
00:49:28,455 --> 00:49:32,710
והם ידעו סקאד בא
בכיוון הכללי שלהם.

1020
00:49:32,710 --> 00:49:35,150
הם לא ידעו מאיפה זה בא.

1021
00:49:35,150 --> 00:49:38,210
זה היה עכשיו עד לרדאר
רכיב של המערכת הפטריוט

1022
00:49:38,210 --> 00:49:43,150
הגנת Dhahran לאתר ולשמור
מסלולו של טיל האויב הנכנס.

1023
00:49:43,150 --> 00:49:44,561
>> -The רדאר היה מאוד חכם.

1024
00:49:44,561 --> 00:49:46,560
זה באמת היה לעקוב אחר
עמדתו של סקאד

1025
00:49:46,560 --> 00:49:48,930
ולאחר מכן לחזות בי
זה כנראה יהיה

1026
00:49:48,930 --> 00:49:51,380
בפעם הבאה
רדאר נשלח דופק החוצה.

1027
00:49:51,380 --> 00:49:53,040
שנקרא שער הטווח.

1028
00:49:53,040 --> 00:49:57,620
>> -Then פעם הפטריוט
מחליט יש לו מספיק זמן

1029
00:49:57,620 --> 00:50:02,400
עבר לחזור ולבדוק הבאים
מיקום לאובייקט מזוהה זה

1030
00:50:02,400 --> 00:50:03,550
זה חוזר.

1031
00:50:03,550 --> 00:50:07,820
אז כשזה חזר להלא נכון
מקום, אז זה לא רואה שום אובייקט.

1032
00:50:07,820 --> 00:50:10,360
והוא מחליט שאין אובייקט.

1033
00:50:10,360 --> 00:50:13,630
שיש זיהוי שווא
וזה מפיל את המסלול.

1034
00:50:13,630 --> 00:50:16,970
>> -The סקאד הנכנס נעלם
ממסך המכ"ם,

1035
00:50:16,970 --> 00:50:20,200
ושניות לאחר מכן, אותו
פגע בצריפים.

1036
00:50:20,200 --> 00:50:22,570
סקאד נהרג 28.

1037
00:50:22,570 --> 00:50:26,110
זה האחרון פוטר
בתקופת מלחמת המפרץ הראשונה.

1038
00:50:26,110 --> 00:50:31,920
באופן טרגי, התוכנה המעודכנת
הגיע עם שחר ביום הבא.

1039
00:50:31,920 --> 00:50:34,870
היה לי פגם התוכנה
היה קבועה, סגירה

1040
00:50:34,870 --> 00:50:39,150
פרק אחד במוטרד
ההיסטוריה של הטילים פטריוטים.

1041
00:50:39,150 --> 00:50:40,030
>> [END הפעלת וידאו]

1042
00:50:40,030 --> 00:50:41,488
>> דוד י מלאן: זהו זה לCS50.

1043
00:50:41,488 --> 00:50:42,820
אנחנו אראה אותך ביום רביעי.

1044
00:50:42,820 --> 00:50:46,420

1045
00:50:46,420 --> 00:50:50,370
>> [השמעת מוסיקה]

1046
00:50:50,370 --> 00:54:23,446