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

2
00:00:10,940 --> 00:00:13,060
>> דוד J מלאן: כל
נכון, אז זה CS50.

3
00:00:13,060 --> 00:00:15,040
וזה ברור ביום שישי.

4
00:00:15,040 --> 00:00:16,850
וזה הסוף של שבוע אחד.

5
00:00:16,850 --> 00:00:21,020
אז אתם אולי זוכרים שהפסקנו,
הפעם האחרונה, עם סחרור מסוכן של מיני.

6
00:00:21,020 --> 00:00:25,020
לפיה אנו חושפים את השקר הזה, שלא
עניין גובר מה שאתה כבר לימדת

7
00:00:25,020 --> 00:00:31,610
עד, 1 מחולק 10 הוא לא, ב
למעשה, 0.1 או 0.100 או .10000.

8
00:00:31,610 --> 00:00:35,270
למעשה, אם אנחנו לקמפל זה
תכנית, כפי שעשינו אתמול, עם,

9
00:00:35,270 --> 00:00:39,770
להפוך את חוסר דיוק, ולאחר מכן
לעשות נקודה, לקצץ, חוסר דיוק,

10
00:00:39,770 --> 00:00:43,600
נודע לנו שזה מה שזה
1 מחולק 10 הוא למעשה.

11
00:00:43,600 --> 00:00:46,140
אז זה לא באמת די במקרה.

12
00:00:46,140 --> 00:00:49,014
אבל זה עושה רמז בכמה
מגבלה בסיסית של מחשבים.

13
00:00:49,014 --> 00:00:50,930
ואכן, בין
דברים שאנחנו הולכים לעשות

14
00:00:50,930 --> 00:00:55,130
היום הוא להעיף מבט במה זה יש
קרה, מה השלכות שיש לכך,

15
00:00:55,130 --> 00:00:58,430
איך האנושות נכשלה
לתפוס את זה בחלק מאוד

16
00:00:58,430 --> 00:01:00,410
situations-- הרציני
התוצאה של ש

17
00:01:00,410 --> 00:01:03,141
כבר די טרגי
וexpensive-- וגם

18
00:01:03,141 --> 00:01:04,849
תסתכל איך אנחנו
באמת יכול להגן על

19
00:01:04,849 --> 00:01:06,530
נגד סוגים של מגבלות אלה.

20
00:01:06,530 --> 00:01:10,940
אז באופן אינטואיטיבי, אולי,
מדוע מחולק 1 על ידי 10,

21
00:01:10,940 --> 00:01:15,480
לפי המחשב שלי
כאן, לא רק 1/10, 0.10?

22
00:01:15,480 --> 00:01:15,980
כן.

23
00:01:15,980 --> 00:01:16,530
מה אתה חושב?

24
00:01:16,530 --> 00:01:17,860
>> חבר קהל: RADIX הוא שונה?

25
00:01:17,860 --> 00:01:18,550
>> דוד J מלאן: מה הוא?

26
00:01:18,550 --> 00:01:19,730
אה, RADIX הוא שונה?

27
00:01:19,730 --> 00:01:20,720
אז לא ממש.

28
00:01:20,720 --> 00:01:23,200
זה בעצם יותר
בסיסי לחומרה.

29
00:01:23,200 --> 00:01:23,980
מחשבות אחרות?

30
00:01:23,980 --> 00:01:24,584
כן.

31
00:01:24,584 --> 00:01:26,750
חבר קהל: הם
לייצג מספרים שונים?

32
00:01:26,750 --> 00:01:27,880
דוד J מלאן: אז they-- ימין.

33
00:01:27,880 --> 00:01:29,338
הם מייצגים מספרים שונים.

34
00:01:29,338 --> 00:01:30,700
לא מדויק, ככל הנראה.

35
00:01:30,700 --> 00:01:33,190
כך שהוא-- ובכן,
אחרת ממה?

36
00:01:33,190 --> 00:01:34,490
או שממנו?

37
00:01:34,490 --> 00:01:35,050
מאיתנו?

38
00:01:35,050 --> 00:01:35,966
חבר קהל: כן.

39
00:01:35,966 --> 00:01:38,930
הם לא משתמשים בעשרוניים
מערכת ל[ לא ברור].

40
00:01:38,930 --> 00:01:39,680
דוד J מלאן: אישור.

41
00:01:39,680 --> 00:01:41,560
אז במובן מסוים, הם לא
להשתמש בשיטה העשרונית.

42
00:01:41,560 --> 00:01:43,720
מתחת למכסה המנוע,
הכל, אכן, בינארי,

43
00:01:43,720 --> 00:01:45,510
וזה קשור, למעשה.

44
00:01:45,510 --> 00:01:48,135
אבל זה אפילו פשוט יותר
הסבר מזה.

45
00:01:48,135 --> 00:01:48,635
כן.

46
00:01:48,635 --> 00:01:49,970
>> חבר קהל: הם
יש רק חתיכות כל כך הרבה.

47
00:01:49,970 --> 00:01:52,370
הם יכולים רק לאחסן עד מסוימים
מידה, כמו עם שברים עשרוניים.

48
00:01:52,370 --> 00:01:52,780
>> דוד J מלאן: כן.

49
00:01:52,780 --> 00:01:54,420
זה מה שבאמת מקבל על זה.

50
00:01:54,420 --> 00:01:57,180
מתברר כי מחשבים
בדרך כלל, תמיד רק

51
00:01:57,180 --> 00:01:59,690
להשתמש בכמות מוגבלת של מידע
לייצג משהו.

52
00:01:59,690 --> 00:01:59,870
נכון?

53
00:01:59,870 --> 00:02:02,110
אחרי הכל, יש לנו קבוע רק
כמות של שטח דיסק קשיח.

54
00:02:02,110 --> 00:02:04,210
יש לנו רק סכום קבוע
של זיכרון RAM, או זיכרון מחשב.

55
00:02:04,210 --> 00:02:06,251
ואם יש לך רק
סכום קבוע של משהו,

56
00:02:06,251 --> 00:02:09,611
בוודאי שאתה לא ממש יכול לספור עד
עד אינסוף או כל מספר שאתה רוצה.

57
00:02:09,611 --> 00:02:11,610
אתה, סוג של, צריך
לבחור מה טווח

58
00:02:11,610 --> 00:02:13,220
ערכים שאתה הולך לתמוך.

59
00:02:13,220 --> 00:02:18,100
>> וכך למשל, בשבוע או שניים
לפני, כשדיברנו על ASCII,

60
00:02:18,100 --> 00:02:21,610
ודיברנו על 8 סיביות,
או בייט, כביכול,

61
00:02:21,610 --> 00:02:26,360
המספר הגדול ביותר שיכולנו
מייצג עם 8 ביטים היה מה?

62
00:02:26,360 --> 00:02:28,350
255.

63
00:02:28,350 --> 00:02:31,850
ואנחנו יכולים לייצג 256 ערכים מוחלט
אבל לא אם אנחנו מבלים אחד מהם

64
00:02:31,850 --> 00:02:34,190
על 0-- ובכן, אבל אם אנחנו
להוציא אחד מהם על 0,

65
00:02:34,190 --> 00:02:36,830
לאחר מכן את המספר הגדול ביותר
הוא, כמובן, 255.

66
00:02:36,830 --> 00:02:39,410
>> אז מתברר, שזה הוא
המקרה מדי, בהקשר זה.

67
00:02:39,410 --> 00:02:42,350
התחלנו לדבר בפעם האחרונה,,
על מספרי נקודה צפה, ש

68
00:02:42,350 --> 00:02:44,640
הם שונים ממספרים שלמים, ב
כי יש להם נקודה עשרונית

69
00:02:44,640 --> 00:02:47,056
וגם, בתקווה, כמה מספרים
לאחר ש, אבל הם יותר מדי.

70
00:02:47,056 --> 00:02:51,730
מחשב הוא רק בדרך כלל הולך
להשתמש 32 סיביות, אולי 64 סיביות

71
00:02:51,730 --> 00:02:53,497
לייצג ערך נקודה צפה.

72
00:02:53,497 --> 00:02:56,080
אז למרות שאנחנו כבר גדלנו
לימוד מתמטיקה ולדעת

73
00:02:56,080 --> 00:02:58,750
כי אתה בהחלט יכול להיות
מספר אינסופי של מספרים

74
00:02:58,750 --> 00:03:01,650
לאחר הנקודה העשרונית, לא
אם יש לך זיכרון סופי.

75
00:03:01,650 --> 00:03:03,930
אתה, סוג של, צריך לעגל,
או לבחור ש

76
00:03:03,930 --> 00:03:05,346
מספרים שאתה הולך לייצג.

77
00:03:05,346 --> 00:03:08,710
ואז אתה יכול לחשוב על, במובן מסוים,
זה להיות במחשב הקרוב ביותר

78
00:03:08,710 --> 00:03:14,050
קירוב לערך 1/10 ש
הוא יכול לקבל, עם רק 32 או כך ביטים.

79
00:03:14,050 --> 00:03:15,300
וזה לא רק 1/10.

80
00:03:15,300 --> 00:03:19,820
>> לדוגמא, אם אני משנה את זה ל
1/3, שבו אנו חושבים הוא אפילו פשוט יותר.

81
00:03:19,820 --> 00:03:21,300
אז 1 חלקי 3.

82
00:03:21,300 --> 00:03:22,355
תן לי לשמור את הקובץ.

83
00:03:22,355 --> 00:03:24,680
תן לי ללכת קדימה והדר מחדש את זה.

84
00:03:24,680 --> 00:03:25,820
ותן לי להפעיל מחדש את זה.

85
00:03:25,820 --> 00:03:30,000
גם כאן, ככל הנראה, 1/3 הוא לא 0.3
ולאחר מכן מספר אינסופי של 3 של

86
00:03:30,000 --> 00:03:30,770
לאחר מכן.

87
00:03:30,770 --> 00:03:32,540
יש לך חוסר הדיוק הזה בסוף.

88
00:03:32,540 --> 00:03:35,544
אז אנחנו בני האדם הם נכונים, ומה ש
אתה למדת הוא, למעשה, נכון,

89
00:03:35,544 --> 00:03:37,460
אבל אנחנו נתקעים
נגד כמה מגבלות.

90
00:03:37,460 --> 00:03:39,420
>> ומה שחשבתי
היינו עושה היום, הוא מתחיל

91
00:03:39,420 --> 00:03:42,190
על ידי הסתכלות, בכנות,
תוצאות טרגיות של זה

92
00:03:42,190 --> 00:03:45,490
לפעמים, כאשר האנושות
לא ממש ליישם

93
00:03:45,490 --> 00:03:48,460
למציאות זו ומגבלות אלה.

94
00:03:48,460 --> 00:03:52,360
ואנו רואים סדרה של ציורים
מערוץ ההיסטוריה שלוקח

95
00:03:52,360 --> 00:03:53,950
תסתכל איך דברים השתבשו.

96
00:03:53,950 --> 00:03:56,340
זה זמן רב על 8 דקות,
ואנחנו נחזור אחרי זה

97
00:03:56,340 --> 00:03:59,439
ותסתכל בדיוק
מה עוד יכול להשתבש.

98
00:03:59,439 --> 00:04:00,605
אם היינו יכול לעמעם את lights--

99
00:04:00,605 --> 00:04:02,350
>> [וידאו השמעה]

100
00:04:02,350 --> 00:04:06,310
>> -Computers, כולנו באים לקבל
הבעיות לעתים קרובות מתסכלות ש

101
00:04:06,310 --> 00:04:07,750
ללכת איתם.

102
00:04:07,750 --> 00:04:11,370
באגס, וירוסים, ותוכנה
תקלות הן מחירים קטנים

103
00:04:11,370 --> 00:04:13,230
לשלם עבור הנוחות.

104
00:04:13,230 --> 00:04:17,519
אבל בהיי-טק ומהירות גבוהה
יישומים צבאיים ותכנית החלל,

105
00:04:17,519 --> 00:04:22,130
הבעיה הקטנה ביותר יכול
להיות מוגדל לאסון.

106
00:04:22,130 --> 00:04:27,750
ב -4 ביונים 1996, מדענים מוכנים
כדי להפעיל רקטות אריאן 5 בלתי מאוישות.

107
00:04:27,750 --> 00:04:29,890
זה נשא מדעי
לווינים שנועדו

108
00:04:29,890 --> 00:04:33,030
להקים בדיוק איך
אינטראקציה השדה המגנטית של כדור הארץ

109
00:04:33,030 --> 00:04:35,600
עם רוחות שמש.

110
00:04:35,600 --> 00:04:37,930
הרקטות נבנתה ל
סוכנות החלל האירופית

111
00:04:37,930 --> 00:04:41,620
והרמתי את מתקניה
על החוף של גויאנה הצרפתית.

112
00:04:41,620 --> 00:04:44,924
>> -ואז כ -30 שניות ל
הטיסה, שהם ראשון

113
00:04:44,924 --> 00:04:46,340
משהו שם לב שהשתבש.

114
00:04:46,340 --> 00:04:49,280
כי החרירים היו מסתובבים
בדרך הם ממש לא צריכים.

115
00:04:49,280 --> 00:04:53,042
כ -40 שניות לטיסה,
בבירור הרכב היה בצרות,

116
00:04:53,042 --> 00:04:55,250
ואז הם עשו
ההחלטה להרוס אותו.

117
00:04:55,250 --> 00:04:58,970
קצין בטיחות טווח עם
אומץ אדיר לחץ על הכפתור,

118
00:04:58,970 --> 00:05:03,940
פוצץ את הטיל לפני שהוא יכול
להיות סכנה לשלום הציבור.

119
00:05:03,940 --> 00:05:06,600
>> -זהו היה העלמה
מסע של 5 אריאן,

120
00:05:06,600 --> 00:05:09,270
וההרס שלה לקח
מקום בגלל פגם

121
00:05:09,270 --> 00:05:10,992
משובץ בתוכנה של הרקטות.

122
00:05:10,992 --> 00:05:12,700
בחור' בעיה ב
אריאן היה שיש

123
00:05:12,700 --> 00:05:15,370
היה מספר שנדרש
64 סיביות להביע,

124
00:05:15,370 --> 00:05:18,150
והוא רצה להמיר
זה למספר 16 ביט.

125
00:05:18,150 --> 00:05:21,160
הם הניחו כי המספר
אף פעם לא הולך להיות גדול מאוד,

126
00:05:21,160 --> 00:05:25,020
שרוב הספרות אלה ב
מספר 64 הביט היה 0 של.

127
00:05:25,020 --> 00:05:26,310
הם טעו.

128
00:05:26,310 --> 00:05:28,680
>> בחור' חוסר יכולת של אחד
תוכנה לקבלה

129
00:05:28,680 --> 00:05:32,820
הסוג של מספר שנוצר על ידי
עוד היה בשורש הכישלון.

130
00:05:32,820 --> 00:05:37,190
פיתוח תוכנה הפך
חלק מאוד יקר של טכנולוגיה חדשה.

131
00:05:37,190 --> 00:05:40,760
רקטת אריאן 4 הייתה מאוד
מוצלח, כל כך הרבה של התוכנה

132
00:05:40,760 --> 00:05:43,990
נוצר עבורו היה גם
שימוש באריאן 5.

133
00:05:43,990 --> 00:05:49,750
>> בחור' בעיה בסיסית הייתה שאריאן
5 היו מהירים יותר, מהיר יותר מואצים.

134
00:05:49,750 --> 00:05:53,000
והתוכנה לא הייתה
אחריות לכך.

135
00:05:53,000 --> 00:05:56,330
>> בחור' הרס של הרקטות
היה אסון פיננסי עצום,

136
00:05:56,330 --> 00:05:59,670
כל עקב שגיאת תוכנת דקות.

137
00:05:59,670 --> 00:06:01,990
אבל זה לא היה ראשון
בעיות המרת נתונים בזמן

138
00:06:01,990 --> 00:06:05,310
הטריד טכנולוגית רקטות מודרנית.

139
00:06:05,310 --> 00:06:08,300
>> -in שינה 1991, עם תחילת
של מלחמת המפרץ הראשון,

140
00:06:08,300 --> 00:06:10,650
הטילים הפטריוט
חווה סוג דומה

141
00:06:10,650 --> 00:06:12,650
בעיה המרת מספר.

142
00:06:12,650 --> 00:06:15,620
כתוצאה מכך, 28 אנשים,
28 חיילים אמריקאים

143
00:06:15,620 --> 00:06:18,440
נהרגו וכ
100 אחרים נפצעו,

144
00:06:18,440 --> 00:06:21,900
כאשר הפטריוט, שהיה אמור
כדי להגן מפני הסקאדים נכנסים,

145
00:06:21,900 --> 00:06:24,630
לא הצליח לירות טיל.

146
00:06:24,630 --> 00:06:29,440
>> -כאשר עיראק פלשה לכווית ואמריקה
השיק סופה במדבר בתחילת השינה 1991,

147
00:06:29,440 --> 00:06:33,800
סוללות טילים פטריוט נפרסו
כדי להגן על סעודיה וישראל

148
00:06:33,800 --> 00:06:37,000
מהתקפות טילי סקאד עיראקיים.

149
00:06:37,000 --> 00:06:40,610
הפטריוט הוא ארה"ב, לטווח בינוני
קרקע-אוויר מערכת

150
00:06:40,610 --> 00:06:43,010
מיוצר על ידי חברת ריית'און.

151
00:06:43,010 --> 00:06:49,080
>> בחור' גודל של המיירט הפטריוט,
עצמו, הוא על, ארוך בערך 20 רגל.

152
00:06:49,080 --> 00:06:51,250
והוא שוקל כ -2000 פאונד.

153
00:06:51,250 --> 00:06:55,195
והוא נושא ראש נפץ של על--
אני חושב שזה בערך 150 פאונד.

154
00:06:55,195 --> 00:06:59,500
וראש הנפץ, עצמו,
הוא נפץ גבוה,

155
00:06:59,500 --> 00:07:02,570
שבו יש שברים סביבו.

156
00:07:02,570 --> 00:07:06,890
המעטפת של ראש הנפץ היא
תוכנן לפעול כמו כדורי עופרת.

157
00:07:06,890 --> 00:07:09,130
>> בחור' טילים
בוצע, 4 למכולה,

158
00:07:09,130 --> 00:07:12,080
ומועברים על ידי חצי קרוואן.

159
00:07:12,080 --> 00:07:19,100
>> בחור' מערכת טילים אנטי פטריוט
חוזר לפחות 20 שנים.

160
00:07:19,100 --> 00:07:22,320
הוא תוכנן במקור
כטילי הגנה אוויריים

161
00:07:22,320 --> 00:07:24,180
להפיל מטוסי אויב.

162
00:07:24,180 --> 00:07:27,860
במלחמת המפרץ הראשון,
כאשר המלחמה שבאה,

163
00:07:27,860 --> 00:07:32,745
הצבא רצה להשתמש בו כדי
להפיל את הסקאדים, לא מטוסים.

164
00:07:32,745 --> 00:07:36,150
חיל העירקי לא היה
כל כך הרבה של בעיה,

165
00:07:36,150 --> 00:07:39,110
אבל הצבא היה מודאג הסקאדים.

166
00:07:39,110 --> 00:07:42,340
וכך הם ניסו
שדרוג הפטריוט.

167
00:07:42,340 --> 00:07:44,760
>> -Intercepting אויב
טיל נוסע במאך חמש

168
00:07:44,760 --> 00:07:47,250
הולך להיות מאתגר מספיק.

169
00:07:47,250 --> 00:07:50,000
אבל כאשר הפטריוט
הובהל לשירות,

170
00:07:50,000 --> 00:07:54,030
הצבא לא היה מודע ל
שינוי העירקי שעשה

171
00:07:54,030 --> 00:07:56,840
הסקאדים שלהם כמעט בלתי אפשרי להכות.

172
00:07:56,840 --> 00:08:01,020
>> -מה קרה, היא הסקאדים ש
היו באים ב, היו לא יציבים,

173
00:08:01,020 --> 00:08:02,310
הם מתנדנדים.

174
00:08:02,310 --> 00:08:05,140
הסיבה לכך,
היו העיראקים, כדי

175
00:08:05,140 --> 00:08:09,450
כדי לקבל 600 קילומטרים מ
טילים לטווח של 300 קילומטר,

176
00:08:09,450 --> 00:08:12,930
לקח משקל מראש הנפץ מול
ועשה את ראש הנפץ קל יותר.

177
00:08:12,930 --> 00:08:17,710
אז עכשיו, הפטריוט של מנסים לבוא
בסקאד, ורוב הזמן,

178
00:08:17,710 --> 00:08:21,700
רובם המכריע של
זמן, זה היה לטוס רק על ידי סקאד.

179
00:08:21,700 --> 00:08:25,700
>> -Once מפעילי המערכת הפטריוט
הבנתי הפטריוט החטיאה את מטרתה,

180
00:08:25,700 --> 00:08:29,790
הם פוצצו ראש הנפץ של הפטריוט,
כדי להימנע מנפגעים אפשריים אם זה

181
00:08:29,790 --> 00:08:32,380
היה מותר לנפול אל הקרקע.

182
00:08:32,380 --> 00:08:36,340
>> חייהם." היה מה שרוב האנשים ראו,
כדורי אש הגדולים האלה בשמיים,

183
00:08:36,340 --> 00:08:41,289
וטעות כ
מיירט של ראשי נפץ סקאד.

184
00:08:41,289 --> 00:08:43,590
למרות בלילה
שמיים, פטריוטס הופיע

185
00:08:43,590 --> 00:08:47,020
להיות בהצלחה
להרוס הסקאדים, בDhahran,

186
00:08:47,020 --> 00:08:49,730
לא יכולה להיות טעות
על ביצועיה.

187
00:08:49,730 --> 00:08:53,990
יש, מערכת המכ"ם של הפטריוט
איבד את המסלול של סקאד הנכנס,

188
00:08:53,990 --> 00:08:56,650
ומעולם לא השיק,
בשל פגם תוכנה.

189
00:08:56,650 --> 00:08:59,650

190
00:08:59,650 --> 00:09:04,100
זה היה הישראלים שגילו ראשון
כי המערכת כבר הייתה ב,

191
00:09:04,100 --> 00:09:07,510
פער הזמן הגדול יותר
הפך, בשל שעון המשובץ

192
00:09:07,510 --> 00:09:09,490
במחשב של המערכת.

193
00:09:09,490 --> 00:09:12,670
>> "בקשר 2 שבועות לפני
הטרגדיה בDhahran,

194
00:09:12,670 --> 00:09:15,010
הישראלים דיווחו ל
משרד ההגנה,

195
00:09:15,010 --> 00:09:17,940
כי המערכת מאבדת זמן,
כי לאחר כ 8 שעות של ריצה,

196
00:09:17,940 --> 00:09:21,410
הם שמו לב שהמערכת הייתה
הופך באופן ניכר פחות מדויק.

197
00:09:21,410 --> 00:09:25,290
משרד ההגנה הגיב ב
אומר לי כל הסוללות הפטריוט

198
00:09:25,290 --> 00:09:28,070
לא לעזוב את המערכות
על במשך זמן רב.

199
00:09:28,070 --> 00:09:29,960
הם אף פעם לא אמרו את מה שזמן רב היה.

200
00:09:29,960 --> 00:09:30,460
8 שעות?

201
00:09:30,460 --> 00:09:30,960
10 שעות?

202
00:09:30,960 --> 00:09:31,870
1000 שעות?

203
00:09:31,870 --> 00:09:33,734
אף אחד לא ידע.

204
00:09:33,734 --> 00:09:35,650
בחור' סוללה הפטריוט
מוצב בצריפים

205
00:09:35,650 --> 00:09:40,410
בDhahran, והפנימי הפגום שלה
שעון, היה על מעל 100 שעות

206
00:09:40,410 --> 00:09:43,041
בלילה של 25 בפברואר.

207
00:09:43,041 --> 00:09:47,416
>> 'זה מעקב זמן לדיוק
של כ 1/10 של שנייה.

208
00:09:47,416 --> 00:09:49,290
עכשיו 1/10 של שנייה היא
מספר מעניין

209
00:09:49,290 --> 00:09:52,700
כי זה לא יכול להיות
בא לידי ביטוי בינארי, בדיוק.

210
00:09:52,700 --> 00:09:54,820
מה שאומר, זה לא יכול
לבוא לידי ביטוי, בדיוק,

211
00:09:54,820 --> 00:09:57,420
בכל מחשב דיגיטלי מודרני.

212
00:09:57,420 --> 00:10:01,460
קשה להאמין, אבל
להשתמש בזה כדוגמא.

213
00:10:01,460 --> 00:10:03,520
בואו ניקח את המספר, 1/3.

214
00:10:03,520 --> 00:10:07,110
1/3 לא יכול לבוא לידי ביטוי
בעשרוני, בדיוק.

215
00:10:07,110 --> 00:10:11,490
1/3 הוא 0.333 קורה לאינסוף.

216
00:10:11,490 --> 00:10:15,486
אין דרך לעשות את זה, עם
דיוק מוחלט, בעשרוני.

217
00:10:15,486 --> 00:10:18,360
זה אותו הסוג בדיוק של
בעיה שקרתה בפטריוט.

218
00:10:18,360 --> 00:10:22,510
עוד המערכת רצה,
גרוע שגיאת הזמן הפכה.

219
00:10:22,510 --> 00:10:28,420
>> אחרי ככלות של מבצע 100 שעות, השגיאה
בזמן היה רק ​​על 1/3 משני.

220
00:10:28,420 --> 00:10:31,830
אבל במונחים של מיקוד
טיל נוסע במאך 5,

221
00:10:31,830 --> 00:10:35,890
זה הביא למעקב
שגיאה של למעלה מ -600 מטרים.

222
00:10:35,890 --> 00:10:38,970
זה יהיה שגיאה חמורה
לחיילים בDhahran.

223
00:10:38,970 --> 00:10:45,035
>> -מה קרה, היא השקת סקאד היה
זוהה על ידי לוויני התרעה,

224
00:10:45,035 --> 00:10:48,930
הם וחדשים שסקאד היה
מגיע בכיוון הכללי שלהם.

225
00:10:48,930 --> 00:10:51,170
הם לא ידעו מאיפה זה בא.

226
00:10:51,170 --> 00:10:53,990
>> 'זה היה עכשיו עד לרדאר
רכיב של המערכת הפטריוט,

227
00:10:53,990 --> 00:10:58,520
הגנת Dhahran, כדי לאתר ולשמור
מסלול של טיל האויב הנכנס.

228
00:10:58,520 --> 00:10:59,690
>> בחור' הרדאר היה מאוד חכם.

229
00:10:59,690 --> 00:11:01,710
זה באמת היה לעקוב אחר
העמדה של סקאד

230
00:11:01,710 --> 00:11:04,040
ולחזות בי
זה כנראה יהיה,

231
00:11:04,040 --> 00:11:06,140
בפעם הבאה,
רדאר נשלח דופק החוצה.

232
00:11:06,140 --> 00:11:07,660
שנקרא שער הטווח.

233
00:11:07,660 --> 00:11:11,870
>> -Then, פעם הפטריוט
מחליט יש מספיק זמן

234
00:11:11,870 --> 00:11:16,280
עבר לחזור ולבדוק הבאים
מיקום לאובייקט מזוהה זה,

235
00:11:16,280 --> 00:11:17,280
הוא חוזר.

236
00:11:17,280 --> 00:11:21,690
אז כשזה חזר להלא נכון
מקום, אז זה לא רואה שום אובייקט

237
00:11:21,690 --> 00:11:25,230
והוא מחליט שלא היה
אובייקט, זה היה גילוי כוזב,

238
00:11:25,230 --> 00:11:26,650
ומפיל את המסלול.

239
00:11:26,650 --> 00:11:29,690
סקאד הנכנס נעלם
ממסך המכ"ם,

240
00:11:29,690 --> 00:11:32,670
ושניות לאחר מכן, אותו
טרק לצריפים.

241
00:11:32,670 --> 00:11:38,100
סקאד נהרג 28 והיה האחרון
אחד נורה במהלך מלחמת המפרץ הראשונה.

242
00:11:38,100 --> 00:11:43,460
למרבה הצער, תוכנה המעודכנת
הגיע Dhahran היום הבא.

243
00:11:43,460 --> 00:11:46,150
היה פגם התוכנה
היה קבועה, סגירה

244
00:11:46,150 --> 00:11:48,940
פרק אחד במוטרד
ההיסטוריה של הטילים הפטריוט.

245
00:11:48,940 --> 00:11:50,220
>> [סוף ההשמעה]

246
00:11:50,220 --> 00:11:54,340
>> דוד J מלאן: אז אנחנו נסתכל
כמה מגבלות דומות במעט.

247
00:11:54,340 --> 00:11:58,470
אבל קודם, בואו
מעבר לכמה לידיעתך זה.

248
00:11:58,470 --> 00:12:01,575
אז one-- בסוף השבוע הזה, יש
יהיו קטעים סופר,

249
00:12:01,575 --> 00:12:04,200
שנועדו לתפוס את המקום
סעיפים סדירים, ש

250
00:12:04,200 --> 00:12:05,460
יתחיל את שבוע ומכאן.

251
00:12:05,460 --> 00:12:08,204
תסתכל על אתר האינטרנט של CS50
לקבלת מידע נוספת על אלה.

252
00:12:08,204 --> 00:12:11,120
הם גם יהיו מצולמים וזרמו
לחיות לאלה שאינם מסוגלים להשתתף.

253
00:12:11,120 --> 00:12:12,980
בעיה להגדיר 1 היא ב
אתר האינטרנט של הקורס כבר,

254
00:12:12,980 --> 00:12:15,105
ואנחנו נסתכל
כי בקצת.

255
00:12:15,105 --> 00:12:18,350
ושעתי עבודה מדי, תיקח
ביום שני זה עד יום חמישי.

256
00:12:18,350 --> 00:12:20,960
>> אז זה היה הקנונית ביותר
תכנית שנראינו בזמן האחרון.

257
00:12:20,960 --> 00:12:23,590
זה כמו הפשוט
תכנית שאתה יכול לכתוב ב- C,

258
00:12:23,590 --> 00:12:25,250
ואפילו שזה קצת של תביעה נועזת.

259
00:12:25,250 --> 00:12:25,750
נכון?

260
00:12:25,750 --> 00:12:28,070
כי יש הרבה
לכאורה מורכבות לזה.

261
00:12:28,070 --> 00:12:30,445
אז בואו ניקח מבט מהיר ב
מה חלקם של גורמים אלה

262
00:12:30,445 --> 00:12:33,080
היו ולאחר מכן נסה לספק
מודל המנטלי לאיך

263
00:12:33,080 --> 00:12:35,710
הפשוט ביותר של תוכניות אלה
לעבוד, ואז נתחיל

264
00:12:35,710 --> 00:12:38,050
מסתכל על דברים יותר ויותר מורכב.

265
00:12:38,050 --> 00:12:41,280
אז הקו הזה כאן, הדגיש החברה,
בצהוב, מה שאנחנו לא אומרים, בפעם האחרונה,

266
00:12:41,280 --> 00:12:43,200
כי זה עושה לנו?

267
00:12:43,200 --> 00:12:45,220
מה המטרה שהוא משרת?

268
00:12:45,220 --> 00:12:46,984
כל אחד מרחוק יותר בחזרה?

269
00:12:46,984 --> 00:12:47,483
כן.

270
00:12:47,483 --> 00:12:48,649
>> חבר קהל: [לא ברור]

271
00:12:48,649 --> 00:12:50,871

272
00:12:50,871 --> 00:12:51,704
דוד J מלאן: טוב.

273
00:12:51,704 --> 00:12:53,537
אז זה נותן לך גישה
לפקודות, או בואו

274
00:12:53,537 --> 00:12:56,750
פונקציות קוראים להם, שמישהו
אחר כתב, שהכריזו,

275
00:12:56,750 --> 00:12:58,350
כביכול, בקובץ אחר.

276
00:12:58,350 --> 00:13:02,370
אז אנחנו תראו בדיוק מה קובץ .h
הוא מול קובץ .ג, סופו של דבר.

277
00:13:02,370 --> 00:13:04,710
אבל לעת עתה, רק יודע
printf ש, למשל,

278
00:13:04,710 --> 00:13:08,370
הוא בין הפונקציות שהיו
הכריז בקובץ אחר, אי שם

279
00:13:08,370 --> 00:13:12,930
על הכונן הקשיח של הענן אחר ש
מאפשר לנו הגישה printf ולהשתמש בו

280
00:13:12,930 --> 00:13:15,240
מבלי להמציא מחדש
גלגל בעצמנו.

281
00:13:15,240 --> 00:13:16,930
בינתיים, עיקרי.

282
00:13:16,930 --> 00:13:19,690
מה היה האנלוגי של שבוע ראשי, שעבר?

283
00:13:19,690 --> 00:13:20,190
כן.

284
00:13:20,190 --> 00:13:21,460
>> חבר קהל: הדגל ירוק נלחץ.

285
00:13:21,460 --> 00:13:21,740
>> דוד J מלאן: כן.

286
00:13:21,740 --> 00:13:23,490
שריטה של, כאשר הדגל ירוק לחץ.

287
00:13:23,490 --> 00:13:25,560
זה כמו פיסת הפאזל
כי בעיטות מחוץ דברים.

288
00:13:25,560 --> 00:13:28,306
וכך באופן דומה, עשה העולם
החלטתי לפני כמה שנים כי בC,

289
00:13:28,306 --> 00:13:30,930
וחבורה של שפות אחרות,
אם אתה רוצה לכתוב תכנית,

290
00:13:30,930 --> 00:13:33,410
הפונקציה הראשונה שלך
יש שייקרא, עיקרי.

291
00:13:33,410 --> 00:13:34,641
ויש לה להיראות כך.

292
00:13:34,641 --> 00:13:36,640
אבל אנחנו נחזור,
בפעם אחרת, למה, int,

293
00:13:36,640 --> 00:13:38,690
ו, חלל, אומר בהקשר זה.

294
00:13:38,690 --> 00:13:42,860
לעת עתה, הסוגריים המסולסלים הם סוג
כמו צורת פיסת הפאזל של Scratch

295
00:13:42,860 --> 00:13:45,080
שמתמצת כמה מספר הקווים.

296
00:13:45,080 --> 00:13:47,070
ובין על הקווים
כאן, הוא זו אחת כאן.

297
00:13:47,070 --> 00:13:51,610
printf הוא פונקציה שמטרתה ב
חיים הוא להדפיס מחרוזת מעוצבת.

298
00:13:51,610 --> 00:13:55,010
ועל ידי מעוצב, אני אומר שאתה
יכול לחבר בערכים מציין מיקום,

299
00:13:55,010 --> 00:13:58,360
ואתה יכול לציין כמה עשרוני
נקודות, כמה מספרים כדי להדפיס

300
00:13:58,360 --> 00:14:00,040
אחרי נקודה עשרונית וכדומה.

301
00:14:00,040 --> 00:14:05,040
וprintf, כמובן, לוקח אחד
או יותר טיעונים או פרמטרים,

302
00:14:05,040 --> 00:14:06,770
ידוע אחר, יותר פשוט, כתשומות.

303
00:14:06,770 --> 00:14:09,230
>> אז printf, כמו הרבה
פונקציות, לוקחת תשומות.

304
00:14:09,230 --> 00:14:12,730
ותשומות אלה אימצו
על ידי שני הסוגריים כאן.

305
00:14:12,730 --> 00:14:15,180
ובתוך אלה הוא קלט אחד.

306
00:14:15,180 --> 00:14:18,600
זה מחרוזת, כפי שקראנו לזה,
וזה רק רצף של תווים,

307
00:14:18,600 --> 00:14:22,310
כמו מילה, או ביטוי, או כל
מאמר גם, בין מרכאות כפולות.

308
00:14:22,310 --> 00:14:25,712
וזה מה שהולך להשפיע
התנהגות של printf כי, כמובן,

309
00:14:25,712 --> 00:14:27,170
זה רק פונקצית הדפסה גנריות.

310
00:14:27,170 --> 00:14:29,600
זה לא הולך לדעת מה
להדפיס, אלא אם אתה אומר את זה.

311
00:14:29,600 --> 00:14:31,000
ואז, כמה פרטי פרטים.

312
00:14:31,000 --> 00:14:34,056
מה אמר זה מוזר
רצף של סימנים הוא?

313
00:14:34,056 --> 00:14:34,556
כן.

314
00:14:34,556 --> 00:14:35,410
>> חבר קהל: קו חדש.

315
00:14:35,410 --> 00:14:35,990
>> דוד J מלאן: קו חדש.

316
00:14:35,990 --> 00:14:39,340
אז מתברר, שאתה לא יכול רק להכות,
להיכנס, כאשר אתה כותב את התכנית.

317
00:14:39,340 --> 00:14:42,590
בדרך כלל, המהדר הוא הולך לקבל
קצת מבולבל לגבי מה שאתה אומר.

318
00:14:42,590 --> 00:14:45,340
במקום זאת, יש לך, פשוטו כמשמעו,
אומר, תן לי קו חדש כאן.

319
00:14:45,340 --> 00:14:49,506
וכך / n הוא מה שאנחנו בדרך כלל
קורא אופי בריחה.

320
00:14:49,506 --> 00:14:50,870
אז n, לקו חדש.

321
00:14:50,870 --> 00:14:53,810
והמהדר יודע
כי כשהוא רואה / n,

322
00:14:53,810 --> 00:14:57,420
זה בעצם צריך לגרום למחשב,
סופו של דבר, או printf, במקרה זה,

323
00:14:57,420 --> 00:15:00,260
להדפיס חדש בפועל
קו, כמו להכות, להיכנס,

324
00:15:00,260 --> 00:15:01,480
מקש במקלדת.

325
00:15:01,480 --> 00:15:05,620
ולבסוף, מה שעשה אנחנו אומרים
חתיכת התחביר הזה היא בשביל?

326
00:15:05,620 --> 00:15:06,591
מה זה מייצג?

327
00:15:06,591 --> 00:15:07,090
כן.

328
00:15:07,090 --> 00:15:07,490
>> חבר קהל: [לא ברור]

329
00:15:07,490 --> 00:15:08,660
>> דוד J מלאן: זה פשוט
סוף השורה.

330
00:15:08,660 --> 00:15:09,909
זה הסוף של ההצהרה.

331
00:15:09,909 --> 00:15:11,890
ולהבין שאנחנו לא
לשים אותם בכל מקום.

332
00:15:11,890 --> 00:15:13,900
אנחנו בהחלט לא לשים אותם
בקצוות של כל שורה.

333
00:15:13,900 --> 00:15:16,680
לדוגמא, יש אף ב
קו ראשון, שיש אף אחד על הקו

334
00:15:16,680 --> 00:15:18,680
עם, עיקרי, יש אף אחד
לאחר הסוגריים המסולסלים,

335
00:15:18,680 --> 00:15:21,740
אבל אתה תתחיל לראות ולקבל
מכיר בו הוא קרא ל.

336
00:15:21,740 --> 00:15:26,014
וזה כמעט תמיד לאחר פונקציה
להתקשר או הצהרה, פעולה כלשהי

337
00:15:26,014 --> 00:15:27,180
שאתה בעצם לוקח.

338
00:15:27,180 --> 00:15:29,520
>> ויודע עכשיו, במיוחד אם
בין אלה פחות נוחים,

339
00:15:29,520 --> 00:15:32,540
אלה הם מיני דברים מטופשים
שתקבלו בסופו דופק בטעות

340
00:15:32,540 --> 00:15:33,873
הראש בקיר מעל.

341
00:15:33,873 --> 00:15:36,107
מכיוון שאתה אהיה לוגי
בטוח בכמה בעיה

342
00:15:36,107 --> 00:15:38,440
שפתרת לבעיה
סט, והדבר הארור רק

343
00:15:38,440 --> 00:15:40,187
לא לקמפל או אפילו לרוץ.

344
00:15:40,187 --> 00:15:43,270
ולעתים קרובות כל כך, בשלב מוקדם, זה הולך
להיות בגלל שפספסת סוגריים,

345
00:15:43,270 --> 00:15:44,455
או שפספסת נקודה-פסיק.

346
00:15:44,455 --> 00:15:46,547
וכל כך פשוט להיות זהיר
סוגים של הדברים האלה,

347
00:15:46,547 --> 00:15:49,380
ומנסה לא לקבל מתוסכל
שלהם כי עושה מהר מאוד זה

348
00:15:49,380 --> 00:15:50,640
הפך כובע ישן.

349
00:15:50,640 --> 00:15:53,910
אבל זה קל מאוד להגיע
מתוסכל בשלב מוקדם, כתוצאה מכך.

350
00:15:53,910 --> 00:15:57,020
>> אז עכשיו, בואו נסתכל על איך
קו זה הוא למעשה עובד

351
00:15:57,020 --> 00:15:59,170
ואז להסתכל על מעט
יותר מסובך אחד.

352
00:15:59,170 --> 00:16:02,017
אז יש לנו כאן,
היכולת לצייר על המסך הזה.

353
00:16:02,017 --> 00:16:04,100
ובואו נניח ש
זה מסך המחשב שלי,

354
00:16:04,100 --> 00:16:08,589
אבל אני כותב שלום התכנית,,
ולא אני מיושם, printf.

355
00:16:08,589 --> 00:16:10,130
מישהו אחר יישם, printf.

356
00:16:10,130 --> 00:16:12,420
מי הייתי רוצה לטעון ל
יישמת, printf?

357
00:16:12,420 --> 00:16:12,920
אם אנחנו עשויים?

358
00:16:12,920 --> 00:16:13,830
בסדר, מה שמך?

359
00:16:13,830 --> 00:16:14,155
>> סטודנט 1: [? גופאל. ?]

360
00:16:14,155 --> 00:16:15,529
>> דוד J מלאן: גופאל, לבוא בעד.

361
00:16:15,529 --> 00:16:16,430
בואו למעלה.

362
00:16:16,430 --> 00:16:17,070
בסדר.

363
00:16:17,070 --> 00:16:22,260
אז יש לנו, כאן, כמה תגים שם,
מאז אנחנו נעשה את משחק קצת מזה.

364
00:16:22,260 --> 00:16:26,270
ואנו קוראים לך, printf.

365
00:16:26,270 --> 00:16:30,170
ואם אתה רוצה לבוא לכאן,
מה בדיוק אני נמשך על המסך,

366
00:16:30,170 --> 00:16:32,340
זה די פשוט, יש לי, זה.

367
00:16:32,340 --> 00:16:35,550
>> בסדר, אז, שלום השם שלי הוא,
printf, אם אתה רוצה לשים את זה על.

368
00:16:35,550 --> 00:16:35,740
בסדר.

369
00:16:35,740 --> 00:16:37,360
ואם אתה יכול ללכת לעמוד
על ידי מסך המחשב

370
00:16:37,360 --> 00:16:39,730
כאילו אתה הפונקציה ש
הגיע עם מערכת מחשב זה.

371
00:16:39,730 --> 00:16:42,063
והמטרה שלך בחיים היא
למעשה להדפיס משהו.

372
00:16:42,063 --> 00:16:44,560
אבל הרבה כמו התכנית ש
פשוט היה על המסך, כאן,

373
00:16:44,560 --> 00:16:47,060
אנחנו הולכים צריכים
למעשה לתת לך כמה קלט.

374
00:16:47,060 --> 00:16:51,810
>> וכך, אם הקלט שלי, כאן, הוא
ככל הנראה, מה שהוא עבר לprintf,

375
00:16:51,810 --> 00:16:53,730
בואו סוג של ללעוג אותו ככה.

376
00:16:53,730 --> 00:16:58,720
אני הולך לכתוב, פשוטו כמשמעו, ב
פיסת נייר, "שלום, עולם"

377
00:16:58,720 --> 00:17:03,020
הקו הנטוי נ 'ושיהיה ברור, מה
אני רק מצויר על פיסת נייר זה,

378
00:17:03,020 --> 00:17:04,020
נראה כך.

379
00:17:04,020 --> 00:17:08,730
לכן, כאשר אני מפעיל תכנית זו, וזה
קו צהוב של קוד מקבל להורג,

380
00:17:08,730 --> 00:17:12,970
זה כאילו אני, את תכנית שלום,
אני מוסר כמה קלט לפונקציה

381
00:17:12,970 --> 00:17:13,970
שמישהו כתב אחר.

382
00:17:13,970 --> 00:17:16,595
>> ואם אתה, עם האצבע שלך,
באמת יכול, עם האצבע שלך,

383
00:17:16,595 --> 00:17:21,520
לצייר על המסך מה
זה שיש לך נמסר,

384
00:17:21,520 --> 00:17:27,465
למעשה, סופו של דבר, הוא
לראות בדיוק את זה, על המסך.

385
00:17:27,465 --> 00:17:29,140
ומקרה פינה קטן כאן.

386
00:17:29,140 --> 00:17:31,540
וטוב, אנחנו לא צריכים לראות
הקו, חדש, בשלב זה.

387
00:17:31,540 --> 00:17:33,900
זה לא יהיה נכון בשבילך
לצייר שורה חדשה באופן מפורש.

388
00:17:33,900 --> 00:17:36,810
אבל אם אנחנו כל הזמן כותב את מילות על
מסך, שהם בסופו של מתחת לזה.

389
00:17:36,810 --> 00:17:39,560
>> אז תודה רבה לך, אבל מקל
כאן לרגע אחד.

390
00:17:39,560 --> 00:17:42,860
עכשיו אנחנו צריכים אחד אחר
מתנדב, אם היינו יכולים,

391
00:17:42,860 --> 00:17:46,830
זה הולך צריך לשחק את התפקיד
ל-- זה אנשים היחידים בתזמורת

392
00:17:46,830 --> 00:17:47,355
ברגע זה.

393
00:17:47,355 --> 00:17:47,980
איך על-- אישור.

394
00:17:47,980 --> 00:17:48,480
ממש כאן.

395
00:17:48,480 --> 00:17:49,180
בואו למעלה.

396
00:17:49,180 --> 00:17:49,955
מה השם שלך?

397
00:17:49,955 --> 00:17:50,922
>> סטודנט 2: [? Ivay. ?]

398
00:17:50,922 --> 00:17:51,796
דוד J מלאן: מצטער?

399
00:17:51,796 --> 00:17:52,990
סטודנט 2: [? Ivay. ?]

400
00:17:52,990 --> 00:17:55,320
דוד J מלאן: איתן, יבוא עליו.

401
00:17:55,320 --> 00:17:55,820
לא?

402
00:17:55,820 --> 00:17:58,390
האם אני מקבל לא בסדר, כי גם
אחרי שאמרת את זה פעמיים?

403
00:17:58,390 --> 00:17:58,890
בואו למעלה.

404
00:17:58,890 --> 00:18:00,030
קשה לשמוע כאן.

405
00:18:00,030 --> 00:18:05,240

406
00:18:05,240 --> 00:18:05,740
אוקיי.

407
00:18:05,740 --> 00:18:07,190
ואני מצטער, מה שמך?

408
00:18:07,190 --> 00:18:07,680
>> סטודנט 2: [? Ivay. ?]

409
00:18:07,680 --> 00:18:08,790
>> [? דוד J מלאן: Ivay. ?] אוקיי.

410
00:18:08,790 --> 00:18:10,430
לעת עתה, אם לא
מוח, אתה GetString.

411
00:18:10,430 --> 00:18:11,013
>> סטודנט 2: אישור.

412
00:18:11,013 --> 00:18:11,797
מגניב.

413
00:18:11,797 --> 00:18:14,630
דוד J מלאן: אז אם אתה רוצה
לעמוד כאן רק לרגע,

414
00:18:14,630 --> 00:18:17,100
בואו נסתכל מעט
תכנית מורכבת יותר, ש

415
00:18:17,100 --> 00:18:18,670
עכשיו יש שלוש שורות של קוד.

416
00:18:18,670 --> 00:18:24,080
אז יש לנו, אחד, לציין את השם שלך באמצעות
printf; שני, קריאה לGetString,

417
00:18:24,080 --> 00:18:28,060
אחרי משימה ל
משתנים בשם, מחרוזת של, או בהשם של;

418
00:18:28,060 --> 00:18:31,260
ואז שיחה נוספת ל, printf,
אבל הפעם עם שתי כניסות.

419
00:18:31,260 --> 00:18:33,646
>> אז כבר עשינו מדינה
השם שלך, או לייתר דיוק, יש לנו

420
00:18:33,646 --> 00:18:34,770
כבר עשה שיחת printf.

421
00:18:34,770 --> 00:18:38,960
אז אני הולך לכתוב, מדינה את השם שלך.

422
00:18:38,960 --> 00:18:42,089
וכך, מה שאני הולך
עובר, printf, ברגע,

423
00:18:42,089 --> 00:18:43,005
די פשוט, זו.

424
00:18:43,005 --> 00:18:47,760
אז אם אתה רוצה ללכת קדימה ולצייר את זה
על המסך, זה הקלט שלך עכשיו.

425
00:18:47,760 --> 00:18:48,260
בסדר.

426
00:18:48,260 --> 00:18:51,160
ותשכח מחרוזת, עכשיו יש לנו
הקו שלנו של קוד כאן.

427
00:18:51,160 --> 00:18:54,470
אז ב, GetString, אנחנו צריכים
לקרוא למעשה, GetString.

428
00:18:54,470 --> 00:18:57,920
אז המטרה שלך בחיים היא רק ללכת
אל התזמורת, אם אתה יכול,

429
00:18:57,920 --> 00:18:58,980
ולקבל את שמו של מישהו.

430
00:18:58,980 --> 00:19:00,860
אבל בואו אתן לך
משהו לשים על זה.

431
00:19:00,860 --> 00:19:02,908
אם אתה רוצה, ללכת
קדימה ולקבל מחרוזת,

432
00:19:02,908 --> 00:19:05,241
לקבל את שמו של מישהו שב
פיסת נייר, אם אתה יכול.

433
00:19:05,241 --> 00:19:12,940

434
00:19:12,940 --> 00:19:13,530
>> בסדר.

435
00:19:13,530 --> 00:19:15,250
ואנו רואים, ברגע,
ששמו שאנחנו מקבלים.

436
00:19:15,250 --> 00:19:17,630
בינתיים, מה שאני הולך
יש לי מוכן, היא פיסה ריקה

437
00:19:17,630 --> 00:19:21,340
נייר, שבו, אני הולך
לאחסון כל מה ערכו

438
00:19:21,340 --> 00:19:25,752
הוא שGetString חוזר אליי,
אני, להיות משתנה מחרוזת בשם, ים.

439
00:19:25,752 --> 00:19:26,252
בסדר.

440
00:19:26,252 --> 00:19:27,293
אז מה יש לך כאן?

441
00:19:27,293 --> 00:19:27,950
ניק.

442
00:19:27,950 --> 00:19:28,450
בסדר.

443
00:19:28,450 --> 00:19:30,910
אז יש לנו את שמו של ניק כאן.

444
00:19:30,910 --> 00:19:33,750
אז זה מה שממש
הוחזר

445
00:19:33,750 --> 00:19:35,810
לי, כביכול, על ידי GetString.

446
00:19:35,810 --> 00:19:38,720
>> אני, עכשיו, אני הולך ל
לבצע עזב הצד

447
00:19:38,720 --> 00:19:43,440
ביטוי ש, שבו אני פשוט
להעתיק למטה, למטרות של היום, ניק.

448
00:19:43,440 --> 00:19:46,470
אז עכשיו, יש לי משתנים
בשם, זה, אחסון שמו של ניק.

449
00:19:46,470 --> 00:19:49,520
אני כבר נמסר ל
printf, טיעון קודם.

450
00:19:49,520 --> 00:19:52,800
אבל בשורה השלישית והאחרונה שלנו
קוד, אני באמת צריך את היד printf

451
00:19:52,800 --> 00:19:58,500
משהו קצת different--
"שלום,% s," n קו נטוי.

452
00:19:58,500 --> 00:20:01,510
>> וכך את השורה האחרונה אני הולך
לsend-- הדבר האחרון שאני

453
00:20:01,510 --> 00:20:03,060
הולך לרשום עכשיו, היא זו.

454
00:20:03,060 --> 00:20:06,310
אז שתי השורות של קוד, או
ולא את השורה האחרונה של קוד,

455
00:20:06,310 --> 00:20:10,690
שיחות לשני inputs--
אחד, זה, ושני, זה.

456
00:20:10,690 --> 00:20:13,330
אז אם פונקצית printf
עכשיו יכול לקחת אלה כקלט,

457
00:20:13,330 --> 00:20:16,000
תן לי לנקות את המסך בשבילך.

458
00:20:16,000 --> 00:20:17,250
למעשה לא, אתה יכול ללכת קדימה.

459
00:20:17,250 --> 00:20:19,333
נשאיר את זה, שכן
זה באותה התכנית.

460
00:20:19,333 --> 00:20:21,760

461
00:20:21,760 --> 00:20:27,380
אנחנו צריכים לראות, שלום, ניק.

462
00:20:27,380 --> 00:20:27,880
בסדר.

463
00:20:27,880 --> 00:20:29,670
אז זה היה לא מעט
חישוקים לקפוץ דרך, רק

464
00:20:29,670 --> 00:20:31,620
, לכתוב מדינה שלך
שם, ו, שלום, ניק.

465
00:20:31,620 --> 00:20:37,210
אבל הרעיון הפשוט הזה של פטירת הודעה,
פטירת קלט ופלט קבלה,

466
00:20:37,210 --> 00:20:40,430
הוא בדיוק המודל שאנחנו הולכים יש לי
אפילו את הפונקציות המורכבות ביותר.

467
00:20:40,430 --> 00:20:41,804
אז תודה לך כל כך הרבה לשניכם.

468
00:20:41,804 --> 00:20:43,730
יש לנו מתח יפה
כדור כאן בשבילך.

469
00:20:43,730 --> 00:20:48,890
ותודה לGetString
ומתנדבים printf כאחד.

470
00:20:48,890 --> 00:20:49,551
תודה.

471
00:20:49,551 --> 00:20:50,050
בסדר.

472
00:20:50,050 --> 00:20:50,966
תודה לשניכם.

473
00:20:50,966 --> 00:20:56,640

474
00:20:56,640 --> 00:21:00,430
>> אז אנחנו כבר מדברים על
עד כה, בעיקר על מיתרים.

475
00:21:00,430 --> 00:21:06,550
ומתברר שC יכול למעשה
להבין כמה סוגי נתונים שונים.

476
00:21:06,550 --> 00:21:08,860
למעשה, בואו ניקח
מסתכל על אלה כאן.

477
00:21:08,860 --> 00:21:12,490
אז C, והרבה שפות,
להבין דברים בשם תווים.

478
00:21:12,490 --> 00:21:16,852
Char הוא בדרך כלל
בית אחד, או שמונה סיביות.

479
00:21:16,852 --> 00:21:19,810
והוא מייצג דמות אחת,
כמו המכתב, או ההון

480
00:21:19,810 --> 00:21:21,990
מכתב, או האות קטנה
, או נקודה, סימן קריאה

481
00:21:21,990 --> 00:21:25,440
או כל דמות שאתה יכול להקליד ב
המקלדת שלך, ולפעמים אפילו יותר.

482
00:21:25,440 --> 00:21:26,795
אנחנו גם לקרות כדי לראות צף.

483
00:21:26,795 --> 00:21:31,160
לצוף הוא, בדרך כלל,
ערך של 32 סיביות, או ארבעה בתים

484
00:21:31,160 --> 00:21:33,660
כי שוב, בית אחד הוא שמונה סיביות.

485
00:21:33,660 --> 00:21:36,675
>> אז לצוף הוא ערך נקודה צפה,
משהו עם נקודה עשרונית.

486
00:21:36,675 --> 00:21:38,550
ואכן, זה מה ש
הסרט מדבר

487
00:21:38,550 --> 00:21:42,240
על כשהם דיברו על צפים
ערכי נקודה, כמה מספר קבוע של ביטים

488
00:21:42,240 --> 00:21:43,940
בשימוש כדי לייצג מספר אמיתי.

489
00:21:43,940 --> 00:21:45,740
אבל יש גם דברים שנקראים זוגות.

490
00:21:45,740 --> 00:21:47,860
אלה קיימים ב- Java,
אם אתה כבר לקח נגמ"שים,

491
00:21:47,860 --> 00:21:51,540
וכפי ששם כפול, לשמחתי
מרמז, הוא פעמיים גדולות כמו לצוף.

492
00:21:51,540 --> 00:21:54,540
זה עדיין מספר אמיתי,
רק יש לו יותר ביטים

493
00:21:54,540 --> 00:21:58,390
עם שיהיה יותר ויותר מדויקים,
או לאחסן מספרים גדולים עוד יותר.

494
00:21:58,390 --> 00:21:58,890
int הוא קל.

495
00:21:58,890 --> 00:22:00,181
דברנו על זה בפעם האחרונה.

496
00:22:00,181 --> 00:22:01,160
זה פשוט שלם.

497
00:22:01,160 --> 00:22:03,980
וזה בדרך כלל 32
ביטים, או ארבעה בתים.

498
00:22:03,980 --> 00:22:07,850
>> וכך, אם יש לך, בואו נראה עכשיו,
32 bits-- ועשינו את זה בשבוע 0,

499
00:22:07,850 --> 00:22:10,820
פעם כל כך briefly-- אם יש לך
32 סיביות, מה הגדול ביותר

500
00:22:10,820 --> 00:22:13,580
מספר שאתה יכול לייצג כמספר שלם?

501
00:22:13,580 --> 00:22:16,080
לתת או לקחת?

502
00:22:16,080 --> 00:22:18,380
זה כמו 4 מליארד דולרים,
וזה רק אם אנחנו

503
00:22:18,380 --> 00:22:20,690
ייצוג מספרים חיוביים בלבד.

504
00:22:20,690 --> 00:22:23,930
אם יש לך 32 סיביות, ואתה רוצה
לייצג מספרים שליליים, כמו גם,

505
00:22:23,930 --> 00:22:27,100
הטווח שלך הוא, בעצם, שלילי
2 מליארד למיליארדים חיובי 2.

506
00:22:27,100 --> 00:22:29,250
אבל בדרך כלל, נתחיל
ב 0 ללכת עד 4 מליארד דולרים.

507
00:22:29,250 --> 00:22:32,400
>> אתה לא צריך לדעת בדיוק, אבל
אנחנו יכולים לראות את זה, למעשה, אם אני רק

508
00:22:32,400 --> 00:22:36,400
לפתוח קצת מחשבון, כאן.

509
00:22:36,400 --> 00:22:41,070
אני יכול לעשות 2 32, ו
זה בדיוק עד כמה גדול,

510
00:22:41,070 --> 00:22:43,190
כמה ערכים שאתה יכול
מייצג, עם 32 סיביות.

511
00:22:43,190 --> 00:22:44,442
וזה בערך 4 מיליארדים.

512
00:22:44,442 --> 00:22:46,900
אז אנחנו נשמור רואים מספר ש
בכמה מקומות שונים.

513
00:22:46,900 --> 00:22:48,890
אבל אם אתה צריך עוד
מספרים מזה,

514
00:22:48,890 --> 00:22:51,670
מתברר של שם
משהו שנקרא ארוך ארוך.

515
00:22:51,670 --> 00:22:54,005
וארוך ארוך הוא
בדרך כלל 64 סיביות, ש

516
00:22:54,005 --> 00:22:56,380
אומר שזה סדר הגודל
אפילו גדול יותר מint.

517
00:22:56,380 --> 00:22:59,510
>> אז אני אפילו לא יכול לבטא את הכי גדול
מספר שאתה יכול לייצג,

518
00:22:59,510 --> 00:23:01,340
אבל זה במידה ניכרת יותר.

519
00:23:01,340 --> 00:23:05,190
עכשיו כצד, מבחינה היסטורית,
אם int הוא 32 סיביות,

520
00:23:05,190 --> 00:23:12,780
וארוך ארוך הוא 64 סיביות, איך
הגדול הוא ארוך, לא ארוך ארוך?

521
00:23:12,780 --> 00:23:16,500

522
00:23:16,500 --> 00:23:20,330
היית חושב שזה יותר מint
אבל אולי פחות ארוך ארוך ארוך מ,

523
00:23:20,330 --> 00:23:21,400
אבל זה תלוי בעצם.

524
00:23:21,400 --> 00:23:23,400
>> וכך מתברר אחד
של התסכולים מדי,

525
00:23:23,400 --> 00:23:26,830
עם כתיבת קוד במערכות מסוימות,
הוא שלא כל אלה סוגי נתונים

526
00:23:26,830 --> 00:23:28,440
יש לי ערכים נקבעו מראש.

527
00:23:28,440 --> 00:23:29,771
לפעמים זה ביטים רבים זה.

528
00:23:29,771 --> 00:23:31,020
לפעמים זה שפיסות רבות.

529
00:23:31,020 --> 00:23:32,750
אז אתה באמת צריך לדעת,
לפעמים, מה חומרה

530
00:23:32,750 --> 00:23:34,083
אתה מפעיל את התוכנה שלך על.

531
00:23:34,083 --> 00:23:36,960
למרבה המזל, שפות אחרות ו
סוגי נתונים אחרים שקיימים כיום,

532
00:23:36,960 --> 00:23:38,400
תאפשר לך להיות מדויק יותר.

533
00:23:38,400 --> 00:23:41,220
ובכן, ראינו מחרוזת,
וראינו בול, גם,

534
00:23:41,220 --> 00:23:43,960
אבל מסתבר לבוא אלה
רק עם ספריית CS50.

535
00:23:43,960 --> 00:23:46,240
אז אלה לא בנויים
לג אלה במקום,

536
00:23:46,240 --> 00:23:49,340
מגיע בקובץ שנקרא
CS50.h, שסופו של דבר ימצא

537
00:23:49,340 --> 00:23:51,831
לקלף את השכבות של.

538
00:23:51,831 --> 00:23:53,830
אבל לעת עתה, הם פשוט
סוגי נתונים נוספים.

539
00:23:53,830 --> 00:23:57,060
בול הוא אמת או שקר, ו
מחרוזת היא רצף של תווים,

540
00:23:57,060 --> 00:23:57,970
כמו מילה.

541
00:23:57,970 --> 00:24:01,690
עכשיו printf, שראינו, יש
מצייני מיקום,% s הוא אחד.

542
00:24:01,690 --> 00:24:05,430
וייתכן שתוכל, לחברה,
להסיק מדוגמאות אלה אחרים, איך

543
00:24:05,430 --> 00:24:07,720
יש לך יכול מציין מיקום
עבור סוגי נתונים שונים.

544
00:24:07,720 --> 00:24:11,150
לדוגמא, לקחת ניחוש, אם אתה
רציתי להדפיס את char בודד באמצעות

545
00:24:11,150 --> 00:24:15,270
printf, מציין המיקום הוא כנראה% ג.

546
00:24:15,270 --> 00:24:19,650
ואם אתה רוצה להדפיס
שלם עם מציין מיקום, אני%.

547
00:24:19,650 --> 00:24:25,150
LLD% הוא ערך עשרוני ארוך ארוך,
אבל ארוך ארוך, כך שממפה לזה.

548
00:24:25,150 --> 00:24:28,640
ואז f% לצפים
ערך נקודה או לכפול,

549
00:24:28,640 --> 00:24:31,270
אז לפעמים הם בשימוש מחדש
בהקשרים שונים.

550
00:24:31,270 --> 00:24:33,350
אז אנחנו תראו ולהשתמש
כמה מאותם לאורך זמן.

551
00:24:33,350 --> 00:24:36,420
וprintf ופונקציות אחרות גם
רצפי הבריחה של אחרים תמיכה,

552
00:24:36,420 --> 00:24:38,080
ולפעמים, אלה נחוצים.

553
00:24:38,080 --> 00:24:39,770
אז n הקו הנטוי הוא קו חדש.

554
00:24:39,770 --> 00:24:42,886
לא סרק, עושה כל אחד
רוצה לקחת דקירה?

555
00:24:42,886 --> 00:24:43,760
חבר קהל: כרטיסייה.

556
00:24:43,760 --> 00:24:44,551
דוד J מלאן: כרטיסייה.

557
00:24:44,551 --> 00:24:46,810
אז אם אתה באמת רוצה
להדפיס את כרטיסייה, לא

558
00:24:46,810 --> 00:24:49,940
מספר קבוע של חללים אך בפועל
אופי כרטיסייה, אתה לא פגעת,

559
00:24:49,940 --> 00:24:53,490
כרטיסייה, מקש במקלדת, בדרך כלל,
אתה בעצם לעשות לא קו נטוי.

560
00:24:53,490 --> 00:24:57,750
ציטוט כפול קו נטוי,
למה שאני אי פעם היה רוצה את זה?

561
00:24:57,750 --> 00:24:58,250
נכון?

562
00:24:58,250 --> 00:25:00,417
למה אני לא יכול פשוט להקליד
ציטוט כפול על המקלדת שלי?

563
00:25:00,417 --> 00:25:02,124
חבר קהל:
כי, אחרת, זה

564
00:25:02,124 --> 00:25:04,830
הולך חושב שזה הסוף
של רצון [ההדפסה שלך? טקסט. ?]

565
00:25:04,830 --> 00:25:05,420
>> דוד J מלאן: בדיוק.

566
00:25:05,420 --> 00:25:07,211
זכור, עם שלנו
דוגמאות printf, כאשר אנו

567
00:25:07,211 --> 00:25:10,075
עברו לprintf בקלט,
בצד השמאל של שמחרוזת הקלט

568
00:25:10,075 --> 00:25:12,950
ועל זכותם של הקלט ש
האביב, כמובן, היה ציטוט כפול.

569
00:25:12,950 --> 00:25:16,270
אם הקלט שלך יש כפול
ציטוט באמצע ש,

570
00:25:16,270 --> 00:25:18,920
פוטנציאל למחשב
מתבלבל, כמו ל,

571
00:25:18,920 --> 00:25:20,760
עושה ציטוט הכפול הזה
שייך באמצע?

572
00:25:20,760 --> 00:25:22,150
עם השמאל אחד האם זה שייך?

573
00:25:22,150 --> 00:25:23,566
עם האדם הנכון האם זה שייך?

574
00:25:23,566 --> 00:25:26,780
וכך, אם אתה רוצה לעשות את זה סופר
ברור, אתה עושה קו נטוי ציטוט כפול,

575
00:25:26,780 --> 00:25:30,480
כך שזה נמלט, כביכול, ו
זה לא conflated למשהו אחר.

576
00:25:30,480 --> 00:25:34,400
ויש עוד כמה אחר כאן,
r קו נטוי, בגרשיים בודדים, 0,

577
00:25:34,400 --> 00:25:36,510
כי אנו עשויים לראות לאורך זמן, כמו גם.

578
00:25:36,510 --> 00:25:37,760
ועכשיו, מה לגבי פונקציות?

579
00:25:37,760 --> 00:25:41,630
>> אז פעולות שאנחנו יכולים לקחת עד כה
בשפה זו, C, גם, שראינו,

580
00:25:41,630 --> 00:25:44,320
printf, כמובן, וכל
של אחרים על המסך,

581
00:25:44,320 --> 00:25:47,140
כאן, שאנו נשתמש ל
השבועות הראשונים של הקורס בלבד,

582
00:25:47,140 --> 00:25:48,485
תבוא ספריית CS50.

583
00:25:48,485 --> 00:25:51,850
והם עושים את זה הרבה יותר קל, ב
C, למעשה כדי לקבל קלט משתמש.

584
00:25:51,850 --> 00:25:54,200
מתברר כי ב- C, ו
בכנות בכמה שפות,

585
00:25:54,200 --> 00:25:57,450
זה כאב אמיתי בצוואר לעשות
משהו פשוט, כמו לבקש מהמשתמש

586
00:25:57,450 --> 00:26:01,310
למקלדת, לקלטו או שלה.

587
00:26:01,310 --> 00:26:03,240
וכך בפונקציות אלה לעשות את זה יותר קל.

588
00:26:03,240 --> 00:26:05,472
>> ויש לה גם שגיאה
בדיקה לאורך כל דרך,

589
00:26:05,472 --> 00:26:07,180
כך, שכאשר אתה
זוכר ביום רביעי, אנחנו

590
00:26:07,180 --> 00:26:09,740
ראה, לנסות שוב, אזהרה,
כשלא שיתפתי פעולה,

591
00:26:09,740 --> 00:26:11,700
ואני הקלדתי מילה, במקום מספר?

592
00:26:11,700 --> 00:26:15,402
אנחנו עשינו את העבודה שחורה מוקדם
על מנת לוודא שהמשתמשים משתפים פעולה.

593
00:26:15,402 --> 00:26:17,860
אבל אלה הם רק אימון
גלגלים שסופו של דבר אנו,

594
00:26:17,860 --> 00:26:19,640
ובמהירות, להמריא.

595
00:26:19,640 --> 00:26:22,630
>> אז לסיכום, אם כן,
בואו ניקח מבט מהיר,

596
00:26:22,630 --> 00:26:26,620
כמו שעשינו עם שריטה, ב
כמה מבנים הקנונית בג

597
00:26:26,620 --> 00:26:28,580
זה נועד, סוג
של, להיות סיור סופה,

598
00:26:28,580 --> 00:26:30,990
רק כך יש לך התייחסות
ושראית את הדברים בהתחלה.

599
00:26:30,990 --> 00:26:34,100
אבל אז אנחנו מסתכלים קידוד בפועל
להשתמש בחלק מאבני בניין אלה.

600
00:26:34,100 --> 00:26:36,710
כל כך הרבה כמו בגרד,
כאשר היינו לנו הצהרות כמו,

601
00:26:36,710 --> 00:26:41,570
אומר או, לחכות, בC, יש לנו
פונקציות, כמו גם, כמו printf.

602
00:26:41,570 --> 00:26:45,350
>> אם אנחנו רוצים להביע את מצב
ב- C, זה דומה, ברוח,

603
00:26:45,350 --> 00:26:47,840
שלפיסת הפאזל ש
נראה כמו זה בהתחלה.

604
00:26:47,840 --> 00:26:49,850
אבל במקום זה, אנחנו
פשוטו כמשמעו רק לכתוב, אם.

605
00:26:49,850 --> 00:26:51,830
ולאחר מכן, בסוגריים,
אנחנו שמים את מצב,

606
00:26:51,830 --> 00:26:54,807
שבו המצב שהוא מה שנעשינו
קורא, שוב, ביטוי בוליאני.

607
00:26:54,807 --> 00:26:56,390
ושוב, זה סוג של פסאודו קוד.

608
00:26:56,390 --> 00:26:58,830
ואכן, // היא תגובה.

609
00:26:58,830 --> 00:27:00,550
זה רק מילות אנגלית לעצמי.

610
00:27:00,550 --> 00:27:03,000
אבל זה בכלל
מבנה, אם, מצב.

611
00:27:03,000 --> 00:27:05,220
אבל אנחנו תראו בטון
דוגמאות ברגע.

612
00:27:05,220 --> 00:27:07,960
>> אם אתה רוצה יש לי
מזלג דו-כיווני בכביש,

613
00:27:07,960 --> 00:27:11,740
כמו שעשינו עם המתנדב שלנו ב
יום רביעי, אתה יכול להיות, אם אחר.

614
00:27:11,740 --> 00:27:16,020
ואם אתה רוצה להיות שלישי ו
מצב סופי, או מצב ברירת מחדל,

615
00:27:16,020 --> 00:27:19,006
אתה יכול לקבל רק בלוק אחר, יש.

616
00:27:19,006 --> 00:27:21,880
ובאופן דומה, עם ביטויי בוליאני,
אתה יכול, ו, אותם יחד.

617
00:27:21,880 --> 00:27:24,296
וראינו ביום רביעי, ש
זה לא אמפרסנד יחיד,

618
00:27:24,296 --> 00:27:28,220
זה שני, מסיבות ברמה נמוכה יותר ש
סופו של הדבר יראו ולשחק איתו.

619
00:27:28,220 --> 00:27:30,410
או-ing דברים ביחד
הוא 2 קווים אנכיים.

620
00:27:30,410 --> 00:27:32,240
על מקלדת ארה"ב, זה
הוא בדרך כלל מפתח

621
00:27:32,240 --> 00:27:35,730
עם מקש Shift מעל
שלך מקש Enter או Return מפתח.

622
00:27:35,730 --> 00:27:38,620
>> ואז יש את הדברים האלה ש
אנו נשתמש אולי פעם או פעמיים.

623
00:27:38,620 --> 00:27:42,570
הם פונקציונלי שווי ערך ל
מה אתה יכול לעשות עם, אם, אם אחר,

624
00:27:42,570 --> 00:27:44,950
אחר אם אחר, לבנות,
אבל הם נקראים מתג.

625
00:27:44,950 --> 00:27:48,020
הם נראים שונים מאוד, אבל אנחנו
לראות בחלק מקוד ההפצה שלנו,

626
00:27:48,020 --> 00:27:51,890
עבור קבוצת בעיה בעתיד, סביר להניח,
שזה לפעמים פשוט יפה

627
00:27:51,890 --> 00:27:54,060
דרך להביע כל
חבורה של תנאים,

628
00:27:54,060 --> 00:27:57,590
מבלי הרבה סוגריים מסולסלים ו
הרבה סוגריים וכניסה.

629
00:27:57,590 --> 00:28:01,910
אבל הם נותנים לנו לא יותר
כוח מאשר יש לנו כבר.

630
00:28:01,910 --> 00:28:02,550
ועכשיו לולאות.

631
00:28:02,550 --> 00:28:05,020
וזה אחד, נבחן
בקצת יותר לאט.

632
00:28:05,020 --> 00:28:08,470
אבל אז, נתחיל להשתמש אלה,
במיוחד עבור מי שמכיר כבר.

633
00:28:08,470 --> 00:28:13,830
זוהי הדרך הקנונית, אם להפליא
דרך מסתורית, לכתוב לולאה בג

634
00:28:13,830 --> 00:28:15,896
>> עכשיו לולאה בScratch הייתה
די פשוט.

635
00:28:15,896 --> 00:28:17,020
יש לך, לנצח, בלוק.

636
00:28:17,020 --> 00:28:19,760
יש לך, חזור על, בלוק עם
רק מספר שאתה צריך להקליד.

637
00:28:19,760 --> 00:28:22,220
ועם ללולאה,, אתה יכול
ליישם את שני רעיונות אלה,

638
00:28:22,220 --> 00:28:23,595
אבל זה קצת יותר טכני.

639
00:28:23,595 --> 00:28:25,994
אבל בכנות, זה גם
יחסית פשוט.

640
00:28:25,994 --> 00:28:28,160
ברגע שאתה יודע את סדר
פעולות, אתה ממש

641
00:28:28,160 --> 00:28:30,910
הם פשוט הולכים לחבר ערכים
ולומר למחשב מה לעשות.

642
00:28:30,910 --> 00:28:32,800
אז הנה דוגמא.

643
00:28:32,800 --> 00:28:38,040
זה לולאה ש, די
פשוט, סופר ממספר אחת למעלה

644
00:28:38,040 --> 00:28:40,187
דרך אחר.

645
00:28:40,187 --> 00:28:42,020
ורק על ידי צצה
בזה, גם אם יש לך

646
00:28:42,020 --> 00:28:44,660
ללא ניסיון קודם עם
שפה זו, מה מספר

647
00:28:44,660 --> 00:28:46,920
אין זה כנראה מתחיל לספור ב?

648
00:28:46,920 --> 00:28:47,730
אישור, 0.

649
00:28:47,730 --> 00:28:50,240
ואני מנחש שזה בגלל שאתה
רואה שיש int ואני,

650
00:28:50,240 --> 00:28:51,073
שהוא משתנה.

651
00:28:51,073 --> 00:28:52,390
זה אותחל ל0.

652
00:28:52,390 --> 00:28:55,670
>> ומאוחר יותר, זה נראה כמו
אנחנו עוברים printf, ערך.

653
00:28:55,670 --> 00:28:58,000
ואכן, עשיתי קצת טעות דפוס כאן.

654
00:28:58,000 --> 00:28:59,850
אבל זה קבוע בקלות.

655
00:28:59,850 --> 00:29:02,390
הרשה לי להוסיף ב, אני כאן.

656
00:29:02,390 --> 00:29:06,150
עכשיו יש לנו בן printf
עבר שערך מציין מיקום.

657
00:29:06,150 --> 00:29:08,299
ומה קורה לספור דרך?

658
00:29:08,299 --> 00:29:08,840
קהל: 50.

659
00:29:08,840 --> 00:29:09,340
50.

660
00:29:09,340 --> 00:29:10,160
49.

661
00:29:10,160 --> 00:29:10,910
דוד J מלאן: 49.

662
00:29:10,910 --> 00:29:13,340
50 אז, במבט ראשון, נראה תקין.

663
00:29:13,340 --> 00:29:16,990
אבל זה, מתברר, הולך להיות
המצב שלנו שאנחנו להמשיך לבדוק.

664
00:29:16,990 --> 00:29:21,740
ואנחנו הולכים לעצור פעם אחת
אני כבר לא פחות מ -50.

665
00:29:21,740 --> 00:29:24,920
אז לולאה זו, לעומת זאת, צריכה
לבצע, כל עוד הוא אני פחות מ -50.

666
00:29:24,920 --> 00:29:28,891
אבל ברגע שזה הופך להיות 50, או 51,
או גרוע מזה, זה צריך להפסיק באופן אוטומטי.

667
00:29:28,891 --> 00:29:29,390
בסדר.

668
00:29:29,390 --> 00:29:31,200
>> אז מה בעצם קורה כאן?

669
00:29:31,200 --> 00:29:33,160
אז זה בסדר
פעולות ללולאה.

670
00:29:33,160 --> 00:29:35,440
אחד, יש לך את
מה שנקרא אתחול.

671
00:29:35,440 --> 00:29:38,264
נתח מודגש צהוב זה
קוד מבוצע ראשון,

672
00:29:38,264 --> 00:29:40,930
ויש לה ההשפעה ש, ל
יום רביעי, אתה בטח מתאר לעצמי.

673
00:29:40,930 --> 00:29:45,500
זה יוצר משתנה בשם i ו
חנויות במשתנות שהערך 0.

674
00:29:45,500 --> 00:29:47,560
אז הוא אני 0 בנקודה זו בסיפור הזה.

675
00:29:47,560 --> 00:29:49,680
>> הדבר הבא ש
קורה במבנה זה,

676
00:29:49,680 --> 00:29:51,540
הוא שהמצב מקבל בדק.

677
00:29:51,540 --> 00:29:54,325
אז אני בודק באופן מיידי,
הוא אני פחות מ 50?

678
00:29:54,325 --> 00:29:57,700
וכמובן, התשובה
לעת עתה הוא, ללא ספק, כן.

679
00:29:57,700 --> 00:30:00,710
כן, כי אני הוא 0, ו
זה בוודאי פחות מ -50.

680
00:30:00,710 --> 00:30:03,866
אז מה קורה, הוא שזה
שורת קוד מקבלת להורג.

681
00:30:03,866 --> 00:30:06,740
ולמעשה, אם יש מספר רב של
שורות קוד בסוגריים המסולסלים אלה,

682
00:30:06,740 --> 00:30:09,020
כל מה שהם מקבלים להורג בזה אחר זה.

683
00:30:09,020 --> 00:30:11,450
>> ובהשפעה כאן, הוא
ככל הנראה, להדפיס

684
00:30:11,450 --> 00:30:15,365
אני המספר, שהוא הולך
להיות 0, ולאחר מכן 1, ולאחר מכן 2.

685
00:30:15,365 --> 00:30:15,865
אבל למה?

686
00:30:15,865 --> 00:30:17,410
למה זה לקבל מוגדל?

687
00:30:17,410 --> 00:30:20,680
ובכן, הדבר הרביעי ש
שקורה הוא שתחביר זה

688
00:30:20,680 --> 00:30:22,610
מקבל להורג, לאחר פסיק.

689
00:30:22,610 --> 00:30:27,506
i ++ היא דרך קצרנות לומר;
לקחת את הערך של i, ולהוסיף 1 לזה;

690
00:30:27,506 --> 00:30:30,380
ואז בפעם הבאה, להוסיף
1 אליו; והפעם הבאה,

691
00:30:30,380 --> 00:30:31,330
להוסיף 1 לזה.

692
00:30:31,330 --> 00:30:33,640
>> אז אם אנחנו ממשיכים ללכת,
מה הולך לקרות

693
00:30:33,640 --> 00:30:35,890
הבא אני לא הולך ל
לאתחל אני אי פעם שוב.

694
00:30:35,890 --> 00:30:38,290
אם אני כל הזמן אתחול
אני 0, דוגמא זו

695
00:30:38,290 --> 00:30:41,110
אף פעם לא היה בסופו, כי
אני יהיה תקוע על 0.

696
00:30:41,110 --> 00:30:43,870
אבל מה שהולך לקרות הוא
כי התנאי ייבדק,

697
00:30:43,870 --> 00:30:54,280
שורת קוד יקבל להורג,
אני יהיה מוגדל,

698
00:30:54,280 --> 00:30:56,970
מצב ייבדק,
קוד יקבל להורג.

699
00:30:56,970 --> 00:30:59,790
וזה המשיך רכיבה על אופניים שוב,
ושוב, ושוב,

700
00:30:59,790 --> 00:31:03,340
עד ש++ גורם ערך של 50.

701
00:31:03,340 --> 00:31:05,870
>> המצב אז אומר,
50 פחות מ -50?

702
00:31:05,870 --> 00:31:09,360
התשובה, כמובן, היא לא, ו
כך שכל הקוד מפסיק ביצוע.

703
00:31:09,360 --> 00:31:13,020
ואם יש לך יותר קוד על המסך
למטה, זה מה שקורה עכשיו.

704
00:31:13,020 --> 00:31:17,530
זה קופץ החוצה של סוגריים המסולסלים אלה ו
ממשיך להדפיס יותר אחרי זה.

705
00:31:17,530 --> 00:31:20,470
>> אז בדיחה עכשיו, מFoxtrot, ש
אתה אולי עכשיו תבין.

706
00:31:20,470 --> 00:31:30,810

707
00:31:30,810 --> 00:31:31,560
זה תמיד מצחיק.

708
00:31:31,560 --> 00:31:34,110
זה כמו המגחך
סוג של לחלחל,

709
00:31:34,110 --> 00:31:38,370
ואז אתה מבין שאתה לא צריך
להיות צוחקים על הומור כזה.

710
00:31:38,370 --> 00:31:41,160
אבל יש כמה ממסעדה
כאן, מבחינה פדגוגית, מדי.

711
00:31:41,160 --> 00:31:43,577
אז מתברר שאני
חסר חתיכת התחביר,

712
00:31:43,577 --> 00:31:45,410
או Foxtrot של חסר
חתיכת התחביר כאן.

713
00:31:45,410 --> 00:31:48,076
מה שחסר, שהיו לנו
בכל דוגמא אחרת, עד כה?

714
00:31:48,076 --> 00:31:51,599

715
00:31:51,599 --> 00:31:53,390
חזור, הוא שם, כל כך
זה משהו אחר,

716
00:31:53,390 --> 00:31:54,440
שנחזור לזמן קצר.

717
00:31:54,440 --> 00:31:55,398
מה שחסר, למרות ש?

718
00:31:55,398 --> 00:31:55,908
כן.

719
00:31:55,908 --> 00:31:58,150
>> חבר קהל:
אתחול של [לא ברור].

720
00:31:58,150 --> 00:31:58,470
>> דוד J מלאן: אישור.

721
00:31:58,470 --> 00:31:58,980
אז כן.

722
00:31:58,980 --> 00:32:03,210
אז בעצם, זה הוא-- ובכן,
וספירה מאותחלת

723
00:32:03,210 --> 00:32:05,470
למעלה, או לייתר דיוק, הכריז מעל.

724
00:32:05,470 --> 00:32:06,960
אז זה הוא דרך נוספת של עושה את זה.

725
00:32:06,960 --> 00:32:08,685
אבל לא בקו אחד זה כאילו זה בתוקף.

726
00:32:08,685 --> 00:32:09,310
מה דעתך על כאן?

727
00:32:09,310 --> 00:32:10,196
>> חבר קהל: האם זה סוגריים המסולסלים?

728
00:32:10,196 --> 00:32:10,640
>> דוד J מלאן: כן.

729
00:32:10,640 --> 00:32:12,080
אז הסוגריים המסולסלים חסרים.

730
00:32:12,080 --> 00:32:15,495
אבל הקוד הזה, אני מתכוון, לאשראי שלהם,
הוא למעשה, מבחינה תחבירית בתוקף.

731
00:32:15,495 --> 00:32:17,610
מתברר, שאתה לא
צריכים סוגריים המסולסלים

732
00:32:17,610 --> 00:32:21,691
אם יש לך רק שורה אחת של קוד ש
אתה רוצה לבצע בתוך הלולאה.

733
00:32:21,691 --> 00:32:24,190
עכשיו אנחנו תמיד, בכיתה וב
כל קוד ההפצה שלנו,

734
00:32:24,190 --> 00:32:26,730
כוללים סוגריים המסולסלים
בכל מקרה, רק למען הבהירות.

735
00:32:26,730 --> 00:32:29,010
אבל מבין שבספרי לימוד
ודוגמאות באינטרנט,

736
00:32:29,010 --> 00:32:31,300
ייתכן מאוד לראות מתולתל
פלטה חסרה מתישהו.

737
00:32:31,300 --> 00:32:34,850
וזה בסדר, אם מה שאתה
יש מסוכסך ונועד

738
00:32:34,850 --> 00:32:38,650
רק שורה אחת של קוד, ולא
מספר שורות הקוד, שעלול להיות.

739
00:32:38,650 --> 00:32:39,150
בסדר.

740
00:32:39,150 --> 00:32:44,500
כל כך קשור לנושא של
חוסר דיוק, הוא נושא של גלישה,

741
00:32:44,500 --> 00:32:48,560
במובן זה, דומה,
יש לי מספרים שלמים גבולות אליהם

742
00:32:48,560 --> 00:32:49,970
בדיוק כמו ערכי נקודה צפה?

743
00:32:49,970 --> 00:32:53,120
בעולם נקודה צפה
ערכים, אנחנו יכולים רק להיות כל כך מדויקים,

744
00:32:53,120 --> 00:32:55,710
לאחר ש, לפעמים
דברים רעים יכולים לקרות,

745
00:32:55,710 --> 00:32:57,760
והתוכניות שלנו יכולות להיות מרכבה וטעייה.

746
00:32:57,760 --> 00:33:00,050
עכשיו גם עם מספרים שלמים,
אתה יכול נתקלת בבעיות.

747
00:33:00,050 --> 00:33:03,820
עכשיו שלם אין
נקודה עשרונית או מספרים אחרי זה.

748
00:33:03,820 --> 00:33:07,130
זה רק מספר טבעי, בדרך כלל.

749
00:33:07,130 --> 00:33:09,430
אז מה יכול להשתבש עם int?

750
00:33:09,430 --> 00:33:12,210
אם אני משתמש int ל
רוזן, מה יכול להשתבש?

751
00:33:12,210 --> 00:33:13,230
נראה הרבה יותר פשוט.

752
00:33:13,230 --> 00:33:13,873
כן.

753
00:33:13,873 --> 00:33:16,240
>> חבר קהל: אם
מספר מקבל [לא ברור]

754
00:33:16,240 --> 00:33:17,073
>> דוד J מלאן: כן.

755
00:33:17,073 --> 00:33:20,820
מה אם סופר כל כך גבוה, ש
לא יכול להביע את שהמספר גדול באמת.

756
00:33:20,820 --> 00:33:21,320
נכון?

757
00:33:21,320 --> 00:33:23,910
בשלב מסוים, אתה הולך
יעלה על הגבולות

758
00:33:23,910 --> 00:33:27,077
של ערך של 32 סיביות או ערך של 64 סיביות.

759
00:33:27,077 --> 00:33:29,410
עכשיו שוב, אני לא בטוח איך
לבטא ערך של 64 סיביות,

760
00:33:29,410 --> 00:33:32,230
אבל אני יודע שעם שלם של 32 סיביות,
הערך הגדול ביותר שהוא יכול להיות,

761
00:33:32,230 --> 00:33:35,490
אם זה רק חיובי
ערכים, הוא כ -4 מליארד דולרים.

762
00:33:35,490 --> 00:33:39,000
אז אם אני מנסה לספור עד 5 מיליארדים,
משהו הולך לקרות.

763
00:33:39,000 --> 00:33:41,050
אבל בואו נראה מה, למעשה, יכול לקרות.

764
00:33:41,050 --> 00:33:44,570
בעולם של מספר שלם
גלישה, שבו אתה, במובן מסוים,

765
00:33:44,570 --> 00:33:48,270
גדות הקיבולת של
שלם, מה שעלול לקרות?

766
00:33:48,270 --> 00:33:51,190
>> אז הנה מספר בינארי,
זה מחזיר אותנו ל0.

767
00:33:51,190 --> 00:33:54,630
זה כל של 1, ומצייני המיקום
שם, הן סמכויות של 2,

768
00:33:54,630 --> 00:33:55,980
אז זה בינארי.

769
00:33:55,980 --> 00:33:59,416
אז אלה הם 8, 1 סיביות על המסך.

770
00:33:59,416 --> 00:34:01,290
ואם אתה זוכר או
אתה עושה במהירות במתמטיקה,

771
00:34:01,290 --> 00:34:06,074
מה הערך שאינו מיוצג
כאן עם שמונה 1 הביטים האלה?

772
00:34:06,074 --> 00:34:06,950
255.

773
00:34:06,950 --> 00:34:09,260
ואפילו אם לא היית די בטוח
של המתמטיקה, אתה יכול לעשות את זה.

774
00:34:09,260 --> 00:34:10,550
או שאתה יכול פשוט סוג
סיבה דרכו,

775
00:34:10,550 --> 00:34:12,633
חכה רגע, אם אני
מייצג ערך 8 סיביות,

776
00:34:12,633 --> 00:34:17,750
ויש לי 256 ערכים אפשריים,
אבל הראשון שבם הוא 0,

777
00:34:17,750 --> 00:34:19,909
אני רק יודע ש
גדול הולך להיות 255,

778
00:34:19,909 --> 00:34:21,510
וזה מה שזה אחד יכול להיות.

779
00:34:21,510 --> 00:34:26,060
>> אז נניח שאני מנסה להוסיף 1 לערך זה.

780
00:34:26,060 --> 00:34:28,750
מה היית עושה בכיתה
בית הספר בעת הוספת 1, וזה

781
00:34:28,750 --> 00:34:31,139
לא ממש בכושר, כי
אתה צריך לסחוב 1?

782
00:34:31,139 --> 00:34:34,380
מהו מספר זה הולך
להפוך כאשר אתה מוסיף 1?

783
00:34:34,380 --> 00:34:37,030
זה הולך להיות 0.

784
00:34:37,030 --> 00:34:37,530
נכון?

785
00:34:37,530 --> 00:34:41,139
כי אם היה לך bits-- יותר ואני יהיה
אנסה, סוג של, הקלד אותו כאן--

786
00:34:41,139 --> 00:34:44,710
אם היו לנו יותר ביטים, מה ש
יכל לעשות כאן הוא להוסיף 1,

787
00:34:44,710 --> 00:34:47,370
ואז הייתי מקבל את זה.

788
00:34:47,370 --> 00:34:48,739
אופס.

789
00:34:48,739 --> 00:34:52,250
הייתה לנו קצת 1 כל הדרך לכאן.

790
00:34:52,250 --> 00:34:55,530
>> אבל אם זה סופי
ערך, זה רק 8 סיביות,

791
00:34:55,530 --> 00:34:57,480
וזה לפני שנקבע
על ידי המחשב,

792
00:34:57,480 --> 00:34:59,370
כי 1 הוא למעשה לא קיימים.

793
00:34:59,370 --> 00:35:00,980
זה פשוט סוג של נופל מצוק.

794
00:35:00,980 --> 00:35:05,480
ולכן אם אתה מוסיף 1 עד 255, מה ש
ערך שאתה כנראה מקבל?

795
00:35:05,480 --> 00:35:06,180
0.

796
00:35:06,180 --> 00:35:09,700
וכך מספרים בטעות,
ואולי, שלא במתכוון,

797
00:35:09,700 --> 00:35:12,040
בסופו של עטיפה סביב כמו זה.

798
00:35:12,040 --> 00:35:14,079
אז מה יכול להיות המשמעות של זה?

799
00:35:14,079 --> 00:35:15,620
ובכן, יש כמה דברים שונים.

800
00:35:15,620 --> 00:35:18,751
אז אחת, זה בסופו של מחפש
כמו 0, שלא במתכוון,

801
00:35:18,751 --> 00:35:20,750
אבל אתה סוג של יכול לראות,
אפילו בעולם האמיתי,

802
00:35:20,750 --> 00:35:23,416
לטוב או לרע,
גילויים של הרעיון הזה של גבול.

803
00:35:23,416 --> 00:35:26,630
לדוגמא, כל אחד מכם ש
אי פעם שיחק לגו מלחמת כוכבים,

804
00:35:26,630 --> 00:35:28,880
האם מישהו יודע במקרה
המספר המרבי של מטבעות

805
00:35:28,880 --> 00:35:32,032
אתה יכול לאסוף בגו מלחמת כוכבים?

806
00:35:32,032 --> 00:35:35,640
קח ניחוש המבוסס על
השאלות מובילות של היום.

807
00:35:35,640 --> 00:35:39,140
הוא גדול יותר 256 או 255.

808
00:35:39,140 --> 00:35:40,330
זה 4 מיליארדים.

809
00:35:40,330 --> 00:35:42,080
אז מתברר, ו
יש כמה אנשים--

810
00:35:42,080 --> 00:35:46,080
כמה night-- האחרון אישר googling
מקבל 4 מליארד מטבעות זהב,

811
00:35:46,080 --> 00:35:47,730
או מה שלא, בגו מלחמת כוכבים.

812
00:35:47,730 --> 00:35:49,860
למרות שככל הנראה, יש
דרך להערים המשחק,

813
00:35:49,860 --> 00:35:53,222
יש באג או תכונה, המאפשר לך
רק צובר המון המון נקודות.

814
00:35:53,222 --> 00:35:54,930
אבל הגדול ביותר האפשרי
ערך, לפי

815
00:35:54,930 --> 00:35:58,360
לצילום מסך שלי מישהו
מצאו באינטרנט, הוא אכן, 4 מיליארדים.

816
00:35:58,360 --> 00:35:59,240
>> עכשיו למה זה?

817
00:35:59,240 --> 00:36:03,040
זה בדיוק 4 מליארד דולרים,
כנראה בגלל שמישהו החליט,

818
00:36:03,040 --> 00:36:05,500
שכתב את המשחק הזה,
שהם יכולים לעשות 4 מליארד דולרים,

819
00:36:05,500 --> 00:36:07,340
משהו, משהו, משהו,
כמו הערך שמתי את

820
00:36:07,340 --> 00:36:10,256
עם המחשבון קודם לכן, אבל
זה פשוט נקי קטן לבני אדם

821
00:36:10,256 --> 00:36:12,610
לומר את המספר המרבי
של coins-- או חתיכים,

822
00:36:12,610 --> 00:36:14,860
כפי שהם מכנים them-- ש
יכול לאסוף הוא 4 מליארד דולרים.

823
00:36:14,860 --> 00:36:16,290
וכך, למה זה?

824
00:36:16,290 --> 00:36:20,310
איך הוא משחק לגו
יישום הדלפק

825
00:36:20,310 --> 00:36:23,420
זה שמירה על המסלול של
מספר המטבעות שיש לך?

826
00:36:23,420 --> 00:36:24,266
הם משתמשים במה?

827
00:36:24,266 --> 00:36:26,390
חבר קהל: זה מפסיק
ספירה לאחר 4 מיליארדים.

828
00:36:26,390 --> 00:36:27,720
דוד J מלאן: זה מפסיק
ספירה לאחר 4 מליארד דולרים,

829
00:36:27,720 --> 00:36:29,525
מה שאומר שאתה יכול
להסיק, כמתכנת,

830
00:36:29,525 --> 00:36:31,960
כי הם כנראה
באמצעות מספר שלם 32 ביט.

831
00:36:31,960 --> 00:36:35,380
כמו מתכנת, פשוטו כמשמעו, רק
מוקלד, int, בקוד שלו או שלה,

832
00:36:35,380 --> 00:36:39,620
וזה הסוג של משתנה ש
הם משתמשים לאחסון הקוד של מישהו.

833
00:36:39,620 --> 00:36:42,230
אז יש ביטויים אחרים
סוגים של מגבלות אלה.

834
00:36:42,230 --> 00:36:45,063
>> אז אני לא שיחקתי game-- זה
ואני קורא על ההיסטוריה

835
00:36:45,063 --> 00:36:48,470
כדי לאשר כmuch-- אבל ב
גרסה המקורית של ציביליזציה, שבו

836
00:36:48,470 --> 00:36:53,240
אתה כנראה אינטראקציה זה עם זה
אחר ויכול לנהל מלחמה או שלום יש לי,

837
00:36:53,240 --> 00:36:56,590
גנדי היה אמור להיות אחד מ
הדמויות השלוות ביותר, כפי ש

838
00:36:56,590 --> 00:36:59,280
מבין את זה, בראשון
גרסה של ציביליזציה.

839
00:36:59,280 --> 00:37:03,250
ואכן, בסולם של 1 עד 10,
התוקפנות שלו הייתה רק 1.

840
00:37:03,250 --> 00:37:05,620
אז אי פעם כל כך בלשון המעטה
אגרסיווי, ככל הנראה.

841
00:37:05,620 --> 00:37:11,590
>> אבל בשלב מסוים, אתה כנראה יכול
להתקין דמוקרטיה בגאוגרפיה שלך.

842
00:37:11,590 --> 00:37:14,900
ואם תתקינו דמוקרטיה
לגרסה של המשחק שלך,

843
00:37:14,900 --> 00:37:17,320
אז רמת התוקפנות שלך יורדת.

844
00:37:17,320 --> 00:37:18,460
זה דבר טוב.

845
00:37:18,460 --> 00:37:20,890
אנשים שלווים יותר
ככל הנראה, במצב ש.

846
00:37:20,890 --> 00:37:23,190
אבל ככל הנראה, מישהו עשה
אין לי, אם, מצב

847
00:37:23,190 --> 00:37:24,780
בגרסה המקורית של הקוד.

848
00:37:24,780 --> 00:37:30,650
>> אז רמת התוקפנות של גנדי הלכה מ
1 חיובי, מינוס 2, לשלילי 1,

849
00:37:30,650 --> 00:37:33,840
אבל המשחק לא
להבין מספרים שליליים.

850
00:37:33,840 --> 00:37:38,680
אז מה שקרה הוא תוקפנותו של גנדי
רמה הלכה מ1, 0, 1 לשלילית,

851
00:37:38,680 --> 00:37:40,900
שהיה האפקט של
עטיפה סביב להיות

852
00:37:40,900 --> 00:37:44,690
האופי האגרסיבי ביותר
במשחק, בשווי של 255,

853
00:37:44,690 --> 00:37:46,630
בסולם של 1 עד 10.

854
00:37:46,630 --> 00:37:49,887
ומאז, יש כבר
יותר גלגולים של המשחק הזה,

855
00:37:49,887 --> 00:37:51,720
והם שמרו אותו כ
סוג של ביצת פסחא,

856
00:37:51,720 --> 00:37:53,870
שגנדי הוא כנראה
כך אגרסיווי מאוד.

857
00:37:53,870 --> 00:37:56,740
אבל זה היה התוצאה של
שגיאת תכנות פשוטה מאוד

858
00:37:56,740 --> 00:37:58,630
שבגרסה מאוד מוקדמת של המשחק.

859
00:37:58,630 --> 00:38:02,860
>> עכשיו יותר מטריד, יותר
לאחרונה, בואינג 787

860
00:38:02,860 --> 00:38:05,720
תועד כבעל
באג, לא מהסוג של מכשיר

861
00:38:05,720 --> 00:38:07,340
אתה במיוחד רוצה להיות באג.

862
00:38:07,340 --> 00:38:10,130
והתסמינים, שאני אקרא
כאן, ממאמר באינטרנט,

863
00:38:10,130 --> 00:38:13,840
היה, מטוס 787 מודל זה
שכבר מופעל ברציפות

864
00:38:13,840 --> 00:38:18,030
לימים 248 יכולים לאבד את כל
זרם חילופין, AC,

865
00:38:18,030 --> 00:38:20,850
חשמל, בשל
יחידות גנרטור שליטה,

866
00:38:20,850 --> 00:38:23,330
GCUs, בו זמנית
הולך למצב Fail-בטוח.

867
00:38:23,330 --> 00:38:26,790
אז זה היה אזהרה
כאשר בעיה זו התגלתה.

868
00:38:26,790 --> 00:38:28,750
מצב זה נגרם
על ידי דלפק תוכנה,

869
00:38:28,750 --> 00:38:32,230
פנימי לGCUs, כך
מספר שלם או משתנים,

870
00:38:32,230 --> 00:38:36,850
כי הצפת רצון אחרי 248
ימים של כוח רציף.

871
00:38:36,850 --> 00:38:40,350
בואינג הוא בתהליך של
פיתוח שדרוג תוכנת GCU ש

872
00:38:40,350 --> 00:38:42,350
יהיה לתקן את המצב בטוח.

873
00:38:42,350 --> 00:38:44,226
>> כל כך הרבה כמו הטיל
תרחיש, שבי

874
00:38:44,226 --> 00:38:46,850
היה להם כמה סוג של משתנה
שספירה, וספירה,

875
00:38:46,850 --> 00:38:50,720
ולספור, אבל עולה על גדותיו בהדרגה
גבולות היכולת שלה,

876
00:38:50,720 --> 00:38:54,890
באופן דומה עשה מטוס הארור
יש לי גלישה משתנה

877
00:38:54,890 --> 00:38:56,410
אחרי מספיק זמן של ריצה.

878
00:38:56,410 --> 00:38:59,240
ולכן דרך לשון-בלחי
של עובד סביב נושא זה

879
00:38:59,240 --> 00:39:04,400
הוא באמת, אתחול מחדש, המטוס שלך בכל
247 ימים, כך שהזיכרון מקבל ניגב

880
00:39:04,400 --> 00:39:06,100
ומשתנה חוזר ל0.

881
00:39:06,100 --> 00:39:09,410
אבל מבין, זה הוא מאוד
גלגול גדול של תוכנה,

882
00:39:09,410 --> 00:39:14,070
אבל במיוחד כאשר אנו שומעים על אפל
מערכות הפעלה הולכת למכוניות,

883
00:39:14,070 --> 00:39:18,030
ועצמי נוהג במכוניות מגוגל, ו
כל מספר גלגולים של תוכנה

884
00:39:18,030 --> 00:39:21,000
בחיי היומיום של, הטלוויזיות שלנו
ושעונים, ועוד,

885
00:39:21,000 --> 00:39:24,950
מבין היו מוקפים תוכנה,
כל שנכתב על ידי, בני אדם.

886
00:39:24,950 --> 00:39:28,150
>> וכפי שכולנו בקרוב לגלות,
זה מאוד קל ומאוד אופייני

887
00:39:28,150 --> 00:39:30,250
לעשות טעויות בעת כתיבת תוכנה.

888
00:39:30,250 --> 00:39:32,745
ואם אתה לא תופס אותם,
כמה דברים רעים יכולים לקרות.

889
00:39:32,745 --> 00:39:35,400
עכשיו לפעמים, כמה
דברים מצחיקים יכולים לקרות,

890
00:39:35,400 --> 00:39:38,280
או לפחות לפעמים אנחנו
יודע לצפות כמה רוע.

891
00:39:38,280 --> 00:39:41,550
אז 0 מחולקים 0, מכיתה
בית ספר, הוא בדרך כלל דבר רע.

892
00:39:41,550 --> 00:39:43,050
זה לא מוגדר.

893
00:39:43,050 --> 00:39:46,440
ומתברר out-- ובואו נראה אם
המיקרופון שלי יכול להרים את זה up-- כי אפל

894
00:39:46,440 --> 00:39:47,790
היה להם קצת כיף עם זה לאחרונה.

895
00:39:47,790 --> 00:39:48,850
אז יש לי iPhone כאן.

896
00:39:48,850 --> 00:39:54,160
אני הולך לדבר עם Siri ולשאול אותה
לתת לי תשובה ל0 מחולקת 0.

897
00:39:54,160 --> 00:39:55,850
מה 0 מחולקים 0?

898
00:39:55,850 --> 00:39:59,350

899
00:39:59,350 --> 00:40:02,230
>> SIRI: תארו לעצמכם שיש לך 0
עוגיות, ואתה לפצל אותם באופן שווה

900
00:40:02,230 --> 00:40:03,540
בין 0 חברים.

901
00:40:03,540 --> 00:40:05,810
כמה עוגיות כל אדם לקבל?

902
00:40:05,810 --> 00:40:06,350
רואה?

903
00:40:06,350 --> 00:40:07,660
זה לא הגיוני.

904
00:40:07,660 --> 00:40:10,540
ועוגי הוא עצוב
שאין עוגיות.

905
00:40:10,540 --> 00:40:13,987
ואתה עצוב ש
אין לך חברים.

906
00:40:13,987 --> 00:40:15,570
דוד J מלאן: זהו סוג של מעצבנת.

907
00:40:15,570 --> 00:40:17,550
אז זה מה שרק אמר שיש.

908
00:40:17,550 --> 00:40:21,380
זה לא מוגדר, זה לא מוגדר,
ואכן, שפות תכנות רבות

909
00:40:21,380 --> 00:40:24,950
או, באמת, מהדרים יהיו
לזהות כאשר אתה, בתכנית,

910
00:40:24,950 --> 00:40:27,050
מנסה לחלק 0 על ידי 0.

911
00:40:27,050 --> 00:40:29,830
יותר כיף מאשר אף זו, הוא
שככל הנראה, עוגי

912
00:40:29,830 --> 00:40:31,270
הוא בטוויטר בימים אלה.

913
00:40:31,270 --> 00:40:37,610
והוא השיב לזה, עם זה,
שהוא מקסים לחלוטין.

914
00:40:37,610 --> 00:40:40,110
אבל בואו ניקח מבט מהיר ב
כמה מבנים אחרים,

915
00:40:40,110 --> 00:40:43,459
ואז לשים חלק מזה
קוד לשימוש, בדרכים טובות.

916
00:40:43,459 --> 00:40:45,250
אז מתברר, מלבד
ללולאות, יש

917
00:40:45,250 --> 00:40:49,174
משהו שנקרא לולאה בזמן, ש
נראה שונה ומיושם

918
00:40:49,174 --> 00:40:51,590
וקצת differently--
סופו של דבר יראו examples--

919
00:40:51,590 --> 00:40:53,500
אבל במובן מסוים,
זה פשוט כי זה

920
00:40:53,500 --> 00:40:56,670
אינו מאפשר לך לאתחל ו
לעדכן בתוך הגבולות של הלולאה.

921
00:40:56,670 --> 00:40:57,794
אתה עדיין יכול ליישם את זה.

922
00:40:57,794 --> 00:41:01,219
אז אתה יכול לעשות בדיוק את אותם דברים
עם לולאה בזמן, כמו עם ללולאה,

923
00:41:01,219 --> 00:41:03,260
אבל התחביר שלך, ultimately--
וכבסוף

924
00:41:03,260 --> 00:41:04,551
see-- הולך להיות שונה.

925
00:41:04,551 --> 00:41:07,450
יש אפילו לעשות בזמן לולאה, ש
הוא למעשה קצת שונה,

926
00:41:07,450 --> 00:41:09,640
בכי בעוד ללולאה
ולולאה בזמן תמיד

927
00:41:09,640 --> 00:41:13,005
לבדוק את מצבם הראשון, אם
אתה קורא את הדבר הזה למעלה עד למטה,

928
00:41:13,005 --> 00:41:16,440
זה נראה כמו סוג של זה הולך
לבדוק את המצב שלו אחרון, כי זה

929
00:41:16,440 --> 00:41:17,910
באמת השורה האחרונה של קוד.

930
00:41:17,910 --> 00:41:20,580
ואכן, זה הולך להיות שימושי
בתוכניות מסוימות שאנחנו כותבים,

931
00:41:20,580 --> 00:41:23,746
אם אתה רוצה לעשות משהו פשוט עיוור
וסופו של דבר לבדוק את מצבו.

932
00:41:23,746 --> 00:41:25,205
זה לא בהכרח דבר רע.

933
00:41:25,205 --> 00:41:27,912
אם אנחנו רוצים משתנים, אנחנו יכולים לעשות
זה בכמה דרכים שונות.

934
00:41:27,912 --> 00:41:30,290
וראינו בFoxtrot
קריקטורה, דרך אחת לעשות את זה,

935
00:41:30,290 --> 00:41:33,400
שבו אתה מצהיר משתנה,
כמו פסיק דלפק int,

936
00:41:33,400 --> 00:41:36,570
ואז אולי later-- הבא
קו, אולי 10 קווים later--

937
00:41:36,570 --> 00:41:37,800
אתה בעצם לאתחל אותו.

938
00:41:37,800 --> 00:41:42,230
אז אלה 2 שורות קוד
להצהיר על משתנה מסוג int

939
00:41:42,230 --> 00:41:44,930
וקורא לזה דלפק, כך שזה נותן לי
מספיק ביטיי להחזיק int.

940
00:41:44,930 --> 00:41:48,230
ואז בסופו, היא מעבירה
הערך 0 למשתנים ש.

941
00:41:48,230 --> 00:41:51,250
זה מסדיר את של 0 ו -1 של ב
דפוס, שאנחנו יודעים משבוע שעבר,

942
00:41:51,250 --> 00:41:53,260
מייצג את המספר שאנו מכירים כ0.

943
00:41:53,260 --> 00:41:56,920
או בכנות, אתה יכול לעשות את זה הרבה
באופן תמציתי יותר, פשוט אהבתי את זה.

944
00:41:56,920 --> 00:41:59,390
>> עכשיו יש לנו גם
יכולת לקרוא לפונקציות.

945
00:41:59,390 --> 00:42:03,070
ולמעשה, הנה קו 2
תכנית, או קטע ממנו,

946
00:42:03,070 --> 00:42:06,157
המאפשר לנו למעשה
לכתוב קצת קוד ש

947
00:42:06,157 --> 00:42:08,990
מקבל מחרוזת מuser-- הרבה
כמו ההתנדבות שלנו רגע ago--

948
00:42:08,990 --> 00:42:11,320
אחסון התוצאה ב
משתנה בשם שם,

949
00:42:11,320 --> 00:42:15,470
ואז-- הרבה כמו עם המתנדב שלנו
עם הדפסים מתוך ערכים אלה printf--

950
00:42:15,470 --> 00:42:19,180
על ידי עובר בשתי טענות,
מחרוזת, ואחריו משתנה

951
00:42:19,180 --> 00:42:20,781
בשם, שם, את עצמו.

952
00:42:20,781 --> 00:42:23,155
אז בואו נסתכל, לפני
אנו חוזרים למריו יש,

953
00:42:23,155 --> 00:42:26,010
בכמה עכשיו, דוגמאות לכך.

954
00:42:26,010 --> 00:42:30,537
>> אני הולך קדימה ופתוח
עד, נניח, פונקציה-0.c.

955
00:42:30,537 --> 00:42:33,120
וכמו תמיד, את הקוד הזה הוא
זמין באתר האינטרנט של הקורס,

956
00:42:33,120 --> 00:42:35,660
כך שאתה יכול לשחק יחד ב
הבית ומסתכל על זה מאוחר יותר.

957
00:42:35,660 --> 00:42:40,400
אבל הנה התכנית בזה
מהות, מקו 17-22.

958
00:42:40,400 --> 00:42:43,270
התכנית העיקרית היא שבו
התכנית תמיד עומדת להתחיל.

959
00:42:43,270 --> 00:42:46,980
תכנית זו, ככל הנראה, הוא הולכת
להדפיס את השם שלך, מעי גס.

960
00:42:46,980 --> 00:42:50,320
זה אז הולך לקרוא GetString,
בדיוק כמו שעשינו עם המתנדבים שלנו.

961
00:42:50,320 --> 00:42:53,365
ואז, זה מעניין,
זה הולך לקרוא PrintName.

962
00:42:53,365 --> 00:42:56,490
מתברר, כל הזמן הזה, יש
נראה שיש פונקציה שנקראת PrintName.

963
00:42:56,490 --> 00:42:57,614
שמדפיס את שמו של מישהו.

964
00:42:57,614 --> 00:43:01,210
אנחנו לא צריכים להשתמש printf מ
פעם, יש PrintName.

965
00:43:01,210 --> 00:43:03,500
>> אבל זה מטעה
כי PrintName לא

966
00:43:03,500 --> 00:43:06,760
מגיע עם ג אנשים לא
להמציא אותה לפני כ -40 או 50 שנים,

967
00:43:06,760 --> 00:43:07,990
אני עשיתי, במקום.

968
00:43:07,990 --> 00:43:10,330
ולמעשה, אם אני לגלול
מטה נוסף, הודעה

969
00:43:10,330 --> 00:43:14,200
איך אני יכול לכתוב שלי
פונקציות בסופו של דבר ימצא .ג

970
00:43:14,200 --> 00:43:16,319
להסביר למה אנחנו כל הזמן אומרים,
חלל, בכמה מקומות,

971
00:43:16,319 --> 00:43:18,110
אבל היום, בואו
רק להסתכל על השם.

972
00:43:18,110 --> 00:43:20,905
>> על קו 24, אם אתה רוצה
ליצור הפונקציה שלך,

973
00:43:20,905 --> 00:43:22,780
אתה ממש לכתוב
שמו של הפונקציה.

974
00:43:22,780 --> 00:43:24,340
אני בחרתי PrintName.

975
00:43:24,340 --> 00:43:26,159
בסוגריים, אתה
לאחר מכן ציין אילו סוגים

976
00:43:26,159 --> 00:43:28,450
תשומות, וכמה אתה
רוצה בפונקציה זו כדי לקחת.

977
00:43:28,450 --> 00:43:31,906
במקרה זה, אני רוצה לקחת את
משתנה 1 נקרא, שם,

978
00:43:31,906 --> 00:43:34,030
וזה הולך להיות של
סוג, מחרוזת, כך שזה הולך

979
00:43:34,030 --> 00:43:35,780
להיות חלק רצף של תווים.

980
00:43:35,780 --> 00:43:39,170
ולאחר מכן, program-- זה
כמו בגרד,

981
00:43:39,170 --> 00:43:42,590
אתה יכול להיות חידה מותאמת אישית pieces--
הוא הולך להיות זה התנהגות מותאמת אישית.

982
00:43:42,590 --> 00:43:46,760
זה הולך לקרוא printf
עובר ב, שלום, מציין מיקום,

983
00:43:46,760 --> 00:43:49,110
ואז זה הולך לחבר
בכל מה שהמשתמש בשם.

984
00:43:49,110 --> 00:43:51,450
>> אז זה דוגמא למה ש
מדען מחשב היית

985
00:43:51,450 --> 00:43:55,090
הפשטת שיחה או פונקציונלית
פירוק, שהם רק

986
00:43:55,090 --> 00:43:58,110
דרכים מפוארות של saying-- האם אם
אתה אוהב את רעיון ברמה גבוהה זו,

987
00:43:58,110 --> 00:44:01,569
כמו שאני רוצה פונקציונלי ש
מדפיס את שמו של מישהו, אתה בהחלט

988
00:44:01,569 --> 00:44:04,360
ממש יכול לכתוב printf ולאחר מכן
לעבור בטענות שאתה רוצה,

989
00:44:04,360 --> 00:44:07,340
והתכנית תעבוד,
שכן יש מאז יום רביעי.

990
00:44:07,340 --> 00:44:10,510
אבל אתה יכול להתחיל משם מופשט
הרעיון של הדפסה שם.

991
00:44:10,510 --> 00:44:13,270
אתה יכול לתת לו שם,
כמו PrintName, וזה

992
00:44:13,270 --> 00:44:15,280
רעיון זה של שכבות משבוע 0.

993
00:44:15,280 --> 00:44:19,910
>> מכאן ואילך, אני ואתה לא צריך לדעת
או אכפת איך PrintName מיושם.

994
00:44:19,910 --> 00:44:22,470
כן הוא משתמש printf, אולי זה
לא, מי יודע מה משתמש?

995
00:44:22,470 --> 00:44:23,410
למי איכפת?

996
00:44:23,410 --> 00:44:26,034
עכשיו אני מדבר כאן,
במקום כאן למטה.

997
00:44:26,034 --> 00:44:28,700
ואכן, כפי שהתוכניות שלנו לקבל
יותר מתקדם ומתוחכם,

998
00:44:28,700 --> 00:44:32,550
אנחנו הולכים להמשיך לקחת כמובן מאליו
שחלקי הפאזל רמה נמוכים יותר קיימים.

999
00:44:32,550 --> 00:44:34,780
בגלל שכתבנו אותם
או מישהו אחר עשה, ולכן

1000
00:44:34,780 --> 00:44:36,910
כי אז אנחנו יכולים לבנות עליהם.

1001
00:44:36,910 --> 00:44:39,430
בואו נסתכל על זה
גרסה, פונקציה אחת.

1002
00:44:39,430 --> 00:44:41,780
>> אז זה אחד זה קצת יותר
מתקדם, אבל מתברר

1003
00:44:41,780 --> 00:44:44,570
כי בספרייה של CS50,
יש רק פונקצית GetInt.

1004
00:44:44,570 --> 00:44:47,720
לא חשבנו, לפני שנים, ל
ליישם פונקצית GetPositiveInt.

1005
00:44:47,720 --> 00:44:50,970
וזה קצת מעצבן כי אם
אתם כותבים תכנית שבי

1006
00:44:50,970 --> 00:44:53,325
אתה רוצה לקבל חיובי
מספר שלם מהמשתמש,

1007
00:44:53,325 --> 00:44:55,010
בהחלט אתה יכול להשתמש GetInt.

1008
00:44:55,010 --> 00:44:57,840
ואתה בהחלט יכול לבדוק עם
המצב ואולי לולאה

1009
00:44:57,840 --> 00:45:00,320
אם int שהוא גדול יותר
מ 0 ולצעוק על המשתמש

1010
00:45:00,320 --> 00:45:02,699
אם הוא או היא לא נותנת לי
לך מספר חיובי.

1011
00:45:02,699 --> 00:45:04,740
אבל בואו לבנות את זה
בניין לחסום את עצמנו,,

1012
00:45:04,740 --> 00:45:06,555
חתיכה מותאמת אישית Scratch, אם תרצה.

1013
00:45:06,555 --> 00:45:08,680
אני הולך יש לי תכנית
כאן שסופו של דבר, אני

1014
00:45:08,680 --> 00:45:11,780
רוצה להיות מסוגל לקרוא
GetPositiveInt, ואני רוצה להיות

1015
00:45:11,780 --> 00:45:14,200
תוכל להדפיס את מה שהוא int.

1016
00:45:14,200 --> 00:45:16,240
אבל זה מפוזר משם עכשיו.

1017
00:45:16,240 --> 00:45:19,050
זה פשוט קיבל רמה גבוהה
שם שאומר את מה שהוא עושה,

1018
00:45:19,050 --> 00:45:21,780
וזה נפלא, כי זה
מאוד אינטואיטיבי עכשיו לקרוא.

1019
00:45:21,780 --> 00:45:24,710
ואם אני עושה אכפת מה יש מתחת
מכסה המנוע, תן לי לגלול למטה.

1020
00:45:24,710 --> 00:45:27,140
וזה קצת מפחיד
בהתחלה, במיוחד

1021
00:45:27,140 --> 00:45:29,470
אם זה התכנית הראשונה שלך,
אבל בואו נסתכל.

1022
00:45:29,470 --> 00:45:32,860
>> אני כבר לא אומר, חלל,
כי מתברר פונקציות,

1023
00:45:32,860 --> 00:45:34,777
הרבה כמו GetString, יכול
להחזיר ערך לי.

1024
00:45:34,777 --> 00:45:36,610
לא רק שיש להם
להדפיס למסך,

1025
00:45:36,610 --> 00:45:38,410
הם באמת יכולים למסור
שלי משהו בחזרה.

1026
00:45:38,410 --> 00:45:41,535
ואילו לפני PrintName,
אני לא צריך שום דבר בחזרה.

1027
00:45:41,535 --> 00:45:44,160
אני צריך תופעת הלוואי של
משהו להופיע על המסך,

1028
00:45:44,160 --> 00:45:46,570
אבל אני לא צריך אדם
למסור לי משהו בחזרה.

1029
00:45:46,570 --> 00:45:48,840
כאן, עם GetPositiveInt,
כמו עם GetInt,

1030
00:45:48,840 --> 00:45:50,640
אני רוצה להימסר משהו בחזרה.

1031
00:45:50,640 --> 00:45:53,220
אז אני אומר לא, חלל,
על קו 23, אך int,

1032
00:45:53,220 --> 00:45:55,570
שאומר, בפונקציה זו
שאני כותב,

1033
00:45:55,570 --> 00:45:58,860
נקרא GetPositiveInt הולך
למסור לי את מספר שלם, לא שום דבר,

1034
00:45:58,860 --> 00:45:59,890
לא מבוטל.

1035
00:45:59,890 --> 00:46:03,280
>> בינתיים, זה הולך לקחת לא
תשומות, כך ש, סוג של, התהפכו זה.

1036
00:46:03,280 --> 00:46:08,280
אני לא נותן GetPositiveInt כל
קלט, אני רוצה שזה ייתן לי את התפוקה שלה.

1037
00:46:08,280 --> 00:46:09,800
ואז מה קורה עכשיו?

1038
00:46:09,800 --> 00:46:11,640
אז הנה איך אני יכול להצהיר על משתנה.

1039
00:46:11,640 --> 00:46:15,090
אני כבר עשיתי את זה מחוץ ללולאה,
מסיבות שסופו של דבר יראו,

1040
00:46:15,090 --> 00:46:17,700
אבל זה רק נותן לי
שלי 32 סיביות נקרא, n,

1041
00:46:17,700 --> 00:46:20,952
ויש לי מראש קביעה-
שלהם כדי לאחסן מספר שלם.

1042
00:46:20,952 --> 00:46:23,660
והנה ש, לעשות בזמן לבנות,
וזה למה זה שימושי.

1043
00:46:23,660 --> 00:46:26,700
פשוטו כמשמעו לעשות את זה,
בעוד n הוא פחות מ 1.

1044
00:46:26,700 --> 00:46:28,030
אז בואו לראות מה קורה.

1045
00:46:28,030 --> 00:46:30,760
אני להדפיס, בבקשה
תן לי int חיובי.

1046
00:46:30,760 --> 00:46:34,300
אז אני מקבל int, באמצעות CS50 של
לתפקד ומאוחסן בn.

1047
00:46:34,300 --> 00:46:38,990
>> ואז, מה שורת קוד כנראה
מקבל להורג הבא, באופן הגיוני?

1048
00:46:38,990 --> 00:46:41,890
איזה קו מספר?

1049
00:46:41,890 --> 00:46:42,571
כן, אז 31.

1050
00:46:42,571 --> 00:46:45,320
אתה לא יודע את זה עד שיש לך
נאמר לי או סוג של להסיק את זה,

1051
00:46:45,320 --> 00:46:45,986
אבל זה נכון.

1052
00:46:45,986 --> 00:46:48,280
זה הולך מלמעלה למטה
ולאחר מכן חוזר על.

1053
00:46:48,280 --> 00:46:55,840
אז אם יש לי הקליד למשל, המספר
שלילי 1, הוא פחות מ n שלילי 1?

1054
00:46:55,840 --> 00:46:56,340
כן.

1055
00:46:56,340 --> 00:46:58,470
בגלל שלילי 1 הוא פחות מ 1.

1056
00:46:58,470 --> 00:46:59,510
אז מה צריך לקרות?

1057
00:46:59,510 --> 00:47:03,260
אני הולך לעשות את זה
בעוד n הוא פחות מ 1,

1058
00:47:03,260 --> 00:47:05,760
אז אני הולך לחזור לקו 28.

1059
00:47:05,760 --> 00:47:09,530
>> וכל time-- ובואו לרוץ זה--
להפוך את פונקצית 1 לקמפל אותו,

1060
00:47:09,530 --> 00:47:11,340
ועכשיו נקודה לקצץ פונקצית 1.

1061
00:47:11,340 --> 00:47:14,280
אם אני מקליד 1 שלילי, זה
הולך לשמור לצעוק עליי

1062
00:47:14,280 --> 00:47:17,530
עד שאשתף פעולה, כי כל
התשומות שלי הוא פחות מ 1

1063
00:47:17,530 --> 00:47:20,070
ואם זה תוך פחות מ 1,
אני הולך להמשיך לעשות את זה.

1064
00:47:20,070 --> 00:47:24,240
אם אני סוף סוף נותן לו מספר כמו 50,
לשמחתי, זה אומר, תודה על 50.

1065
00:47:24,240 --> 00:47:24,970
למה?

1066
00:47:24,970 --> 00:47:30,640
כי ברגע שn הוא לא פחות מ
1, אני מפסיק להיתקע בלולאה זו,

1067
00:47:30,640 --> 00:47:33,840
ומילת מפתח חדש זה היום,
התמורה, פשוטו כמשמעו עושה את זה.

1068
00:47:33,840 --> 00:47:36,800
אז פשוט אני כבר מיושם, ב
תחושה, את המקבילה של GetString,

1069
00:47:36,800 --> 00:47:40,590
לאן אני מסרתי בחזרה ל
מי שמשתמש בי, כמה ערך.

1070
00:47:40,590 --> 00:47:42,820
זה לא חייב להיות
מחרוזת, זה int.

1071
00:47:42,820 --> 00:47:44,990
אז פשוט, מהיר
למשל, אבל אנחנו בקרוב

1072
00:47:44,990 --> 00:47:47,930
לראות כמה מתוחכם יותר
גרסאות עדיין.

1073
00:47:47,930 --> 00:47:53,882
למעשה, בואו נסתכל
מספרי אחד, הנקרא return.c.

1074
00:47:53,882 --> 00:47:55,590
וזה אחד בעצם
קצת יותר פשוט.

1075
00:47:55,590 --> 00:47:59,010
אז המטרה של תכנית זו ב
life-- בואו לקמפל ולהריץ אותו,

1076
00:47:59,010 --> 00:48:03,090
כך להפוך את התמורה, נקודה
קו נטוי, הודעת return--

1077
00:48:03,090 --> 00:48:05,530
התכנית פשוט קוביות הערך 2.

1078
00:48:05,530 --> 00:48:08,410
זה די טיפשי, זה קשה
קוד, זה לא לוקח כל תשומות,

1079
00:48:08,410 --> 00:48:12,220
אבל זה מדגים אחר
פונקציה שכתבתי בעצמי.

1080
00:48:12,220 --> 00:48:15,760
אז הנה, אני כבר הכריז
משתנה, נקרא X, של int הסוג,

1081
00:48:15,760 --> 00:48:17,840
שווה למספר 2,
שרירותי לחלוטין.

1082
00:48:17,840 --> 00:48:19,530
זהו רק חלק הדפסה רכה.

1083
00:48:19,530 --> 00:48:23,070
זה אומר x הוא עכשיו, וכאלה
, נקודה כזו עִקוּב נקודת נקודה.

1084
00:48:23,070 --> 00:48:26,390
והקסם הוא כנראה בקו 21.

1085
00:48:26,390 --> 00:48:30,120
אני קורא לפונקציה בשם, קובייה,
אני מושיט אותו גיליון נייר

1086
00:48:30,120 --> 00:48:32,890
עם מספר 2 שנכתבו עליו,
ומה ערך, מבחינה מתמטית,

1087
00:48:32,890 --> 00:48:34,860
אני רוצה לצאת מזה?

1088
00:48:34,860 --> 00:48:36,570
רק כבדיקת שפיות?

1089
00:48:36,570 --> 00:48:37,070
8.

1090
00:48:37,070 --> 00:48:37,570
נכון?

1091
00:48:37,570 --> 00:48:40,160
אני רוצה 2 קוביות בחזרה, 2 ל
הכח של 3, אז חזרה 8.

1092
00:48:40,160 --> 00:48:42,570
>> אז איפה מיושמת קובייה?

1093
00:48:42,570 --> 00:48:44,349
ובכן, שים לב שזה מיושם כאן למטה.

1094
00:48:44,349 --> 00:48:47,140
ובדיוק כמו בעבר, באופן הגיוני,
למרות שהתחביר הוא כנראה

1095
00:48:47,140 --> 00:48:49,320
מאוד חדש לרבים מכם,
אני רוצה בפונקציה זו

1096
00:48:49,320 --> 00:48:51,780
להחזיר לי גיליון של
נייר עם int על זה.

1097
00:48:51,780 --> 00:48:53,990
אז יש לי int,
שם הוא באופן שרירותי,

1098
00:48:53,990 --> 00:48:55,530
אבל בשם נוחות קובייה.

1099
00:48:55,530 --> 00:48:58,430
הקלט אליו, הוא n של
הקלד מספר שלם, אז זה

1100
00:48:58,430 --> 00:49:00,800
איך אני יכול לעבור במספר
2 על גיליון נייר.

1101
00:49:00,800 --> 00:49:03,910
ואז מתברר תומך C
מתמטיקה, כך אין לך X של פעמים,

1102
00:49:03,910 --> 00:49:06,680
אתה פשוט להשתמש בכוכבית
לכפל.

1103
00:49:06,680 --> 00:49:11,070
וזה מחזיר פעמים n n פעמים
n, וזה פשוט ערך קוביות.

1104
00:49:11,070 --> 00:49:12,840
>> אז לאן אנחנו הולכים עם כל זה?

1105
00:49:12,840 --> 00:49:14,570
זה בהחלט
סיור סופה, היה סמוך ובטוח,

1106
00:49:14,570 --> 00:49:16,410
כי בסעיפי הסופר
ובבעיה להגדיר 1,

1107
00:49:16,410 --> 00:49:18,368
אתה תהיה הלך ב
כל זה עוד יותר.

1108
00:49:18,368 --> 00:49:22,490
ובבעיה להגדיר 1, אנחנו מעבר
מהעולם הגרפי של Scratch

1109
00:49:22,490 --> 00:49:25,640
למשהו שורת הפקודה יותר
בC. אבל אנחנו שואבים את ההשראה

1110
00:49:25,640 --> 00:49:27,680
מכאן המשחק הזה
מפעם, שבי

1111
00:49:27,680 --> 00:49:31,591
באמצעות C והמהדורה הסטנדרטי של
סט עמ אתה ליישם הפירמידה של מריו.

1112
00:49:31,591 --> 00:49:34,340
ובמהדורה של ההאקר
סט עמ ', אם אתה כל כך לבחור לבחור,

1113
00:49:34,340 --> 00:49:38,280
תוכל ליישם קצת יותר
מאתגר את הפירמידה עם שתי פסגות.

1114
00:49:38,280 --> 00:49:41,239
כמו כן תוכל ליישם
אלגוריתם, אלגוריתם חמדן.

1115
00:49:41,239 --> 00:49:43,030
מתברר של שם
איזה היגיון מעניין

1116
00:49:43,030 --> 00:49:45,640
מאחורי התהליך
פועל תחנה של קופאית

1117
00:49:45,640 --> 00:49:47,410
ומסירה בפועל
מישהו שינוי בחזרה.

1118
00:49:47,410 --> 00:49:50,410
יש אלגוריתם זה די
פשוט, כי אתה אולי אפילו

1119
00:49:50,410 --> 00:49:53,576
לתפוס באופן אינטואיטיבי כאשר אתה קורא ראשון
it-- הבין שזה מה שתמיד

1120
00:49:53,576 --> 00:49:57,110
עשה כל זמן שנתתי למישהו מסוים
הכסף back-- שמאפשר לך תמיד

1121
00:49:57,110 --> 00:50:00,679
לצמצם את מספר
הערות נייר או מטבעות מתכת

1122
00:50:00,679 --> 00:50:02,220
שאתה מסרת בחזרה למשתמש.

1123
00:50:02,220 --> 00:50:04,610
וזה, כמובן, הוא משכנע
כי אם אתה הולך לCVS או מה שלא,

1124
00:50:04,610 --> 00:50:06,430
אתה לא רוצה להיות בידיים
חבורה של אלה כל

1125
00:50:06,430 --> 00:50:07,596
או חבורה של פרוטות כולה.

1126
00:50:07,596 --> 00:50:10,120
אתה רוצה הכי פחות
מטבעות, כנראה, אפשרי.

1127
00:50:10,120 --> 00:50:13,070
>> לבסוף, תוכל גם להיות מאותגר
להשתכשך בעולם מים

1128
00:50:13,070 --> 00:50:17,220
ולמעשה לקבל את ההערכה
למיפוי בין שיעורי זרימה,

1129
00:50:17,220 --> 00:50:19,890
של רצון, מים במקלחת,
רק כמה מים משמש.

1130
00:50:19,890 --> 00:50:22,640
והרמז בו,
יהיה קליפ זה כאן,

1131
00:50:22,640 --> 00:50:24,840
שאנחנו בסופו של ל
רק 60 שניות, ש

1132
00:50:24,840 --> 00:50:29,070
מצייר תמונה של
ראשי מקלחת זרימה נמוכה.

1133
00:50:29,070 --> 00:50:30,886
>> [וידאו השמעה]

1134
00:50:30,886 --> 00:50:31,385
-בסדר.

1135
00:50:31,385 --> 00:50:32,774
יש לי הכל כאן.

1136
00:50:32,774 --> 00:50:35,800
יש לי את הסדרה ו 'ציקלון,
הידרה, Jetflow, שטוקהולם

1137
00:50:35,800 --> 00:50:37,660
Supersteam, אתה שם את זה.

1138
00:50:37,660 --> 00:50:39,265
>> ומה באתם ממליצים?

1139
00:50:39,265 --> 00:50:40,460
>> -מה אתה מחפש?

1140
00:50:40,460 --> 00:50:41,300
>> איש -Power.

1141
00:50:41,300 --> 00:50:42,285
כוח.

1142
00:50:42,285 --> 00:50:42,910
הדמוי סילקווד.

1143
00:50:42,910 --> 00:50:44,520
חייהם." בשביל קרינה.

1144
00:50:44,520 --> 00:50:46,335
-זה נכון.

1145
00:50:46,335 --> 00:50:48,275
-עכשיו מה זה?

1146
00:50:48,275 --> 00:50:49,704
"אלוהים." -זה הקומנדו 450.

1147
00:50:49,704 --> 00:50:50,620
אני לא מוכר את זה.

1148
00:50:50,620 --> 00:50:51,700
>> -אבל זה מה שאנחנו רוצים.

1149
00:50:51,700 --> 00:50:52,680
זה קומנדו 450.

1150
00:50:52,680 --> 00:50:53,882
>> -לא יאמין לי.

1151
00:50:53,882 --> 00:50:55,090
הוא משמש רק בקרקס.

1152
00:50:55,090 --> 00:50:56,512
זה לפילים.

1153
00:50:56,512 --> 00:50:59,356
>> "אני אקה לשלם כלום.

1154
00:50:59,356 --> 00:51:01,252
>> מה בנוגע ג'רי?

1155
00:51:01,252 --> 00:51:02,760
>> -הוא לא יכל להתמודד עם זה.

1156
00:51:02,760 --> 00:51:04,910
הוא עדין.

1157
00:51:04,910 --> 00:51:05,750
או כן.

1158
00:51:05,750 --> 00:51:36,737

1159
00:51:36,737 --> 00:51:37,320
[סוף ההשמעה]

1160
00:51:37,320 --> 00:51:37,700
דוד J מלאן: בסדר.

1161
00:51:37,700 --> 00:51:38,820
זה אם לCS50.

1162
00:51:38,820 --> 00:51:40,050
נתראה בשבוע הבא.

1163
00:51:40,050 --> 00:51:45,910

1164
00:51:45,910 --> 00:51:49,029
>> 1 מרצה: [? סקאלי?], [? איאן,?]
ככל פרויקט outro זה,

1165
00:51:49,029 --> 00:51:50,362
מה יש לכם לבוא עם?

1166
00:51:50,362 --> 00:51:51,990
>> SPEAKER 2: טוב, שנתנו
זה מגוון של מחשבה,

1167
00:51:51,990 --> 00:51:53,250
ואנחנו חושבים שהדרך הטובה ביותר צריכה--

1168
00:51:53,250 --> 00:51:53,660
>> SPEAKER 3: מאי אני?

1169
00:51:53,660 --> 00:51:54,326
>> SPEAKER 2: כן.

1170
00:51:54,326 --> 00:51:56,360
בכל האמצעים, למעשה.

1171
00:51:56,360 --> 00:51:59,425
>> 3 דובר: אז אני חושב
אנחנו יכולים לסכם את הרעיון שלנו

1172
00:51:59,425 --> 00:52:05,450
לoutros עם דבר אחד word--.

1173
00:52:05,450 --> 00:52:08,950

1174
00:52:08,950 --> 00:52:10,409
>> דוד J מלאן: שום דבר?

1175
00:52:10,409 --> 00:52:11,200
SPEAKER 3: שום דבר.

1176
00:52:11,200 --> 00:52:12,990
דוד J מלאן: מה זה אומר?

1177
00:52:12,990 --> 00:52:16,260
SPEAKER 3: outros הם על לא מאומה.

1178
00:52:16,260 --> 00:52:21,720
SPEAKER 2: טוב, אני מתכוון, בפילוסופיה,
אני מתכוון, לא תמיד יש משהו.

1179
00:52:21,720 --> 00:52:24,200
1 דובר: אז what's--
מה ההנחה?

1180
00:52:24,200 --> 00:52:25,720
3 דובר: אז זה כמו חיים.

1181
00:52:25,720 --> 00:52:26,680
אוקיי.

1182
00:52:26,680 --> 00:52:28,294
מה עשית היום?

1183
00:52:28,294 --> 00:52:31,811
>> דוד J מלאן: קמתי, היה לי
ארוחת בוקר, ובא לעבוד.

1184
00:52:31,811 --> 00:52:34,056
>> SPEAKER 3: זה outro.

1185
00:52:34,056 --> 00:52:36,806
SPEAKER 2: אבל, אני מתכוון, לא צריך
משהו יקרה לו בכל--

1186
00:52:36,806 --> 00:52:37,889
SPEAKER 3: לא, לא, לא, לא.

1187
00:52:37,889 --> 00:52:40,220
שום דבר לא קורה.

1188
00:52:40,220 --> 00:52:42,910
>> 1 דובר: אז למה אנחנו צופים?

1189
00:52:42,910 --> 00:52:46,956
>> 3 SPEAKER: מכיוון ש
זה outro לCS50.

1190
00:52:46,956 --> 00:52:48,652
>> דוד J מלאן: עדיין לא.

1191
00:52:48,652 --> 00:52:49,151