1
00:00:00,000 --> 00:00:03,381
>> [השמעת מוסיקה]

2
00:00:03,381 --> 00:00:10,626

3
00:00:10,626 --> 00:00:11,610
>> [וידאו השמעה]

4
00:00:11,610 --> 00:00:13,640
>> -הוא משקר.

5
00:00:13,640 --> 00:00:14,380
>> -לגבי מה?

6
00:00:14,380 --> 00:00:17,182
>> -אני לא יודע.

7
00:00:17,182 --> 00:00:19,990
>> -אז מה אנחנו יודעים?

8
00:00:19,990 --> 00:00:23,145
>> חייהם." בשעת 9:15, ריי
Santoya היה בכספומט.

9
00:00:23,145 --> 00:00:23,644
'כן.

10
00:00:23,644 --> 00:00:27,030
אז השאלה היא, מה
הוא עשה בשעת 9:16?

11
00:00:27,030 --> 00:00:29,720
>> -Shooting המילימטר 9 במשהו.

12
00:00:29,720 --> 00:00:31,540
אולי הוא ראה את הצלף.

13
00:00:31,540 --> 00:00:33,412
>> -או עבד איתו.

14
00:00:33,412 --> 00:00:34,340
>> לחכות.

15
00:00:34,340 --> 00:00:36,200
חזור אחד.

16
00:00:36,200 --> 00:00:36,975
>> -מה אתה רואה?

17
00:00:36,975 --> 00:00:44,400

18
00:00:44,400 --> 00:00:47,805
>> -Bring את פניו במסך מלא.

19
00:00:47,805 --> 00:00:48,680
>> משקפיו התיזו.

20
00:00:48,680 --> 00:00:50,060
>> "מצאתי השתקפות.

21
00:00:50,060 --> 00:01:00,455

22
00:01:00,455 --> 00:01:02,280
>> "זאת קבוצת בייסבול Nuevitas.

23
00:01:02,280 --> 00:01:03,110
זה הלוגו שלהם.

24
00:01:03,110 --> 00:01:05,820
>> -ואז הוא מדבר ל
מי שלובש מעיל ש.

25
00:01:05,820 --> 00:01:06,670
>> [סוף ההשמעה]

26
00:01:06,670 --> 00:01:07,628
>> DAVID מלאן: בסדר.

27
00:01:07,628 --> 00:01:11,210
זה CS50 וזה קצת יותר
של [לא ברור] שבה אתה

28
00:01:11,210 --> 00:01:12,890
מתעסק עם בעיה להגדיר ארבעה.

29
00:01:12,890 --> 00:01:16,606
היום אנחנו מתחילים להיראות קצת יותר
עמוק בדברים האלה נקראים מצביעים,

30
00:01:16,606 --> 00:01:18,480
שלמרות שזה
נושא די מסתורי,

31
00:01:18,480 --> 00:01:20,813
מתברר שזה הולך
להיות הכלי שבאמצעותו אנחנו

32
00:01:20,813 --> 00:01:24,320
יכול להתחיל בבנייה והרכבה
תוכניות הרבה יותר מתוחכמות.

33
00:01:24,320 --> 00:01:28,150
אבל עשיתי את זה ביום רביעי האחרון
בדרך של כמה אולפן הראשון.

34
00:01:28,150 --> 00:01:30,190
אז זה, כזכור, הוא
בינקי והיינו לו

35
00:01:30,190 --> 00:01:33,148
להעיף מבט בתכנית ש
לא באמת לעשות משהו מעניין,

36
00:01:33,148 --> 00:01:34,950
אבל זה לא לחשוף כמה בעיות.

37
00:01:34,950 --> 00:01:38,570
אז כדי להתחיל היום, למה שלא ללכת
במהירות באמצעות כמה צעדים אלה,

38
00:01:38,570 --> 00:01:41,920
מנסה לזקק למונחים של האדם
בדיוק מה שקורה כאן

39
00:01:41,920 --> 00:01:45,410
ולמה זה רע, ולאחר מכן לעבור
ובעצם להתחיל לבנות משהו

40
00:01:45,410 --> 00:01:46,309
עם טכניקה זו?

41
00:01:46,309 --> 00:01:48,350
אז אלה היו הראשונים
שני קווים בתכנית זו

42
00:01:48,350 --> 00:01:51,340
ובמונחים של ההדיוט, מה
עושים שני הקווים האלה?

43
00:01:51,340 --> 00:01:55,600
מישהו שנוח למדי
עם מה שהכריז על המסך?

44
00:01:55,600 --> 00:01:58,340

45
00:01:58,340 --> 00:02:00,120
מה הם שני הקווים האלה עושים?

46
00:02:00,120 --> 00:02:02,070
זה לא כל כך
שונה משבוע אחד,

47
00:02:02,070 --> 00:02:03,611
אבל יש כמה סמל מיוחד חדש.

48
00:02:03,611 --> 00:02:04,152
כן?

49
00:02:04,152 --> 00:02:05,628
חזרה לשם.

50
00:02:05,628 --> 00:02:07,092
>> קהל: הכרזת מצביעים?

51
00:02:07,092 --> 00:02:08,050
DAVID מלאן: תגיד שוב?

52
00:02:08,050 --> 00:02:08,860
קהל: הכרזת מצביעים?

53
00:02:08,860 --> 00:02:11,776
DAVID מלאן: מצביעי הכרזה ו
בואו לחדד את זה קצת יותר.

54
00:02:11,776 --> 00:02:14,050
קהל: [לא ברור]
x כתובת ואז y.

55
00:02:14,050 --> 00:02:15,300
DAVID מלאן: ואז לטפל.

56
00:02:15,300 --> 00:02:18,550
אז מה בדיוק אנחנו עושים
הוא אנו מכריזים שני משתנים.

57
00:02:18,550 --> 00:02:21,252
משתנה אלה, אם כי, הולכים
להיות כוכב של int סוג, ש

58
00:02:21,252 --> 00:02:23,210
באופן ספציפי יותר משמעות
הם הולכים לחנות

59
00:02:23,210 --> 00:02:26,450
הכתובת של int,
בהתאמה, X ו- Y.

60
00:02:26,450 --> 00:02:27,660
עכשיו האם יש ערכים?

61
00:02:27,660 --> 00:02:32,621
האם יש כתובות בפועל באלה
שני משתנים בנקודה זו בזמן?

62
00:02:32,621 --> 00:02:33,120
מס '

63
00:02:33,120 --> 00:02:35,030
זה פשוט מה שנקרא ערכי זבל.

64
00:02:35,030 --> 00:02:38,120
אם אתה לא באמת להקצות
משתנה, כל מה שהיה בזכרון RAM

65
00:02:38,120 --> 00:02:42,224
בעבר הוא הולך למלא עם אפסים
ואלה שני משתנים אלו.

66
00:02:42,224 --> 00:02:44,140
אבל אנחנו עדיין לא יודעים
מה הם וזה

67
00:02:44,140 --> 00:02:47,060
הולך להיות מפתח למה ינקי
איבד את ראשו בשבוע שעבר.

68
00:02:47,060 --> 00:02:49,980
>> אז זה היה האולפן
גלגול של זה

69
00:02:49,980 --> 00:02:53,580
לפי שיש לך רק שני משתנים,
חתיכות עגולות קטנות של חימר,

70
00:02:53,580 --> 00:02:57,330
שיכול לאחסן משתנה, אלא כ
החיצים עטופים מציעים,

71
00:02:57,330 --> 00:03:00,640
הם לא ממש מצביעים
לכל מקום ידוע כשלעצמו.

72
00:03:00,640 --> 00:03:03,670
אז היה לנו את הקו הזה, וזה
היה בשבוע שעבר, malloc החדש לזיכרון

73
00:03:03,670 --> 00:03:07,130
הקצאה, אשר היא רק דרך מפוארת
לספר את מערכת ההפעלה, לינוקס

74
00:03:07,130 --> 00:03:09,750
או Mac OS או Windows,
היי, תן ​​לי קצת זיכרון,

75
00:03:09,750 --> 00:03:11,780
וכל מה שיש לך להגיד
מערכת ההפעלה

76
00:03:11,780 --> 00:03:14,699
זה מה שכאשר שואל אותו לזיכרון.

77
00:03:14,699 --> 00:03:16,990
זה לא הולך לאכפת לי מה
אתה הולך לעשות עם זה,

78
00:03:16,990 --> 00:03:19,786
אבל אתה צריך להגיד ההפעלה
מערכת מה בדרך של malloc.

79
00:03:19,786 --> 00:03:20,286
כן?

80
00:03:20,286 --> 00:03:21,078
>> קהל: כמה?

81
00:03:21,078 --> 00:03:21,994
DAVID מלאן: כמה?

82
00:03:21,994 --> 00:03:25,280
כמה בבתים, וכך, זה, שוב,
דוגמא מאולצת, היא רק אומרת,

83
00:03:25,280 --> 00:03:27,360
תן לי את הגודל של int.

84
00:03:27,360 --> 00:03:30,550
עכשיו, בגודל של int
הוא ארבעה בתים או 32 סיביות.

85
00:03:30,550 --> 00:03:32,850
אז זה רק דרך
אומר, היי, מערכת הפעלה,

86
00:03:32,850 --> 00:03:37,290
תן לי ארבעה בתים של זיכרון
שאני יכול להשתמש שברשותי,

87
00:03:37,290 --> 00:03:40,560
ובאופן ספציפי, מה עושה
תמורת malloc בכבוד

88
00:03:40,560 --> 00:03:41,795
לנתח של ארבעה בתים?

89
00:03:41,795 --> 00:03:44,110

90
00:03:44,110 --> 00:03:44,860
קהל: כתובת?

91
00:03:44,860 --> 00:03:45,901
DAVID מלאן: כתובת.

92
00:03:45,901 --> 00:03:47,580
הכתובת של נתח זה של ארבעה בתים.

93
00:03:47,580 --> 00:03:48,190
בדיוק.

94
00:03:48,190 --> 00:03:51,430
ואז זה מה שהוא מאוחסן סופו של דבר
בx ולכן אנחנו לא באמת

95
00:03:51,430 --> 00:03:55,240
אכפת לי מה מספר ש
כתובת היא, בין אם זה ox1 או OX2

96
00:03:55,240 --> 00:03:57,110
או כמה כתובת הקסדצימלי נסתרות.

97
00:03:57,110 --> 00:03:59,850
רק אכפת לנו ציורי
שx משתנה הוא עכשיו

98
00:03:59,850 --> 00:04:01,630
מצביע על נתח זה של זיכרון.

99
00:04:01,630 --> 00:04:05,570
אז החץ מייצג מצביע, או
באופן יותר ספציפי, כתובת זיכרון.

100
00:04:05,570 --> 00:04:09,120
אבל שוב, לא אכפת לנו בדרך כלל
מה הן כתובות בפועל אלה.

101
00:04:09,120 --> 00:04:11,780
עכשיו, קו זה אומר
מה במונחים של ההדיוט?

102
00:04:11,780 --> 00:04:14,330
x כוכבים מקבל 42 פסיק.

103
00:04:14,330 --> 00:04:17,390
מה זה אומר?

104
00:04:17,390 --> 00:04:18,200
אתה רוצה ללכת?

105
00:04:18,200 --> 00:04:20,102
לא לגרד את הצוואר שלך.

106
00:04:20,102 --> 00:04:22,360
>> קהל: הכתובת של x היא ב42.

107
00:04:22,360 --> 00:04:24,300
>> DAVID מלאן: הכתובת של x היא על 42.

108
00:04:24,300 --> 00:04:25,190
לא בדיוק.

109
00:04:25,190 --> 00:04:28,485
כל כך קרוב, אבל לא ממש, כי אין
הכוכב זה קידומת X זה.

110
00:04:28,485 --> 00:04:29,860
אז אנחנו צריכים לצבוט קצת.

111
00:04:29,860 --> 00:04:31,032
כן?

112
00:04:31,032 --> 00:04:36,044
>> קהל: הערך ש
x המצביע מצביע להם 42.

113
00:04:36,044 --> 00:04:36,710
DAVID מלאן: אישור.

114
00:04:36,710 --> 00:04:40,840
הערך שx המצביע הוא
מצביע על, נניח, יהיה 42,

115
00:04:40,840 --> 00:04:44,165
או במילים אחרת, את הכוכב
x אומר, ללכת לכל כתובת

116
00:04:44,165 --> 00:04:48,340
הוא בx, בין אם זה 1 אוקספורד
רחוב אוקספורד סטריט או 33

117
00:04:48,340 --> 00:04:51,850
או ox1 או ox33, מה ש
שכתובת מספרית היא,

118
00:04:51,850 --> 00:04:54,380
x הכוכב הוא ביטול ההפניה של x.

119
00:04:54,380 --> 00:04:57,297
אז ללכת לכתובת זו ו
ואז לשים את המספר 42 שם.

120
00:04:57,297 --> 00:04:59,380
כך שיהיה
דרך שווה ערך לומר ש.

121
00:04:59,380 --> 00:05:01,860
אז זה בסדר גמור ולאחר מכן
היינו מייצג את התמונה

122
00:05:01,860 --> 00:05:05,370
כדלקמן בי הוספנו
42 לנתח של ארבעה

123
00:05:05,370 --> 00:05:09,370
ביטים בצד ימין, אבל
הקו הזה היה בו דברים השתבשו

124
00:05:09,370 --> 00:05:11,120
וראשו של הינקי צץ
את בשלב זה,

125
00:05:11,120 --> 00:05:15,290
כי דברים רעים קורים כש
אתה dereference ערכי זבל

126
00:05:15,290 --> 00:05:18,210
או שאתה dereference לא חוקי
מצביעים, ואני אומר לא חוקי

127
00:05:18,210 --> 00:05:21,020
כי בשלב זה ב
סיפור, מה יש בתוכו של y?

128
00:05:21,020 --> 00:05:24,440
מה הערך של y מבוסס
בכמה הצעדים האחרונים?

129
00:05:24,440 --> 00:05:25,360
כן?

130
00:05:25,360 --> 00:05:26,115
מה זה?

131
00:05:26,115 --> 00:05:26,990
>> קהל: כתובת.

132
00:05:26,990 --> 00:05:28,460
DAVID מלאן: כתובת.

133
00:05:28,460 --> 00:05:31,910
זה צריך להיות כתובת
אבל יש לי אותחל זה?

134
00:05:31,910 --> 00:05:32,800
אז יש לי עדיין לא.

135
00:05:32,800 --> 00:05:35,430
אז מה ידוע להיות שם?

136
00:05:35,430 --> 00:05:37,590
זה רק חלק ערך זבל.

137
00:05:37,590 --> 00:05:41,500
זה יכול להיות כל כתובת מאפס ל
2 מיליארדים אם יש לך שתי הופעות של זיכרון RAM,

138
00:05:41,500 --> 00:05:44,289
או אפס 4 מיליארדים אם יש לך
קיבלתי ארבע ג'יגה-בייט של זיכרון RAM.

139
00:05:44,289 --> 00:05:46,080
זה קצת ערך זבל,
אבל הבעיה היא

140
00:05:46,080 --> 00:05:48,200
כי מערכת ההפעלה,
אם זה לא נתן לך

141
00:05:48,200 --> 00:05:51,140
במיוחד נתח זה של זיכרון
שאתה מנסה ללכת,

142
00:05:51,140 --> 00:05:54,650
זה בדרך כלל הולך לגרום מה
שראינו כאשמת פילוח.

143
00:05:54,650 --> 00:05:57,810
כך שלמעשה, כל אחד מכם שיש להם
נאבק בבעיות בשעתי עבודה

144
00:05:57,810 --> 00:06:00,393
או בבעיות שיותר
בדרך כלל עם מנסה להבין

145
00:06:00,393 --> 00:06:02,150
אשמת פילוח,
שפירושה בדרך כלל

146
00:06:02,150 --> 00:06:05,017
אתה נוגע קטע של
זיכרון שאתה לא צריך להיות.

147
00:06:05,017 --> 00:06:07,350
אתה נוגע בזיכרון ש
מערכת ההפעלה יש לא

148
00:06:07,350 --> 00:06:10,450
מותר לך לגעת, בין אם זה
על ידי הולך רחוק מדי במערך שלך

149
00:06:10,450 --> 00:06:12,870
או מתחיל עכשיו, אם
זה בגלל שאתה נוגע

150
00:06:12,870 --> 00:06:14,780
זיכרון שרק הוא ערך כלשהו אשפה.

151
00:06:14,780 --> 00:06:18,230
>> אז עושה x כוכב כאן
סוג של התנהגות בלתי מוגדרת.

152
00:06:18,230 --> 00:06:22,030
אתה לא צריך לעשות את זה כי סיכויים
הם, התכנית רק הולכת להתרסק,

153
00:06:22,030 --> 00:06:24,050
בגלל שאתה אומר,
ללכת לכתובת זו

154
00:06:24,050 --> 00:06:27,000
ואין לך מושג בי
כתובת שהיא למעשה.

155
00:06:27,000 --> 00:06:30,300
אז מערכת ההפעלה צפויה
הולך להתרסק התכנית שלך

156
00:06:30,300 --> 00:06:33,840
כתוצאה מכך, ואכן, זה
מה קרה שם לינקי.

157
00:06:33,840 --> 00:06:37,210
אז בסופו, קבוע בינקי
בעיה זו עם זו.

158
00:06:37,210 --> 00:06:38,909
אז התכנית שעצמו היה פגום.

159
00:06:38,909 --> 00:06:41,450
אבל אם אתה סוג של לפרוץ קדימה
ולבצע את הקו הזה במקום,

160
00:06:41,450 --> 00:06:45,580
y שווה x רק אומר מה ש
כתובת היא x, גם לשים אותו בy.

161
00:06:45,580 --> 00:06:48,740
>> וכך ציורי, יש לנו
ייצגתי את זה עם שני חיצים

162
00:06:48,740 --> 00:06:51,570
מx ומהצבעת y
לאותו המקום.

163
00:06:51,570 --> 00:06:55,760
אז מבחינה סמנטית, x הוא שווה
לy כי שני אלה

164
00:06:55,760 --> 00:07:00,300
מאחסנים אותו
כתובת, ergo מצביע על 42,

165
00:07:00,300 --> 00:07:04,910
ועכשיו, כשאתה אומר כוכב
y, ללכת לכתובת בy,

166
00:07:04,910 --> 00:07:06,790
זה יש תופעת לוואי מעניין.

167
00:07:06,790 --> 00:07:10,320
אז הכתובת בy היא
אותו דבר כמו הכתובת בx.

168
00:07:10,320 --> 00:07:15,060
אז אם אתה אומר ללכת לכתובת
בy ולשנות את הערך ל -13,

169
00:07:15,060 --> 00:07:17,140
מי עוד נפגע?

170
00:07:17,140 --> 00:07:21,100
X הוא, נקודת D, כביכול,
צריך להיות מושפע גם כן.

171
00:07:21,100 --> 00:07:24,340
>> ואכן, איך ניק משך תמונה זו
באולפן היה בדיוק את זה.

172
00:07:24,340 --> 00:07:28,665
למרות שאנחנו בצענו את המצביע
y, בסופו שלנו באותו המקום,

173
00:07:28,665 --> 00:07:32,780
ולכן אם היינו להדפיס
את x או y pointee של,

174
00:07:32,780 --> 00:07:35,720
אז היינו רואה את הערך של 13.

175
00:07:35,720 --> 00:07:37,927
עכשיו, אני אומר pointee להיות
עולה בקנה אחד עם הווידאו.

176
00:07:37,927 --> 00:07:39,760
מתכנתים, לשלי
ידע, אף פעם לא באמת

177
00:07:39,760 --> 00:07:42,460
לומר את המילה pointee,
שבו הוא מחודד

178
00:07:42,460 --> 00:07:44,650
ב, אבל לעקביות
עם הווידאו, מבין

179
00:07:44,650 --> 00:07:47,520
זה כל מה שהיה
התכוון במצב זה.

180
00:07:47,520 --> 00:07:54,190
אז שאלות על אולפן
או מצביעים או malloc עדיין?

181
00:07:54,190 --> 00:07:54,850
לא?

182
00:07:54,850 --> 00:07:55,470
בסדר.

183
00:07:55,470 --> 00:07:58,560
>> אז בלי עוד
ADO, בואו נסתכל

184
00:07:58,560 --> 00:08:00,700
שבבו זה למעשה יש
שימש במשך זמן מה.

185
00:08:00,700 --> 00:08:03,580
אז היו לנו ספריית CS50 זה
שיש לו כל הפונקציות הללו.

186
00:08:03,580 --> 00:08:06,810
אנחנו השתמשנו GetInt הרבה, GetString,
כנראה GetLongLong קודם לכן

187
00:08:06,810 --> 00:08:09,840
בPSet אחד או כך, אבל
מה בעצם קרה?

188
00:08:09,840 --> 00:08:12,920
ובכן, בואו ניקח מבט מהיר
מתחת למכסה המנוע בתכנית ש

189
00:08:12,920 --> 00:08:17,017
השראה למה שאנו נותנים לך את CS50
ספרייה, ואכן כשל שבוע שעבר,

190
00:08:17,017 --> 00:08:18,850
התחלנו לקחת אותם
גלגלי עזר מ.

191
00:08:18,850 --> 00:08:21,080
אז זה עכשיו מסודרים
של נתיחה שלאחר המוות של מה

192
00:08:21,080 --> 00:08:23,690
כבר קורה
בתוך ספריית CS50,

193
00:08:23,690 --> 00:08:27,250
למרות שאנחנו עכשיו נתחיל לזוז
מזה עבור רוב התוכניות.

194
00:08:27,250 --> 00:08:29,460
>> אז זה תכנית בשם scanf 0.

195
00:08:29,460 --> 00:08:30,510
זה סופר קצר.

196
00:08:30,510 --> 00:08:33,909
זה פשוט יש שורות אלה, אבל זה
מציג scanf פונקציה שנקראת

197
00:08:33,909 --> 00:08:36,909
שאנחנו בעצם הולכים לראות ב
רגע הפנימי של ספריית CS50,

198
00:08:36,909 --> 00:08:38,600
אם כי בצורה מעט שונה.

199
00:08:38,600 --> 00:08:41,330
אז בתכנית זו בקו 16
מכריז x משתנה.

200
00:08:41,330 --> 00:08:43,150
אז תן לי ארבעה בתים לint.

201
00:08:43,150 --> 00:08:45,750
זה כבר אומר למשתמש,
מספר בבקשה, ולאחר מכן

202
00:08:45,750 --> 00:08:49,010
זה קו מעניין ש
קושר יחד למעשה בשבוע שעבר

203
00:08:49,010 --> 00:08:49,790
וזה.

204
00:08:49,790 --> 00:08:53,230
Scanf, ולאחר מכן שמו לב שלוקח
מחרוזת פורמט, בדיוק כמו printf,

205
00:08:53,230 --> 00:08:57,480
אני אומר% int, ואז זה לוקח
טיעון שני שנראה קצת

206
00:08:57,480 --> 00:08:58,260
פאנקי.

207
00:08:58,260 --> 00:09:01,880
זה x אמפרסנד, ולהיזכר,
רק שראינו פעם בשבוע האחרון.

208
00:09:01,880 --> 00:09:03,465
מה x האמפרסנד אין מייצג?

209
00:09:03,465 --> 00:09:06,210

210
00:09:06,210 --> 00:09:08,450
מה אמפרסנד עושה בC?

211
00:09:08,450 --> 00:09:08,950
כן?

212
00:09:08,950 --> 00:09:10,024
>> קהל: כתובת.

213
00:09:10,024 --> 00:09:11,190
DAVID מלאן: כתובת.

214
00:09:11,190 --> 00:09:13,190
אז זה ההפך
של מפעיל הכוכב,

215
00:09:13,190 --> 00:09:17,270
ואילו מפעיל הכוכב אומר, ללכת ל
כתובת זו, מפעיל האמפרסנד

216
00:09:17,270 --> 00:09:20,280
אומר, להבין את
כתובת של משתנה זה,

217
00:09:20,280 --> 00:09:23,530
ואז זה מפתח, משום ש
המטרה של scanf בחיים

218
00:09:23,530 --> 00:09:26,320
הוא לסרוק את המשתמש של
קלט מהמקלדת,

219
00:09:26,320 --> 00:09:29,970
בהתאם לכל מה שהוא או היא
סוגים, ולאחר מכן לקרוא קלט של המשתמש ש

220
00:09:29,970 --> 00:09:32,970
למשתנה, אבל אנחנו
ראה בשבועות האחרונים

221
00:09:32,970 --> 00:09:36,080
שפונקצית ההחלפה ש
ניסיתי ללא מאמץ ליישם

222
00:09:36,080 --> 00:09:37,110
רק נשבר.

223
00:09:37,110 --> 00:09:42,470
נזכיר כי עם פונקצית swap,
אם אנחנו רק הכריזו A ו- B כints,

224
00:09:42,470 --> 00:09:47,040
אנו לא בהצלחה להחליף
שני משתנים פנימיים של החלפה

225
00:09:47,040 --> 00:09:50,080
בדיוק כמו עם חלב וג'יי,
אבל ברגע שההחלפה חזרו,

226
00:09:50,080 --> 00:09:55,200
מה הייתה התוצאה עם כבוד
לx ו- y, הערכים המקוריים?

227
00:09:55,200 --> 00:09:55,700
לא כלום.

228
00:09:55,700 --> 00:09:56,200
כן.

229
00:09:56,200 --> 00:09:59,754
שום דבר לא קרה שזמן, משום ש
חילופים לשנות רק עותקים המקומיים שלה,

230
00:09:59,754 --> 00:10:01,670
כלומר, כל
הפעם, בכל פעם שיש לנו

231
00:10:01,670 --> 00:10:04,010
כבר עובר בטיעונים
לפונקציות, אנחנו

232
00:10:04,010 --> 00:10:05,939
רק עובר עותקים של טענות אלה.

233
00:10:05,939 --> 00:10:07,980
אתה יכול לעשות עם זה
מה שאתה רוצה איתם,

234
00:10:07,980 --> 00:10:10,890
אבל הם הולכים אין לי
השפעה על הערכים המקוריים.

235
00:10:10,890 --> 00:10:13,650
אז זה בעייתי אם אתה
רוצה להיות פונקציה כמו scanf

236
00:10:13,650 --> 00:10:17,170
בחיים, שמטרתה לסרוק
הקלט של המשתמש מהמקלדת

237
00:10:17,170 --> 00:10:22,010
ולאחר מכן למלא את החסר, ולכן ל
לדבר, כלומר, לתת משתנה כמו x

238
00:10:22,010 --> 00:10:25,410
ערך, משום שאם היינו
רק כדי לעבור x לscanf,

239
00:10:25,410 --> 00:10:28,790
אם אתה מחשיב את ההיגיון של אחרון
שבוע, scanf יכול לעשות מה שהיא רוצה

240
00:10:28,790 --> 00:10:33,100
עם עותק של x, אבל זה לא יכול
לשנות לצמיתות x אלא אם כן אנחנו נותנים

241
00:10:33,100 --> 00:10:37,120
scanf מפת אוצר, כביכול,
כאשר x מסמן את המקום, שבו

242
00:10:37,120 --> 00:10:41,860
אנחנו עוברים בכתובת של x, כך ש
scanf יכול ללכת לשם ולמעשה שינוי

243
00:10:41,860 --> 00:10:42,920
הערך של x.

244
00:10:42,920 --> 00:10:45,080
וכך אכן, כל
כי תכנית זו עושה

245
00:10:45,080 --> 00:10:53,180
אם אני עושה scanf 0, במקור שלי
ספריית 5M, לעשות scanf 0,

246
00:10:53,180 --> 00:10:57,730
מספר הנקודה לקצץ scanf,
בבקשה 50, תודה על 50.

247
00:10:57,730 --> 00:11:01,020
>> אז זה לא כל כך מעניין,
אבל מה באמת קורה

248
00:11:01,020 --> 00:11:04,820
הוא שברגע שאני קורא
scanf כאן, את הערך של x

249
00:11:04,820 --> 00:11:06,410
הוא להיות שונה באופן קבוע.

250
00:11:06,410 --> 00:11:08,335
עכשיו, זה נראה נחמד ו
ולמעשה טובים,, זה

251
00:11:08,335 --> 00:11:11,200
נראה כמו שאנחנו לא באמת צריכים
ספריית CS50 בכלל יותר.

252
00:11:11,200 --> 00:11:13,960
לדוגמא, בואו לרוץ
זה שוב כאן.

253
00:11:13,960 --> 00:11:15,750
תן לי לפתוח אותו מחדש לשנייה.

254
00:11:15,750 --> 00:11:20,600
בואו ננסה מספר אנא ו
במקום לומר 50 כמו בעבר,

255
00:11:20,600 --> 00:11:22,810
בואו פשוט להגיד לא.

256
00:11:22,810 --> 00:11:24,000
בסדר, זה קצת מוזר.

257
00:11:24,000 --> 00:11:25,270
אוקיי.

258
00:11:25,270 --> 00:11:28,680
ורק חלק שטויות כאן.

259
00:11:28,680 --> 00:11:31,170
אז זה לא נראה לי
להתמודד עם מצבים מוטעים.

260
00:11:31,170 --> 00:11:33,620
אז אנחנו צריכים מינימאלי התחלה
הוספה כמה בדיקת שגיאות

261
00:11:33,620 --> 00:11:37,460
לוודא שיש למשתמש
הקליד מספר אמיתי כמו 50,

262
00:11:37,460 --> 00:11:40,720
בגלל מילות הקלדה כנראה
לא זוהה כבעייתי,

263
00:11:40,720 --> 00:11:42,020
אבל זה כנראה צריך להיות.

264
00:11:42,020 --> 00:11:46,450
>> בואו נסתכל על גרסה זו כעת זה
הניסיון שלי reimplement GetString.

265
00:11:46,450 --> 00:11:48,437
אם scanf יש את כל זה
פונקציונלי מובנה,

266
00:11:48,437 --> 00:11:51,270
מדוע יש לנו הייתי מתעסק עם אלה
גלגלים כמו GetString אימון?

267
00:11:51,270 --> 00:11:55,450
ובכן, כאן הוא אולי שלי
גרסה פשוטה של ​​GetString

268
00:11:55,450 --> 00:12:00,766
לפי לפני שבוע, אולי הייתי אומר,
תן לי מחרוזת וקורא לזה חיץ.

269
00:12:00,766 --> 00:12:03,390
היום, אני הולך להתחיל רק
אומר כוכב char, אשר, כזכור,

270
00:12:03,390 --> 00:12:04,400
זה רק מילים נרדפים.

271
00:12:04,400 --> 00:12:06,629
זה נראה מפחיד אבל זה
את אותו הדבר בדיוק.

272
00:12:06,629 --> 00:12:09,420
אז תן לי חיץ משתנה בשם
זה הולך לאחסן מחרוזת,

273
00:12:09,420 --> 00:12:12,780
לספר מחרוזת המשתמשים בבקשה,
ואז, בדיוק כמו לפני,

274
00:12:12,780 --> 00:12:17,760
בואו ננסה לשאול את הלקח הזה scanf
% S הפעם ולאחר מכן לעבור במאגר.

275
00:12:17,760 --> 00:12:19,310
עכשיו, לבדוק את שפיות מהירה.

276
00:12:19,310 --> 00:12:22,120
למה אני לא אומר
אמפרסנד חיץ הפעם?

277
00:12:22,120 --> 00:12:25,190

278
00:12:25,190 --> 00:12:26,625
להסיק מהדוגמא הקודמת.

279
00:12:26,625 --> 00:12:28,000
קהל: כוכב תו הוא מצביע.

280
00:12:28,000 --> 00:12:29,920
DAVID מלאן: בדיוק,
כי הזמן, char זה

281
00:12:29,920 --> 00:12:34,080
כוכב הוא כבר מצביע, כתובת,
על ידי הגדרה של להיות שם כוכב ש.

282
00:12:34,080 --> 00:12:37,530
ואם scanf מצפה כתובת,
די פשוט לעבור במאגר.

283
00:12:37,530 --> 00:12:39,260
אני לא צריך לומר חיץ אמפרסנד.

284
00:12:39,260 --> 00:12:42,177
לסקרן, אתה יכול
לעשות משהו כזה.

285
00:12:42,177 --> 00:12:43,510
תהיה לו משמעות שונה.

286
00:12:43,510 --> 00:12:47,240
זה ייתן לך מצביע
למצביע, שהוא למעשה

287
00:12:47,240 --> 00:12:50,050
דבר תקף ב- C, אבל ל
עכשיו, בואו נשמור את זה פשוט

288
00:12:50,050 --> 00:12:51,750
ולשמור את הסיפור בקנה אחד.

289
00:12:51,750 --> 00:12:54,100
אני רק הולך לעבור ב
חיץ וזה נכון.

290
00:12:54,100 --> 00:12:56,487
הבעיה למרות שזה.

291
00:12:56,487 --> 00:12:58,820
תן לי ללכת קדימה ולהפעיל את זה
תכנית לאחר עריכתו.

292
00:12:58,820 --> 00:13:00,902
הפוך scanf 1.

293
00:13:00,902 --> 00:13:02,610
לעזאזל, מהדר שלי של
המושך את השגיאה שלי.

294
00:13:02,610 --> 00:13:04,090
תן לי שנייה אחת.

295
00:13:04,090 --> 00:13:05,460
צלצול.

296
00:13:05,460 --> 00:13:06,990
נניח scanf-1.c.

297
00:13:06,990 --> 00:13:10,880

298
00:13:10,880 --> 00:13:11,380
אוקיי.

299
00:13:11,380 --> 00:13:12,720
יש לנו ללכת.

300
00:13:12,720 --> 00:13:14,280
אני צריך את זה.

301
00:13:14,280 --> 00:13:16,750
יש מספר CS50 שונים
הגדרות תצורה

302
00:13:16,750 --> 00:13:18,280
שלהגן עליך מפני עצמך.

303
00:13:18,280 --> 00:13:21,300
אני צריך להשבית אלה על ידי
פועל צלצול ידני הפעם.

304
00:13:21,300 --> 00:13:22,140
אז מחרוזת בבקשה.

305
00:13:22,140 --> 00:13:25,560
אני הולך קדימה והקלד
בעולם שלום האהוב עליי.

306
00:13:25,560 --> 00:13:26,490
אישור, null.

307
00:13:26,490 --> 00:13:27,700
זה לא מה שהקלדתי.

308
00:13:27,700 --> 00:13:29,690
אז זה מעיד על
משהו לא בסדר להיות.

309
00:13:29,690 --> 00:13:33,920
תן לי ללכת קדימה והקלידו
במחרוזת ארוכה באמת.

310
00:13:33,920 --> 00:13:37,210
תודה על null ואני לא יודע
אם אני הולך להיות מסוגל לקרוס זה.

311
00:13:37,210 --> 00:13:40,240
בואו ננסה עותק קטן
להדביק ולראות אם זה עוזר.

312
00:13:40,240 --> 00:13:43,290
רק להדביק את זה הרבה.

313
00:13:43,290 --> 00:13:47,310
זה בהחלט גדול יותר
מחרוזת מהרגיל.

314
00:13:47,310 --> 00:13:51,450
בואו פשוט באמת לכתוב אותו.

315
00:13:51,450 --> 00:13:51,950
מס '

316
00:13:51,950 --> 00:13:52,650
לעזאזל.

317
00:13:52,650 --> 00:13:53,480
פקודה לא נמצא.

318
00:13:53,480 --> 00:13:54,550
אז זה לא קשור.

319
00:13:54,550 --> 00:13:56,440
זה בגלל שאני הודבק
כמה דמויות רעות,

320
00:13:56,440 --> 00:13:59,780
אבל זה מתברר לא הולך לעבוד.

321
00:13:59,780 --> 00:14:03,510
>> בואו ננסה את זה פעם אחת יותר, משום ש
זה כיף יותר אם בעצם אנחנו לקרוס זה.

322
00:14:03,510 --> 00:14:09,116
בואו נקליד את זה, ועכשיו, אני
הולך להעתיק מחרוזת ארוכה באמת

323
00:14:09,116 --> 00:14:10,990
ועכשיו בואו נראה אם ​​אנחנו
יכול לקרוס הדבר הזה.

324
00:14:10,990 --> 00:14:14,235
שים לב שהושמטתי חללים ו
קווים ונקודה-פסיק חדשים

325
00:14:14,235 --> 00:14:16,035
וכל דמויות פאנקי.

326
00:14:16,035 --> 00:14:16,535
הזן.

327
00:14:16,535 --> 00:14:21,090

328
00:14:21,090 --> 00:14:22,880
ועכשיו הרשת פשוט להיות איטית.

329
00:14:22,880 --> 00:14:27,460
אני החזקתי את הפיקוד-V יותר מדי זמן, באופן ברור.

330
00:14:27,460 --> 00:14:28,190
לעזאזל!

331
00:14:28,190 --> 00:14:29,260
פקודה לא נמצא.

332
00:14:29,260 --> 00:14:29,780
>> אוקיי.

333
00:14:29,780 --> 00:14:32,240
ובכן, הנקודה היא
בכל זאת הבא.

334
00:14:32,240 --> 00:14:36,910
אז מה בעצם קורה
עם הצהרה זו

335
00:14:36,910 --> 00:14:39,240
של חיץ כוכב char על קו 16?

336
00:14:39,240 --> 00:14:41,820
אז מה אני מקבל
כאשר אני מצהיר מצביע?

337
00:14:41,820 --> 00:14:47,440
כל מה שאני מקבל הוא ערך ארבעה בתים
נקרא חיץ, אבל מה יש בפנים שלה

338
00:14:47,440 --> 00:14:49,540
ברגע זה?

339
00:14:49,540 --> 00:14:50,930
זה רק חלק ערך זבל.

340
00:14:50,930 --> 00:14:54,170
כי כל פעם שאתה מכריז על משתנה
ב- C, זה רק חלק ערך זבל,

341
00:14:54,170 --> 00:14:56,220
ואנחנו מתחילים
טיול על מציאות זו.

342
00:14:56,220 --> 00:14:59,720
עכשיו, כשאני אומר לי scanf,
ללכת לכתובת זו

343
00:14:59,720 --> 00:15:01,520
ולשים את מה שהמשתמש מקליד.

344
00:15:01,520 --> 00:15:06,400
אם המשתמש מקליד בשלום
עולם, גם, שבו אין אני שם את זה?

345
00:15:06,400 --> 00:15:07,750
מאגר הוא ערך זבל.

346
00:15:07,750 --> 00:15:11,510
>> אז זה כמו סוג של חץ
שמצביע מי יודע לאן.

347
00:15:11,510 --> 00:15:13,880
אולי זה מצביע
ממש כאן בזכרוני.

348
00:15:13,880 --> 00:15:16,560
וכך, כאשר המשתמש
סוגים בעולם שלום,

349
00:15:16,560 --> 00:15:22,380
התכנית מנסה לשים
מחרוזת שלום עולם לוכסן 0

350
00:15:22,380 --> 00:15:23,910
בנתח של זיכרון.

351
00:15:23,910 --> 00:15:27,070
אבל בהסתברות גבוהה, אבל
ברור שלא 100% הסתברות,

352
00:15:27,070 --> 00:15:30,440
המחשב הולך אז לקרוס
התכנית כי זה לא

353
00:15:30,440 --> 00:15:32,490
זיכרון אני צריך להיות מותר לגעת.

354
00:15:32,490 --> 00:15:36,330
אז בקיצור, תכנית זו היא
פגום בדיוק סיבה ש.

355
00:15:36,330 --> 00:15:38,070
אני ביסודו לא עושה מה?

356
00:15:38,070 --> 00:15:42,366
מה צעדים שיש לי הושמט, בדיוק כמו
אנחנו הושמטו עם הדוגמא הראשונה של בינקי?

357
00:15:42,366 --> 00:15:42,866
כן?

358
00:15:42,866 --> 00:15:43,710
>> קהל: הקצאת זיכרון?

359
00:15:43,710 --> 00:15:45,001
>> DAVID מלאן: הקצאת זיכרון.

360
00:15:45,001 --> 00:15:48,400
אני לא הוקצה בפועל
זיכרון כל למחרוזת ש.

361
00:15:48,400 --> 00:15:50,270
אז אנחנו יכולים לתקן את זה בכמה דרכים.

362
00:15:50,270 --> 00:15:52,700
אחת, אנחנו יכולים לשמור את זה פשוט
ולמעשה, עכשיו אתה

363
00:15:52,700 --> 00:15:55,116
הולך להתחיל לראות טשטוש
של הקווים בין מה ש

364
00:15:55,116 --> 00:15:58,520
מערך הוא, מה היא מחרוזת מה,
כוכב char הוא, מה מערך של תווים

365
00:15:58,520 --> 00:15:59,020
הוא.

366
00:15:59,020 --> 00:16:02,450
הנה דוגמא שנייה
מעורב מחרוזות והודעה

367
00:16:02,450 --> 00:16:05,690
כל מה שעשיתי בקו
16 הוא, במקום לומר

368
00:16:05,690 --> 00:16:09,530
החיץ שהולך להיות char
כוכב, מצביע לנתח של זיכרון,

369
00:16:09,530 --> 00:16:14,057
אני הולך לתת לי מאוד באופן יזום
עצמי חיץ במשך 16 תווים,

370
00:16:14,057 --> 00:16:16,390
ולמעשה, אם אתה מכיר
עם חציצת הטווח,

371
00:16:16,390 --> 00:16:20,570
כנראה מהעולם של קטעי וידאו,
שבו וידאו היא חציצה, חציצה,

372
00:16:20,570 --> 00:16:21,175
חציצה.

373
00:16:21,175 --> 00:16:22,550
ובכן, מה הקשר כאן?

374
00:16:22,550 --> 00:16:24,960
ובכן, בתוך של YouTube
ובתוך נגני וידאו

375
00:16:24,960 --> 00:16:27,200
בדרך כלל הוא מערך
זה יותר גדול מ -16.

376
00:16:27,200 --> 00:16:30,340
זה יכול להיות מערך של גודל אחד
מגה, אולי 10 מגה בייט,

377
00:16:30,340 --> 00:16:34,330
ולתוך המערך שעושה את הדפדפן שלך
להוריד חבורה של בתים שלמה,

378
00:16:34,330 --> 00:16:37,500
חבורה של מגה בייט של כל
וידאו, ונגן וידאו,

379
00:16:37,500 --> 00:16:40,930
YouTube של או מי שזה, מתחיל
קריאת הבתים ממערך ש,

380
00:16:40,930 --> 00:16:43,530
וכל פעם שאתה רואה
מילת חציצה, חציצה,

381
00:16:43,530 --> 00:16:46,350
זה אומר שיש לו את השחקן
הגיע לסוף המערך ש.

382
00:16:46,350 --> 00:16:50,430
הרשת היא כל כך איטית שזה לא קרה
ומילא את המערך עם יותר בתים

383
00:16:50,430 --> 00:16:55,610
ואז אתה מסיבי
כדי להציג למשתמש.

384
00:16:55,610 --> 00:16:59,430
>> אז חיץ הוא מונח מתאים כאן שב
זה פשוט מערך, נתח של זיכרון.

385
00:16:59,430 --> 00:17:02,530
וזה יהיה לתקן את זה
כי מתברר

386
00:17:02,530 --> 00:17:07,410
שאתה יכול לטפל במערכים כאילו
למרות חיץ הם כתובות,

387
00:17:07,410 --> 00:17:10,710
הוא רק סמל, זה
רצף של תווים, חיץ,

388
00:17:10,710 --> 00:17:14,760
זה שימושי עבורי, מתכנת,
אתה יכול להעביר את שמו סביב

389
00:17:14,760 --> 00:17:17,079
כאילו היו
מצביע, כאילו זה

390
00:17:17,079 --> 00:17:21,000
היו הכתובת של נתח
זיכרון במשך 16 תווים.

391
00:17:21,000 --> 00:17:24,530
אז זה אומר, שאני יכול לעבור
scanf בדיוק מילה ש

392
00:17:24,530 --> 00:17:30,670
ואז עכשיו, אם אני עושה תכנית זו,
להפוך scanf 2, scanf לוכסן נקודת 2,

393
00:17:30,670 --> 00:17:35,386
והקלד בשלום עולם,
הזן, time-- ש

394
00:17:35,386 --> 00:17:37,590
>> הממ, מה קרה?

395
00:17:37,590 --> 00:17:39,340
מחרוזת בבקשה.

396
00:17:39,340 --> 00:17:41,430
מה עשה לא בסדר?

397
00:17:41,430 --> 00:17:43,800
שלום עולם, חיץ.

398
00:17:43,800 --> 00:17:44,705
שלום עולם.

399
00:17:44,705 --> 00:17:48,201

400
00:17:48,201 --> 00:17:49,420
אה, אני יודע מה זה עושה.

401
00:17:49,420 --> 00:17:49,920
אוקיי.

402
00:17:49,920 --> 00:17:51,628
אז זה קורא עד
עד החלל הראשון.

403
00:17:51,628 --> 00:17:55,680
אז בואו לרמות רק לרגע ו
אומר רק רציתי להקליד משהו

404
00:17:55,680 --> 00:18:01,408
באמת ארוך כמו זה משפט ארוך
זה אחד, שתיים, שלוש, ארבעה, חמש,

405
00:18:01,408 --> 00:18:04,420
שש, שבע, שמונה, תשע,
10, 11, 12, 13, 14, 15, 16.

406
00:18:04,420 --> 00:18:05,300
אוקיי.

407
00:18:05,300 --> 00:18:07,600
זה אכן משפט ארוך.

408
00:18:07,600 --> 00:18:10,710
אז המשפט הזה הוא
יותר מ- 16 תווים

409
00:18:10,710 --> 00:18:13,670
ולכן, כאשר אני על Enter,
מה הולך לקרות?

410
00:18:13,670 --> 00:18:16,940
ובכן, במקרה זה של
חיץ סיפור, שהכרזתי

411
00:18:16,940 --> 00:18:22,190
בעצם להיות מערך
עם 16 תווים מוכנים ללכת.

412
00:18:22,190 --> 00:18:27,426
אז אחת, שתיים, שלוש, ארבעה, חמש, שש,
שבע, שמונה, תשע, 10, 11, 12, 13, 14,

413
00:18:27,426 --> 00:18:29,440
15, 16.

414
00:18:29,440 --> 00:18:34,410
אז 16 תווים, ועכשיו, כשאני
לקרוא במשהו כזה הוא ארוך

415
00:18:34,410 --> 00:18:43,950
משפט, מה שהולך לקרות הוא
שאני הולך לקרוא בזה הוא ארוך

416
00:18:43,950 --> 00:18:49,660
S-E-N-T-E-N-C-E, משפט.

417
00:18:49,660 --> 00:18:52,270
>> אז זה בכוונה
דבר רע שאני

418
00:18:52,270 --> 00:18:55,060
לשמור על הכתיבה מעבר ל
גבולות של מערכי,

419
00:18:55,060 --> 00:18:56,660
מעבר לגבולות של החיץ שלי.

420
00:18:56,660 --> 00:19:00,100
אני יכול לקבל מזל והתכנית
ישמור על ריצה ולא אכפת לי,

421
00:19:00,100 --> 00:19:03,450
אבל באופן כללי, זה
אכן יתרסק התכנית שלי,

422
00:19:03,450 --> 00:19:06,440
וזה באג בי
קוד הרגע שאני צועד

423
00:19:06,440 --> 00:19:08,576
מעבר לגבולות
של מערך זה, כי אני

424
00:19:08,576 --> 00:19:10,450
לא יודע אם זה
בהכרח הולך להתרסק

425
00:19:10,450 --> 00:19:12,120
או אם אני רק הולך לקבל מזל.

426
00:19:12,120 --> 00:19:15,750
אז זה בעייתי כי ב
מקרה זה, נראה שהיא עובדת

427
00:19:15,750 --> 00:19:20,931
ולתת למרות של להתגרות בגורל כאן,
נראה IDE לסבול לא מעט

428
00:19:20,931 --> 00:19:21,430
ל--

429
00:19:21,430 --> 00:19:22,040
>> יש לנו ללכת.

430
00:19:22,040 --> 00:19:23,240
לבסוף.

431
00:19:23,240 --> 00:19:26,470
אז אני יחיד שיכול לראות את זה.

432
00:19:26,470 --> 00:19:29,630
אז פשוט הייתה לי הרבה הקלדת כיף
את ביטוי בפועל ממש ארוך

433
00:19:29,630 --> 00:19:32,800
כי זה בהחלט עלה
16 בתים, כי אני

434
00:19:32,800 --> 00:19:38,050
הקליד בקו רב הארוך המטורף הזה
ביטוי, ולאחר מכן שם לב מה קרה.

435
00:19:38,050 --> 00:19:41,110
התכנית ניסתה הדפסתו
ואז יש לי אשמת פילוח

436
00:19:41,110 --> 00:19:44,430
ופגמי פילוח הוא כאשר
משהו כזה קורה

437
00:19:44,430 --> 00:19:47,650
ומערכת ההפעלה אומרת
לא, לא יכול לגעת זיכרון ש.

438
00:19:47,650 --> 00:19:49,570
אנחנו הולכים להרוג
התכנית לגמרי.

439
00:19:49,570 --> 00:19:51,180
>> אז זה נראה בעייתי.

440
00:19:51,180 --> 00:19:54,540
אני כבר שיפרתי את התכנית לפיה
לפחות יש לי כמה זיכרון,

441
00:19:54,540 --> 00:19:58,000
אבל זה היה נראה להגביל
GetString הפונקציה מקבל

442
00:19:58,000 --> 00:20:00,780
מחרוזות של כמה אורך סופי 16.

443
00:20:00,780 --> 00:20:04,200
אז אם אתה רוצה לתמוך יותר
משפטים מ -16 תווים,

444
00:20:04,200 --> 00:20:04,880
במה אתה עוסק?

445
00:20:04,880 --> 00:20:07,970
ובכן, אתה יכול להגדיל את
גודל של חיץ זה 32

446
00:20:07,970 --> 00:20:09,190
או שנראה קצת קצר.

447
00:20:09,190 --> 00:20:12,260
למה אנחנו לא פשוט לעשות
זה 1,000 אבל לדחוף בחזרה.

448
00:20:12,260 --> 00:20:17,100
מה התגובה אינטואיטיבית של
רק הימנעות בעיה זו על ידי ביצוע

449
00:20:17,100 --> 00:20:20,660
החיץ שלי גדול יותר, כמו 1,000 תווים?

450
00:20:20,660 --> 00:20:23,470
על ידי יישום GetString דרך זו.

451
00:20:23,470 --> 00:20:27,130
מה טוב או רע כאן?

452
00:20:27,130 --> 00:20:28,033
כן?

453
00:20:28,033 --> 00:20:30,574
קהל: אם אתה לאגד את הרבה
של שטח ואתה לא משתמש בו,

454
00:20:30,574 --> 00:20:33,500
אז אתה לא יכול להקצות מחדש את המרחב הזה.

455
00:20:33,500 --> 00:20:34,500
DAVID מלאן: בהחלט.

456
00:20:34,500 --> 00:20:38,480
זה בזבזני ככל אם אתה לא
באמת צריכים 900 בתים אלה

457
00:20:38,480 --> 00:20:41,057
ובכל זאת אתה שואל ל
1,000 בסך הכל בכל מקרה,

458
00:20:41,057 --> 00:20:44,140
אתה רק רב יותר זיכרון ב
המחשב של המשתמש ממה שאתה צריך,

459
00:20:44,140 --> 00:20:45,740
ואחרי הכל, חלק מ
שכבר נתקלו ב

460
00:20:45,740 --> 00:20:47,620
בחיי שכשאתה
פועל הרבה תוכניות

461
00:20:47,620 --> 00:20:50,470
והם אוכלים את הרבה זיכרון,
זה באמת יכול להשפיע על ביצועים

462
00:20:50,470 --> 00:20:52,220
והניסיון של המשתמש
במחשב.

463
00:20:52,220 --> 00:20:56,090
אז זה סוג של פתרון עצלן,
בודאות, ולהפך,

464
00:20:56,090 --> 00:21:00,140
זה לא רק בזבזן מה בעיה,
עדיין, גם אם אני עושה החיץ שלי

465
00:21:00,140 --> 00:21:02,100
1,000?

466
00:21:02,100 --> 00:21:02,600
כן?

467
00:21:02,600 --> 00:21:04,475
>> קהל: המחרוזת היא אורך 1,001.

468
00:21:04,475 --> 00:21:05,350
DAVID מלאן: בדיוק.

469
00:21:05,350 --> 00:21:08,280
אם המחרוזת שלך היא אורך 1,001,
יש לך בדיוק את אותה בעיה,

470
00:21:08,280 --> 00:21:10,705
ועל ידי הטיעון שלי, הייתי
רק אז לעשות את זה 2000,

471
00:21:10,705 --> 00:21:12,830
אבל אתה לא יודע ב
לקדם כמה גדול הוא צריך להיות,

472
00:21:12,830 --> 00:21:16,890
ובכל זאת, אני צריך לקמפל את התכנית שלי
לפני לתת לאנשים להשתמש והורדה

473
00:21:16,890 --> 00:21:17,390
את זה.

474
00:21:17,390 --> 00:21:21,490
אז זה בדיוק מהסוג
דברים שמנסה ספריית CS50

475
00:21:21,490 --> 00:21:24,750
כדי לעזור לנו עם ואנחנו רק מבט חטוף
בחלק מיישום הבסיסי

476
00:21:24,750 --> 00:21:29,790
כאן, אבל זה CS50 נקודת C. זה
הוא הקובץ שהיה בCS50 IDE

477
00:21:29,790 --> 00:21:31,420
כל השבועות האלה אתה שכבר משתמש.

478
00:21:31,420 --> 00:21:34,280
זה הידור מראש ושיש לך
הייתי משתמש בו באופן אוטומטי

479
00:21:34,280 --> 00:21:38,780
על ידי טבע שיש
מקף דגל CS50 L עם צלצול,

480
00:21:38,780 --> 00:21:42,300
אבל אם אני לגלול למטה דרך כל
פונקציות אלה, הנה GetString,

481
00:21:42,300 --> 00:21:44,636
ורק כדי לתת לך
הטעם של מה שקורה,

482
00:21:44,636 --> 00:21:46,760
בואו ניקח מבט מהיר על
המורכבות היחסית.

483
00:21:46,760 --> 00:21:48,870
זה לא סופר ארוך
פונקציה, אבל אנחנו לא

484
00:21:48,870 --> 00:21:52,530
צריך לחשוב כל קשה על
איך ללכת על מקבל מחרוזות.

485
00:21:52,530 --> 00:21:55,660
>> אז הנה החיץ שלי ואני
כנראה לאתחל אותו לאפס.

486
00:21:55,660 --> 00:21:57,990
זה, כמובן, הוא
אותו דבר כמו כוכב char,

487
00:21:57,990 --> 00:22:00,585
אבל החלטתי ב
יישום ספריית CS50

488
00:22:00,585 --> 00:22:02,460
שאם אנחנו הולכים ל
להיות דינמי לחלוטין,

489
00:22:02,460 --> 00:22:05,770
אני לא יודע מראש כמה גדול של
משתמשי מחרוזת הולכים רוצים לקבל.

490
00:22:05,770 --> 00:22:08,140
אז אני הולך להתחיל
רק עם מחרוזת ריקה

491
00:22:08,140 --> 00:22:11,507
ואני הולך לבנות באותה המידה
זיכרון שאני צריך להתאים את מחרוזת המשתמשים

492
00:22:11,507 --> 00:22:13,340
ואם אין לי
מספיק, אני הולך לשאול

493
00:22:13,340 --> 00:22:15,010
מערכת ההפעלה לזיכרון נוסף.

494
00:22:15,010 --> 00:22:17,510
אני הולך להעביר מחרוזתם
לנתח גדול יותר של זיכרון

495
00:22:17,510 --> 00:22:21,847
ואני הולך לשחרר או לשחרר
נתח גדול מספיק של זיכרון

496
00:22:21,847 --> 00:22:23,680
ואנחנו רק הולכים
לעשות iteratively זה.

497
00:22:23,680 --> 00:22:25,570
>> אז מבט מהיר,
כאן רק משתנה

498
00:22:25,570 --> 00:22:28,780
עם שאני הולך לעקוב אחר
מהקיבולת של החיץ שלי.

499
00:22:28,780 --> 00:22:30,071
כמה בתים אני יכול להתאים?

500
00:22:30,071 --> 00:22:32,070
הנה n משתנה עם
שאני הולך לשמור

501
00:22:32,070 --> 00:22:36,200
אחר כמה בתים הם למעשה ב
החיץ או שהמשתמש הקליד.

502
00:22:36,200 --> 00:22:39,900
אם כבר אתה לא ראית את זה קודם, אתה
ניתן לציין כי משתנה כמו int

503
00:22:39,900 --> 00:22:46,370
אינו חתום, שכפי שהשם מרמז,
אומר שזה לא שלילי, ולמה ש

504
00:22:46,370 --> 00:22:50,590
אי פעם אני רוצה לטרוח ולציין
שint הוא לא רק int,

505
00:22:50,590 --> 00:22:52,540
אבל זה int חתום?

506
00:22:52,540 --> 00:22:55,064
זה int שאינו שלילי.

507
00:22:55,064 --> 00:22:56,355
מה [לא ברור] אומר?

508
00:22:56,355 --> 00:22:58,910
>> קהל: זה מתאר סכום
זיכרון שיכול להיות [לא ברור].

509
00:22:58,910 --> 00:22:59,660
>> DAVID מלאן: כן.

510
00:22:59,660 --> 00:23:03,710
אז אם אני אומר שאינו חתום, זה הוא למעשה
נותן לך אחד קצת זיכרון נוסף

511
00:23:03,710 --> 00:23:07,440
וזה נראה קצת טיפשי, אבל אם אתה
יש ביט אחד של זיכרון נוסף, ש

512
00:23:07,440 --> 00:23:09,940
אומר שיש לך פעמיים רבות
ערכים שאתה יכול לייצג,

513
00:23:09,940 --> 00:23:11,570
כי זה יכול להיות 0 או 1.

514
00:23:11,570 --> 00:23:14,660
אז כברירת מחדל, int יכול להיות בערך
השלילית של 2 מליארד כל הדרך

515
00:23:14,660 --> 00:23:16,030
עד 2 מיליארדים חיוביים.

516
00:23:16,030 --> 00:23:18,540
אלה הם טווחים גדולים, אבל
זה עדיין סוג של בזבזן

517
00:23:18,540 --> 00:23:21,280
אם אתה דואג רק ל
גדלים, שרק באופן אינטואיטיבי

518
00:23:21,280 --> 00:23:24,620
צריך להיות לא-שלילי או
חיובי או 0, גם אז,

519
00:23:24,620 --> 00:23:28,884
למה אתה מבזבז את 2 מליארד
ערכים אפשריים עבור מספרים שליליים

520
00:23:28,884 --> 00:23:30,300
אם אתה לא הולך להשתמש בם?

521
00:23:30,300 --> 00:23:35,350
אז באומרו עכשיו int חתום, שלי יכול
להיות בין 0 וכ -4 מליארד.

522
00:23:35,350 --> 00:23:39,280
>> אז הנה רק C int מסיבות
אנו לא תקבלו לעכשיו כ

523
00:23:39,280 --> 00:23:42,280
למה זה int במקום
של char, אבל כאן הוא

524
00:23:42,280 --> 00:23:44,630
התמצית של מה שקורה
ב, וכמה מכם

525
00:23:44,630 --> 00:23:48,340
עשוי להשתמש, למשל,
פונקצית fgetc אפילו בPSet ארבע

526
00:23:48,340 --> 00:23:51,580
או לאחר מכן, נוכל לראות את זה
שוב בבעיה להגדיר חמש,

527
00:23:51,580 --> 00:23:55,410
fgetc הוא נחמד, כי כשם
סוג של, סוג של arcanely מרמז,

528
00:23:55,410 --> 00:23:57,940
זה פונקציה ש
מקבל אופי וכך,

529
00:23:57,940 --> 00:24:00,690
מה שונה במהותו
על מה שאנחנו עושים בGetString

530
00:24:00,690 --> 00:24:03,110
הוא שאנחנו לא משתמשים ב
scanf באותה הדרך.

531
00:24:03,110 --> 00:24:07,550
אנחנו רק זוחלים לאורך צעד-אחר-צעד
על מה שהמשתמש הקליד ב,

532
00:24:07,550 --> 00:24:10,970
כי אנחנו תמיד יכולים להקצות אחד
char, ולכן אנחנו יכולים תמיד בבטחה

533
00:24:10,970 --> 00:24:15,599
להסתכל char אחד בכל פעם, ו
הקסם מתחיל לקרות כאן.

534
00:24:15,599 --> 00:24:17,890
אני הולך לגלול למטה ל
אמצע פונקציה זו

535
00:24:17,890 --> 00:24:20,360
רק כדי להציג בקצרה בפונקציה זו.

536
00:24:20,360 --> 00:24:22,670
הרבה כאילו יש
פונקצית malloc, יש

537
00:24:22,670 --> 00:24:27,740
פונקציה להקצות מחדש בי להקצות מחדש
מאפשר לך להקצות מחדש נתח של זיכרון

538
00:24:27,740 --> 00:24:29,570
ולהפוך אותו גדול יותר או קטן יותר.

539
00:24:29,570 --> 00:24:33,060
סיפור כל כך קצר וארוך עם
בהינף היד שלי להיום,

540
00:24:33,060 --> 00:24:35,620
יודע כי מה שGetString
הוא עושה הוא זה סוג

541
00:24:35,620 --> 00:24:39,720
של גידול באורח פלא או
מתכווץ החיץ כמשתמש

542
00:24:39,720 --> 00:24:41,440
סוגים במחרוזת שלו או שלה.

543
00:24:41,440 --> 00:24:43,962
>> אז אם המשתמש מקליד
מחרוזת קצרה, את הקוד הזה

544
00:24:43,962 --> 00:24:45,920
רק מקצה מספיק
זיכרון כדי להתאים את המחרוזת.

545
00:24:45,920 --> 00:24:48,086
אם המשתמש שומר הקלדה
כמו שעשיתי את זה שוב ושוב

546
00:24:48,086 --> 00:24:50,330
ושוב, גם אם
המאגר של התחלה זה גדול

547
00:24:50,330 --> 00:24:53,310
והתכנית מבינה, ל
חכה רגע, אני מחוץ למרחב,

548
00:24:53,310 --> 00:24:55,410
זה הולך להכפיל
גודלו של המאגר

549
00:24:55,410 --> 00:24:59,110
ואז להכפיל את גודלו של המאגר
ואת הקוד שעושה את ההכפלה,

550
00:24:59,110 --> 00:25:03,170
אם אנחנו מסתכלים על זה כאן, זה
רק זה אחד-אניה חכמה.

551
00:25:03,170 --> 00:25:06,830
ייתכן שלא ראה את תחביר זה
לפני, אבל אם אתה אומר כוכב שווה,

552
00:25:06,830 --> 00:25:10,470
זה אותו הדבר כמו
אומר קיבולת פעמים 2.

553
00:25:10,470 --> 00:25:13,390
אז זה פשוט ממשיך הכפלה
הקיבולת של החיץ

554
00:25:13,390 --> 00:25:17,480
ואז אומר לי להקצות מחדש לתת
עצמו שהרבה יותר זיכרון.

555
00:25:17,480 --> 00:25:19,720
>> עכשיו, במאמר מוסגר, יש
פונקציות אחרות בפה

556
00:25:19,720 --> 00:25:23,680
שלא ייראה לכל פרט
אחר מאשר להראות בGetInt,

557
00:25:23,680 --> 00:25:26,150
אנו משתמשים בGetString GetInt.

558
00:25:26,150 --> 00:25:28,192
אנחנו בודקים שזה לא
null, ש, כזכור,

559
00:25:28,192 --> 00:25:30,400
הוא הערך המיוחד ש
אומר משהו השתבש.

560
00:25:30,400 --> 00:25:31,233
אנחנו מתוך זיכרון.

561
00:25:31,233 --> 00:25:32,310
יותר טוב לבדוק את זה.

562
00:25:32,310 --> 00:25:33,710
ואנחנו חוזרים ערך זקיף.

563
00:25:33,710 --> 00:25:37,850
אבל אני לדחות להערות כמו ל
מדוע ולאחר מכן אנו משתמשים בבן הדוד הזה של scanf

564
00:25:37,850 --> 00:25:42,100
נקרא sscanf ומתברר
שscanf sscanf, או מחרוזת,

565
00:25:42,100 --> 00:25:45,310
מאפשר לך תסתכל על הקו ש
המשתמש שהוקלד ובלתת לך

566
00:25:45,310 --> 00:25:49,610
לנתח אותו בעצם ומה אני
עושה כאן הוא אני אומר לי sscanf,

567
00:25:49,610 --> 00:25:54,440
לנתח מה יש למשתמש
הקלדתי ולעשות אני בטוח%,

568
00:25:54,440 --> 00:25:59,250
יש מספר שלם בזה, ואנחנו לא
להיכנס היום בדיוק למה שיש גם

569
00:25:59,250 --> 00:26:03,760
ג% כאן, אבל זה על קצה מזלג מאפשר
שלנו כדי לזהות אם משתמש הקליד

570
00:26:03,760 --> 00:26:06,050
במשהו מזויף לאחר המספר.

571
00:26:06,050 --> 00:26:11,766
אז הסיבה שGetInt וGetString
להגיד לך לנסות שוב, לנסות שוב, לנסות שוב

572
00:26:11,766 --> 00:26:13,640
בגלל כל
שהקוד שכתבנו,

573
00:26:13,640 --> 00:26:17,900
זה סוג של מסתכל על הקלט של המשתמש
בהפיכת בטוחה שזה מספרי לגמרי

574
00:26:17,900 --> 00:26:21,700
או שזה צפים בפועל
ערך נקודה או כמו,

575
00:26:21,700 --> 00:26:24,233
תלוי מה ערך
לתפקד אתה משתמש.

576
00:26:24,233 --> 00:26:25,060
>> וואו.

577
00:26:25,060 --> 00:26:25,710
אוקיי.

578
00:26:25,710 --> 00:26:27,592
זה היה בפה מלא
אבל הנקודה כאן היא

579
00:26:27,592 --> 00:26:29,550
כי הסיבה שהיו לנו
גלגלי עזר אלה ב

580
00:26:29,550 --> 00:26:32,880
משום ברמה הנמוכה ביותר,
יש כל כך הרבה דברים ש

581
00:26:32,880 --> 00:26:35,674
יכול להשתבש שאנחנו רוצים
כדי להתמודד עם מנע

582
00:26:35,674 --> 00:26:38,090
אלה דברים בהחלט ב
שבועות הראשונים של הכיתה,

583
00:26:38,090 --> 00:26:42,230
אבל עכשיו עם PSet ארבעה וחמש וPSet
מעבר אתה תראה שזה יותר אל

584
00:26:42,230 --> 00:26:45,570
לך, אבל גם אתה מסוגל יותר
לפתרון מסוג הבעיות

585
00:26:45,570 --> 00:26:47,180
את עצמך.

586
00:26:47,180 --> 00:26:51,770
כל שאלות על GetString או GetInt?

587
00:26:51,770 --> 00:26:52,630
כן?

588
00:26:52,630 --> 00:26:55,130
>> קהל: למה אתה להכפיל
הקיבולת של החיץ

589
00:26:55,130 --> 00:26:57,630
ולא רק הגדלת
זה על ידי את הסכום המדויק?

590
00:26:57,630 --> 00:26:58,100
>> DAVID מלאן: שאלה טובה.

591
00:26:58,100 --> 00:27:00,474
למה לנו להכפיל את הקיבולת
למאגר בניגוד

592
00:27:00,474 --> 00:27:02,800
רק בהגדלתו
על ידי כמה ערך קבוע?

593
00:27:02,800 --> 00:27:03,900
זו הייתה החלטת עיצוב.

594
00:27:03,900 --> 00:27:08,590
אנחנו פשוט החלטנו שמשום שהוא נוטה ל
להיות קצת יקר בזמן חכם לשאול

595
00:27:08,590 --> 00:27:10,440
מערכת ההפעלה
לזיכרון, אנחנו לא

596
00:27:10,440 --> 00:27:13,210
רוצה להגיע בסופו ל
מצב עבור מחרוזות גדולות

597
00:27:13,210 --> 00:27:14,960
שאנחנו מבקשים
מערכת ההפעלה שוב ושוב

598
00:27:14,960 --> 00:27:17,500
ושוב ושוב ב
רצף מהיר לזיכרון.

599
00:27:17,500 --> 00:27:20,387
אז אנחנו פשוט החלטנו, במידה מסוימת
באופן שרירותי, אבל אנחנו מקווים שסבירים,

600
00:27:20,387 --> 00:27:22,720
כי, אתה יודע מה, בוא
אנסה תקדים את המאוחר

601
00:27:22,720 --> 00:27:25,520
ורק לשמור על הכפלתו כך ש
אנו למזער את כמות פעמים

602
00:27:25,520 --> 00:27:29,010
אנחנו צריכים לקרוא malloc או
להקצות מחדש, אבל פסק דין כולל

603
00:27:29,010 --> 00:27:31,820
קורא בהעדר הידיעה
מה משתמשים ייתכן שירצו להקליד.

604
00:27:31,820 --> 00:27:33,600
שני הדרכים יכולות להיות אפשר להתווכח.

605
00:27:33,600 --> 00:27:35,430
ניתן לטעון טוב.

606
00:27:35,430 --> 00:27:39,240
>> אז בואו נסתכל על כמה
תופעות לוואי אחרות של זיכרון,

607
00:27:39,240 --> 00:27:41,610
דברים שיכולים להשתבש
וכלים שאתה יכול

608
00:27:41,610 --> 00:27:43,880
להשתמש בו כדי לתפוס מיני הטעויות האלה.

609
00:27:43,880 --> 00:27:47,800
למרות שמסתבר שכולכם,
check50 לא סיפר לך כמה שיותר,

610
00:27:47,800 --> 00:27:50,050
כבר כתב עגלה
קוד מאז שבוע אחד,

611
00:27:50,050 --> 00:27:53,630
גם אם כל בדיקות check50 הן
עבר, וגם אם אתה וTF שלך

612
00:27:53,630 --> 00:27:56,010
הם סופר בטוחים ש
הקוד שלך עובד כמתוכנן.

613
00:27:56,010 --> 00:27:59,190
או את הקוד שלך כבר מרכבה
פגום בכל מה שמכם,

614
00:27:59,190 --> 00:28:02,540
בשימוש בספריית CS50,
כבר דולף זיכרון.

615
00:28:02,540 --> 00:28:06,040
אתה כבר שואל את מערכת ההפעלה
לזיכרון ברוב התוכניות

616
00:28:06,040 --> 00:28:08,850
שכתבת, אבל יש לך
אף פעם לא באמת נתן אותו בחזרה.

617
00:28:08,850 --> 00:28:12,110
שנקרא GetString
וGetInt וGetFloat,

618
00:28:12,110 --> 00:28:15,270
אבל עם GetString, יש לך
מעולם לא קרא unGetString או תנו

619
00:28:15,270 --> 00:28:19,890
מחרוזת חזרה או משהו דומה, אבל שראינו
שGetString עושה להקצות זיכרון

620
00:28:19,890 --> 00:28:22,810
בדרך של malloc או זה
להקצות מחדש פונקציה, שהוא רק

621
00:28:22,810 --> 00:28:25,670
דומה מאוד ברוח,
ובכל זאת, אנחנו כבר

622
00:28:25,670 --> 00:28:28,629
שואל את מערכת ההפעלה ל
זיכרון וזיכרון שוב ושוב

623
00:28:28,629 --> 00:28:29,670
אבל אף פעם לא נותן אותו בחזרה.

624
00:28:29,670 --> 00:28:33,550
>> עכשיו, במאמר המוסגר, מתברר ש
כאשר תכנית בכל הזיכרון נסגר,

625
00:28:33,550 --> 00:28:34,870
הוא שוחרר באופן אוטומטי.

626
00:28:34,870 --> 00:28:36,150
אז זה לא היה עסקה ענק.

627
00:28:36,150 --> 00:28:38,590
זה לא הולך לשבור
IDE או דברים להאט,

628
00:28:38,590 --> 00:28:40,670
אבל כאשר תוכניות לעשות
בדרך כלל דליפת זיכרון

629
00:28:40,670 --> 00:28:42,170
והם פועלים במשך זמן רב.

630
00:28:42,170 --> 00:28:45,640
אם אי פעם ראו קצת הטיפש
חוף כדור ב- Mac OS או שעון החול

631
00:28:45,640 --> 00:28:51,160
ב- Windows שבו זה סוג של
האטה או חושבים או חשיבה

632
00:28:51,160 --> 00:28:53,770
או פשוט באמת מתחיל
כדי להאט עד כדי זחילה,

633
00:28:53,770 --> 00:28:56,960
זה מאוד אולי יכול להיות
התוצאה של דליפת זיכרון.

634
00:28:56,960 --> 00:28:59,970
המתכנתים שכתבו
התוכנה אתה משתמש ב

635
00:28:59,970 --> 00:29:03,570
לשאול את מערכת ההפעלה לזיכרון
כל כמה דקות, בכל שעה.

636
00:29:03,570 --> 00:29:05,570
אבל אם אתה מפעיל
תוכנה, גם אם זה

637
00:29:05,570 --> 00:29:08,680
ממוזער במחשב שלך
במשך שעות או ימים ארוכים,

638
00:29:08,680 --> 00:29:11,980
ייתכן שאתה מבקש יותר ויותר
זיכרון ולא משתמש בו בפועל

639
00:29:11,980 --> 00:29:15,180
וכך הקוד שלך יכול להיות, או
תוכניות עשויות להיות דולפות זיכרון,

640
00:29:15,180 --> 00:29:18,350
ואם אתה מתחיל לדלוף זיכרון,
יש פחות זיכרון לתוכניות אחרות,

641
00:29:18,350 --> 00:29:21,220
וההשפעה היא ל
להאט את הכל.

642
00:29:21,220 --> 00:29:23,600
>> עכשיו, זה הוא ללא ספק אחד מ
התוכניות הזוועתית ביותר

643
00:29:23,600 --> 00:29:26,350
יהיה לך הזדמנויות
לרוץ בCS50 ככל

644
00:29:26,350 --> 00:29:31,650
כפלט שלה הוא אפילו יותר מאשר אזוטרי
הצלצול של או להפוך של או כל פקודה

645
00:29:31,650 --> 00:29:35,930
תוכניות קו שבצענו בעבר, אבל
לשמחתי, משובץ בתפוקה שלה

646
00:29:35,930 --> 00:29:39,810
הוא כמה טיפים מועילים שסופר
יהיה שימושי גם עבור PSet ארבע

647
00:29:39,810 --> 00:29:41,510
או בהחלט PSet חמש.

648
00:29:41,510 --> 00:29:44,250
אז valgrind הוא כלי
שניתן להשתמש בי להסתכל

649
00:29:44,250 --> 00:29:46,930
לדליפות זיכרון בתכנית שלך.

650
00:29:46,930 --> 00:29:48,570
זה פשוט יחסית להפעלה.

651
00:29:48,570 --> 00:29:51,420
אתה מפעיל valgrind ולאחר מכן, אפילו
למרות שזה קצת מפורט,

652
00:29:51,420 --> 00:29:54,440
בדיקת דליפת מקף מקף
שווה מלא, ולאחר מכן נקודה

653
00:29:54,440 --> 00:29:56,320
סלאש השם של התכנית שלך.

654
00:29:56,320 --> 00:30:00,010
אז valgrind אז יהיה להפעיל את התכנית שלך
וממש בסוף של התכנית שלך

655
00:30:00,010 --> 00:30:02,240
פועל לפני שהוא נסגר ו
נותן לך עוד שורת,

656
00:30:02,240 --> 00:30:04,980
זה הולך לנתחך
תכנית בזמן שהוא כבר פועל

657
00:30:04,980 --> 00:30:07,740
ולספר לך שאתה לדלוף
כל זיכרון ויותר טוב,

658
00:30:07,740 --> 00:30:10,610
לא שאתה נוגע בזיכרון ש
לא שייך לך?

659
00:30:10,610 --> 00:30:13,700
זה לא יכול לתפוס את הכל, אבל זה
די טוב ברוב הדברים המושכים.

660
00:30:13,700 --> 00:30:19,700
>> אז הנה דוגמא של בעל הטווח שלי
תכנית זו, שיש valgrind ריצה,

661
00:30:19,700 --> 00:30:21,470
על תכנית בשם
זיכרון, ואני הולך

662
00:30:21,470 --> 00:30:24,730
כדי להדגיש את הקווים ש
סופו של דבר שמעניין אותנו.

663
00:30:24,730 --> 00:30:27,690
אז יש אפילו יותר הסחות דעת
כי אני כבר נמחק מהשקופיות.

664
00:30:27,690 --> 00:30:30,930
אבל בואו רק לראות מה זה
תכנית היא מסוגלת לספר לנו.

665
00:30:30,930 --> 00:30:34,800
זה מסוגל לספר לנו דברים
כמו כתיבה לא חוקית של גודל 4.

666
00:30:34,800 --> 00:30:38,020
במילים אחרות, אם אתה נוגע בזיכרון,
במיוחד 4 בתים של זיכרון

667
00:30:38,020 --> 00:30:40,350
שאתה לא צריך,
valgrind יכול להגיד לך ש.

668
00:30:40,350 --> 00:30:41,660
כתיבה לא חוקית של גודל 4.

669
00:30:41,660 --> 00:30:43,640
אתה נגעת ארבעה בתים
שאתה לא צריך.

670
00:30:43,640 --> 00:30:44,840
איפה עשית את זה?

671
00:30:44,840 --> 00:30:45,900
זה היופי.

672
00:30:45,900 --> 00:30:50,000
קו ג נקודת זיכרון 21 שבו אתה
דפוק ולכן זה מועיל.

673
00:30:50,000 --> 00:30:53,410
בדומה GDB, זה יכול לעזור
להצביע לך בשגיאה בפועל.

674
00:30:53,410 --> 00:30:57,170
>> עכשיו, זה אחד זה קצת יותר
מפורט, אם לא מבלבל.

675
00:30:57,170 --> 00:31:01,307
40 בתים בלוקים 1 בהחלט
איבד ברשומת הפסד 1 מתוך 1.

676
00:31:01,307 --> 00:31:02,140
מה הכוונה?

677
00:31:02,140 --> 00:31:05,920
ובכן, זה רק אומר שאתה ביקשת
40 בתים ואתה אף פעם לא נתן לו בחזרה.

678
00:31:05,920 --> 00:31:08,930
אתה נקרא malloc או שאתה נקרא
GetString ומערכת ההפעלה

679
00:31:08,930 --> 00:31:12,450
נתתי לך 40 בתים, אבל אתה אף פעם לא
שוחרר או ישוחרר כי זיכרון,

680
00:31:12,450 --> 00:31:15,400
וכדי להיות הוגן, אנחנו אף פעם לא להראות
לך איך להחזיר זיכרון.

681
00:31:15,400 --> 00:31:17,910
מסתבר שיש סופר
פונקציה פשוטה שנקראת חופשית.

682
00:31:17,910 --> 00:31:21,170
לוקח טיעון אחד, הדבר
אתה רוצה לשחרר או להחזיר,

683
00:31:21,170 --> 00:31:23,430
אבל 40 בתים, ככל הנראה,
בתכנית זו

684
00:31:23,430 --> 00:31:27,300
אבד בקו
20 של זיכרון dot ג.

685
00:31:27,300 --> 00:31:28,650
>> אז בואו יראו את התכנית הזאת.

686
00:31:28,650 --> 00:31:31,020
זה סופר חסר תועלת.

687
00:31:31,020 --> 00:31:33,980
זה מוכיח רק
שגיאה זו בפרט.

688
00:31:33,980 --> 00:31:34,920
אז בואו נסתכל.

689
00:31:34,920 --> 00:31:39,920
הנה עיקריות ומרכזי, הודעה, שיחות
פונקציה שנקראת חוזרת F ולאחר מכן.

690
00:31:39,920 --> 00:31:41,550
אז לא כל כך מעניין.

691
00:31:41,550 --> 00:31:42,664
מה f עושה?

692
00:31:42,664 --> 00:31:44,330
שים לב שלא טרחתי עם אב טיפוס.

693
00:31:44,330 --> 00:31:46,520
אני רוצה לשמור את הקוד
מינימאלי ככל האפשר.

694
00:31:46,520 --> 00:31:49,530
אז שמתי את ו 'לעיל עיקרי ו
זה בסדר, בהחלט,

695
00:31:49,530 --> 00:31:51,500
לתוכניות קצרות כזה.

696
00:31:51,500 --> 00:31:56,910
אז f אינה חוזרת כל דבר ועושה
לא לקחת שום דבר, אבל הוא עושה את זה.

697
00:31:56,910 --> 00:31:59,620
היא מצהירה, כמו
בדוגמא בינקי,

698
00:31:59,620 --> 00:32:02,682
מצביע בשם X שקורה
כדי לאחסן את הכתובת של int.

699
00:32:02,682 --> 00:32:03,890
אז זה הצד השמאל.

700
00:32:03,890 --> 00:32:07,230
באנגלית, מה הוא
צד ימני עושה?

701
00:32:07,230 --> 00:32:09,770
כל אחד?

702
00:32:09,770 --> 00:32:13,665
מה הוא עושה את זה בשבילנו?

703
00:32:13,665 --> 00:32:14,651
כן?

704
00:32:14,651 --> 00:32:16,623
>> קהל: [לא ברור]
פעמים את הגודל של int

705
00:32:16,623 --> 00:32:19,175
אשר 10 פעמים ש[ לא ברור]

706
00:32:19,175 --> 00:32:20,800
DAVID מלאן: טוב ותן לי לסכם.

707
00:32:20,800 --> 00:32:25,480
אז להקצות מספיק מקום למספרים שלמים 10
או 10, מה הגודל של int,

708
00:32:25,480 --> 00:32:29,340
זה ארבעה בתים, כך 10 פעמים 4 הוא
40, כך שהצד ימני שיש לי

709
00:32:29,340 --> 00:32:33,930
המודגש הוא לתת לי 40 בתים ו
לאחסן את הכתובת של הבית הראשון

710
00:32:33,930 --> 00:32:34,940
לx.

711
00:32:34,940 --> 00:32:38,380
ועכשיו סוף סוף, והנה שבי
תכנית זו היא מרכבה, מה

712
00:32:38,380 --> 00:32:41,540
לא בסדר עם קו 21 המבוסס על היגיון זה?

713
00:32:41,540 --> 00:32:45,197

714
00:32:45,197 --> 00:32:46,280
מה רע בקו 21?

715
00:32:46,280 --> 00:32:46,780
כן?

716
00:32:46,780 --> 00:32:49,550
קהל: אתה לא יכול
מדד לx [לא ברור].

717
00:32:49,550 --> 00:32:50,300
DAVID מלאן: כן.

718
00:32:50,300 --> 00:32:52,270
אני לא צריך למדד x כמו ש.

719
00:32:52,270 --> 00:32:53,850
אז מבחינה תחבירית, זה בסדר.

720
00:32:53,850 --> 00:32:56,990
מה שיפה הוא, הרבה כמוך
יכול לטפל בשם של מערך

721
00:32:56,990 --> 00:33:01,080
כאילו זה מצביע, באופן דומה
אתה יכול לטפל מצביע כאילו זה

722
00:33:01,080 --> 00:33:06,425
מערך, ואז אני יכול מבחינה תחבירית
אומר תושבת x משהו, x הסוגר אני,

723
00:33:06,425 --> 00:33:07,800
אבל 10 הוא בעייתיים.

724
00:33:07,800 --> 00:33:09,096
למה?

725
00:33:09,096 --> 00:33:10,910
>> קהל: כי זה לא בפנים.

726
00:33:10,910 --> 00:33:12,390
>> DAVID מלאן: זה לא
בתוך נתח זה של זיכרון.

727
00:33:12,390 --> 00:33:15,306
מה הערך הגדול ביותר שאני צריך
לשים בסוגריים מרובעים האלה?

728
00:33:15,306 --> 00:33:16,870
9, 0 עד 9.

729
00:33:16,870 --> 00:33:18,160
בגלל אפס האינדקס.

730
00:33:18,160 --> 00:33:20,190
אז 0 עד 9 יהיו בסדר.

731
00:33:20,190 --> 00:33:23,960
התושבת 10 היא לא טובה ו
אבל, למרות שזוכר, בכל פעם

732
00:33:23,960 --> 00:33:27,017
נדמה לי שאנסה לעשות CS50 IDE
התרסקות על ידי הקלדת ערכים מזויפים,

733
00:33:27,017 --> 00:33:29,100
זה לא תמיד משתף פעולה,
ואכן, לעתים קרובות אתה

734
00:33:29,100 --> 00:33:31,460
מזל רק בגלל ש
מערכת הפעלה לא

735
00:33:31,460 --> 00:33:35,467
שם לב שאתה אי פעם כל כך מעט
עובר כמה נתח של זיכרון,

736
00:33:35,467 --> 00:33:38,300
כי אתה נשאר בתוך טכני
הקטע שלך, אבל עוד על כך

737
00:33:38,300 --> 00:33:40,940
בכיתת מערכות הפעלה,
וכך משהו כזה

738
00:33:40,940 --> 00:33:43,000
מאוד בקלות יכול ללכת מבלי שיבחינו.

739
00:33:43,000 --> 00:33:48,120
התכנית שלך אף פעם לא הולכת להתרסק
באופן עקבי, אבל אולי פעם בכמה זמן.

740
00:33:48,120 --> 00:33:50,610
>> ואז בואו ננסה valgrind
על זה, והנה

741
00:33:50,610 --> 00:33:52,870
שבו יהיו לנו המום
על ידי הפלט לרגע.

742
00:33:52,870 --> 00:34:00,810
אז להפוך את בדיקת דליפת valgrind זיכרון
שווה זיכרון לוכסן נקודה מלא.

743
00:34:00,810 --> 00:34:03,040
והנה הסיבה אני מבטיח
זה היה להציף.

744
00:34:03,040 --> 00:34:05,700
הנה מה שvalgrind, הנה מה ש
מתכנת, קלטת לפני כמה שנים

745
00:34:05,700 --> 00:34:08,469
החליט שזה יהיה רעיון טוב
לפלט להיראות.

746
00:34:08,469 --> 00:34:09,750
אז בואו הגיוני לכך.

747
00:34:09,750 --> 00:34:13,120
אז כל הדרך בצד השמאל-היד
צד בלי שום סיבה טובה

748
00:34:13,120 --> 00:34:16,620
הוא מזהה התהליך של התכנית
אנחנו פשוט לרוץ, מזהה הייחודיים

749
00:34:16,620 --> 00:34:18,030
לתכנית אנחנו רק רצנו.

750
00:34:18,030 --> 00:34:19,738
אנו נמחקו שמ
השקופיות, אבל יש

751
00:34:19,738 --> 00:34:22,190
קצת מידע שימושי כאן.

752
00:34:22,190 --> 00:34:24,684
>> בואו לגלול עד מאוד עליון.

753
00:34:24,684 --> 00:34:25,600
הנה שם התחלנו.

754
00:34:25,600 --> 00:34:27,040
אז זה לא כל כך הרבה תפוקה.

755
00:34:27,040 --> 00:34:30,429
הנה כי כתיבה לא חוקית
גודל 4 על קו 21.

756
00:34:30,429 --> 00:34:31,760
ובכן, מה היה קו 21?

757
00:34:31,760 --> 00:34:34,500
קו 21 היה בדיוק
זה וזה הגיוני

758
00:34:34,500 --> 00:34:37,290
כי אני באופן תקף
כתיבת 4 בתים כי אני

759
00:34:37,290 --> 00:34:40,389
מנסה לשים שלם זה,
שיכול להיות כל דבר,

760
00:34:40,389 --> 00:34:42,370
זה קורה רק כדי להיות
אפס, אבל אני מנסה

761
00:34:42,370 --> 00:34:44,940
לשים אותו במיקום
שלא שייך לי.

762
00:34:44,940 --> 00:34:50,900
יתר על כן, כאן למטה, 40 בתים באחד
בלוקים בהחלט איבדו ברשומת 1.

763
00:34:50,900 --> 00:34:56,500
זאת משום שכאשר אני קורא malloc
כאן, אני לא באמת לשחרר את הזיכרון.

764
00:34:56,500 --> 00:34:58,140
>> אז איך אנחנו יכולים לתקן את זה?

765
00:34:58,140 --> 00:35:02,970
תן לי ללכת קדימה ולהיות קצת יותר בטוח
ולעשות 9 וייתן לי כאן x החופשי.

766
00:35:02,970 --> 00:35:04,820
זוהי הפונקציה החדשה להיום.

767
00:35:04,820 --> 00:35:11,520
אם אני עכשיו שידור חוזר לעשות קו נטוי נקודת זיכרון,
בואו לרוץ valgrind על זה שוב,

768
00:35:11,520 --> 00:35:14,990
להגדיל את החלון שלי ולחץ על Enter.

769
00:35:14,990 --> 00:35:16,900
עכשיו, זה טוב.

770
00:35:16,900 --> 00:35:19,590
הם קוברים את חדשות טובות
בכל פלט זה.

771
00:35:19,590 --> 00:35:20,810
כל הערמה שהייתה חופשיות.

772
00:35:20,810 --> 00:35:23,604
אנחנו נחזור למה שהערימה
הוא, אבל אין דליפות אפשריות.

773
00:35:23,604 --> 00:35:25,520
אז זה סתם עוד
כלי לארגז הכלים שלך

774
00:35:25,520 --> 00:35:30,220
שבה אתה יכול להתחיל ל
למצוא עכשיו טעויות כמו ש.

775
00:35:30,220 --> 00:35:34,532
>> אבל בואו נראה מה
יותר יכול להשתבש כאן.

776
00:35:34,532 --> 00:35:38,890
בואו מעבר החברה ל
למעשה פתרון בעיה.

777
00:35:38,890 --> 00:35:42,440
במאמר מוסגר, אם זה יהיה להקל
קצת בלבול או מתח,

778
00:35:42,440 --> 00:35:43,430
זה עכשיו מצחיק.

779
00:35:43,430 --> 00:35:46,400

780
00:35:46,400 --> 00:35:46,900
כן.

781
00:35:46,900 --> 00:35:49,040
זה די טוב.

782
00:35:49,040 --> 00:35:50,890
בגלל מצביעים הם
כתובות וכתובות

783
00:35:50,890 --> 00:35:53,098
הם בדרך כלל על ידי אמנה
נכתב בהקסדצימלי.

784
00:35:53,098 --> 00:35:54,650
חה, חה, זה מצחיק עכשיו.

785
00:35:54,650 --> 00:35:58,390
בכל אופן, אז בואו עכשיו
למעשה לפתור בעיה.

786
00:35:58,390 --> 00:36:00,840
זה היה סופר,
סופר ברמה נמוכה עד כה,

787
00:36:00,840 --> 00:36:03,950
ואנחנו באמת יכולים לעשות שימושיים
דברים עם פרטים ברמה הנמוכה אלה.

788
00:36:03,950 --> 00:36:06,710
>> אז הצגנו כמה שבועות
לפני הרעיון של מערך.

789
00:36:06,710 --> 00:36:09,177
מערך היה נחמד, כי
קשה לנקות את הקוד שלנו

790
00:36:09,177 --> 00:36:11,760
כי אם אנחנו רוצים לכתוב
תכנית עם תלמידים מרובים

791
00:36:11,760 --> 00:36:15,270
או שמות ובתים רבים ו
מעונות ומכללות וכל זה,

792
00:36:15,270 --> 00:36:19,430
אנו יכולים לאחסן את כל מה יותר
נקי בתוך מערך.

793
00:36:19,430 --> 00:36:23,039
אבל להציע חסרון אחד
של מערך עד כה.

794
00:36:23,039 --> 00:36:26,080
גם אם אתה כבר לא סבלת את זה בעצמך
בתכנית, רק באופן אינסטינקטיבי,

795
00:36:26,080 --> 00:36:30,870
מה הוא דבר רע
על מערך, אולי?

796
00:36:30,870 --> 00:36:32,337
אני שומע כמה מלמולים.

797
00:36:32,337 --> 00:36:34,170
קהל: זה קשה
כדי לשנות את הגודל.

798
00:36:34,170 --> 00:36:36,128
DAVID מלאן: זה קשה
כדי לשנות את הגודל.

799
00:36:36,128 --> 00:36:38,660
אתה לא יכול לשנות את הגודל
של מערך, בעובדה, כשלעצמה

800
00:36:38,660 --> 00:36:43,040
בג אתה יכול להקצות מערך אחר,
להעביר הכול מישן

801
00:36:43,040 --> 00:36:45,380
לחדש, ועכשיו
יש לי כמה שטח נוסף,

802
00:36:45,380 --> 00:36:47,469
אבל זה לא כמו ש
שפה כמו Java או Python

803
00:36:47,469 --> 00:36:49,760
או כל מספר אחר
שפות שבי כמה מכם

804
00:36:49,760 --> 00:36:52,070
יכול להיות מוכר שבו אתה
רק יכול לשמור על הוספת דברים

805
00:36:52,070 --> 00:36:53,930
זרא לסוף המערך.

806
00:36:53,930 --> 00:36:57,880
כאשר יש לך מערך של
גודל 6, כי הוא בגודלה,

807
00:36:57,880 --> 00:37:01,970
וכל כך הרבה כמו הרעיון קודם לכן
יש מאגר בגודל מסוים,

808
00:37:01,970 --> 00:37:05,940
אתה צריך לנחש מחוץ לשער
מה גודל אתה רוצה שזה יהיה?

809
00:37:05,940 --> 00:37:07,880
אם אתה מניח שגדול מדי,
אתה מבזבז את החלל.

810
00:37:07,880 --> 00:37:10,950
אם אתה מניח קטן מדי, אתה
לא ניתן לאחסן נתונים ש, לפחות

811
00:37:10,950 --> 00:37:12,940
ללא עבודה הרבה יותר.

812
00:37:12,940 --> 00:37:18,180
>> אז היום, הודות למצביעים, אנחנו יכולים
להתחיל תופר יחד מותאם אישית שלנו

813
00:37:18,180 --> 00:37:20,989
מבני נתונים, וב
למעשה, כאן הוא משהו

814
00:37:20,989 --> 00:37:23,030
זה נראה קצת יותר
נסתר במבט ראשון,

815
00:37:23,030 --> 00:37:26,440
אבל זה מה שאנחנו קוראים מקושרים
רשימה, ואת שמה סוג של מסכם

816
00:37:26,440 --> 00:37:26,940
את זה.

817
00:37:26,940 --> 00:37:29,550
זה רשימה של מספרים, או ב
מקרה זה, רשימה של מספרים,

818
00:37:29,550 --> 00:37:33,480
אבל זה יכול להיות רשימה של כל דבר, אבל
זה קשור יחד בדרך של חיצים,

819
00:37:33,480 --> 00:37:36,380
ופשוט לקחת את ניחוש
עם מה טכניקה

820
00:37:36,380 --> 00:37:38,310
אנחנו הולכים להיות מסוגלים
לתפור,

821
00:37:38,310 --> 00:37:42,540
קצת כמו פופקורן עם חוט,
קשור מלבנים רשימות כאן?

822
00:37:42,540 --> 00:37:43,936
המספרים שלו?

823
00:37:43,936 --> 00:37:45,560
מהי תכונת השפה הבסיסית?

824
00:37:45,560 --> 00:37:46,350
>> קהל: מצביע.

825
00:37:46,350 --> 00:37:47,308
>> DAVID מלאן: מצביע.

826
00:37:47,308 --> 00:37:51,700
אז כל אחד מהחיצים האלה מייצג כאן
מצביע או סתם כתובת.

827
00:37:51,700 --> 00:37:54,590
אז במילים אחרות, אם אני רוצה
כדי לאחסן רשימה של מספרים,

828
00:37:54,590 --> 00:37:59,040
אני לא יכול פשוט לאחסן אותו אם אני רוצה
את היכולת לגדול ולכווץ

829
00:37:59,040 --> 00:38:00,990
מבנה הנתונים שלי במערך.

830
00:38:00,990 --> 00:38:03,000
אז אני צריך קצת
יותר תחכום,

831
00:38:03,000 --> 00:38:05,720
אבל שמתי לב שזה
תמונת סוג של עולה

832
00:38:05,720 --> 00:38:08,650
כי אם אתה רק צריך אשכולות קטנים
חיבור הכל ביחד,

833
00:38:08,650 --> 00:38:13,100
כנראה לא כל כך קשה כדי להפוך את החלל
בין שני מלבנים אלה

834
00:38:13,100 --> 00:38:16,750
או שתיים של בלוטות אלה, כפי שאנו נתחיל
קורא להם, להכניס לצומת חדשה,

835
00:38:16,750 --> 00:38:19,547
ולאחר מכן עם כמה חוט חדש, רק
תעלה שלושה צמתים יחד,

836
00:38:19,547 --> 00:38:22,880
ראשון, האחרון, והאחד
כי אתה פשוט מוכנס לתוך האמצע.

837
00:38:22,880 --> 00:38:26,000
>> ואכן רשימה מקושרת,
בניגוד למערך, הוא דינמי.

838
00:38:26,000 --> 00:38:27,840
זה יכול לגדול והוא יכול
לכווץ ואתה לא

839
00:38:27,840 --> 00:38:32,434
צריך לדעת או אכפת מראש איך
הרבה נתונים שאתה הולך להיות אחסון,

840
00:38:32,434 --> 00:38:35,600
אבל מסתבר שיש לנו להיות קצת
זהיר לגבי איך ליישם את זה.

841
00:38:35,600 --> 00:38:39,070
אז בואו הראשון של לחשוב איך אנחנו מיישמים
אחד מהמלבנים הקטנים האלה.

842
00:38:39,070 --> 00:38:40,690
זה קל ליישם int.

843
00:38:40,690 --> 00:38:44,000
אתה פשוט אומר n int ולאחר מכן
אתה מקבל 4 בתים עבור int,

844
00:38:44,000 --> 00:38:49,089
אבל איך אני מקבל int, קורא לזה n,
ולאחר מכן מצביע, בואו נקראים לזה הבא.

845
00:38:49,089 --> 00:38:50,880
אנו יכולים לקרוא לאלה
דברים כל דבר שאנחנו רוצים

846
00:38:50,880 --> 00:38:53,590
אבל אני צריך מבנה נתונים מותאמים אישית.

847
00:38:53,590 --> 00:38:54,257
כן?

848
00:38:54,257 --> 00:38:57,020
>> קהל: אמפרסנד [לא ברור].

849
00:38:57,020 --> 00:39:00,940
>> DAVID מלאן: אז אמפרסנד נשתמש ל
לקבל את הכתובת של צומת פוטנציאלית.

850
00:39:00,940 --> 00:39:02,740
אבל אנחנו צריכים עוד
תכונה של C כדי

851
00:39:02,740 --> 00:39:06,700
לתת לי את היכולת ליצור
מלבן מנהג זה, מנהג זה

852
00:39:06,700 --> 00:39:08,919
משתנה אם תרצה, בזיכרון.

853
00:39:08,919 --> 00:39:09,710
קהל: struct.

854
00:39:09,710 --> 00:39:10,626
DAVID מלאן: struct.

855
00:39:10,626 --> 00:39:14,310
נזכיר משבוע שעבר, הצגנו
struct, מילות מפתח פשוטה יחסית זו

856
00:39:14,310 --> 00:39:16,254
המאפשר לנו לעשות דברים כאלה.

857
00:39:16,254 --> 00:39:18,420
C לא הגיע עם נתונים
מבנה נקרא תלמיד.

858
00:39:18,420 --> 00:39:22,190
זה בא עם int ולצוף וchar ו
כזה, אבל זה לא בא עם תלמיד,

859
00:39:22,190 --> 00:39:26,750
אבל אנחנו יכולים ליצור סוג נתוני תלמידים,
מבנה תלמיד, עם תחביר זה

860
00:39:26,750 --> 00:39:27,250
כאן.

861
00:39:27,250 --> 00:39:28,350
ואתה רואה את זה שוב ושוב.

862
00:39:28,350 --> 00:39:30,426
אז אל תדאגו
לשנן את מילות המפתח,

863
00:39:30,426 --> 00:39:33,300
אבל מילת המפתח שחשוב היא
רק העובדה שאנחנו אמרו struct

864
00:39:33,300 --> 00:39:37,590
ואז קראתי לו תלמיד ובתוך
של התלמיד היה שם ובית

865
00:39:37,590 --> 00:39:39,390
או במעונות או משהו דומה.

866
00:39:39,390 --> 00:39:41,980
>> ואז עכשיו היום, בואו להציע את זה.

867
00:39:41,980 --> 00:39:45,240
אני הוספתי כמה מילות, אבל אם אני רוצה
ליישם מלבן זה זה

868
00:39:45,240 --> 00:39:48,440
יש שני int ו
מצביע, אתה יודע מה, אני

869
00:39:48,440 --> 00:39:51,540
הולך להכריז struct נקרא צומת.

870
00:39:51,540 --> 00:39:55,630
אני גם, בתוכו, הולך להגיד
שצומת, מלבן זה, יש int

871
00:39:55,630 --> 00:39:59,730
ואנחנו קוראים לזה n ו
יש לו המצביע הבא.

872
00:39:59,730 --> 00:40:02,540
וזה קצת מפורט,
אבל אם אתה חושב על זה,

873
00:40:02,540 --> 00:40:07,300
החיצים שהיו בתמונה
רגע לפניהם של איזה סוג נתונים?

874
00:40:07,300 --> 00:40:12,330
כאשר כל אחת מהחצים אלה מצביע
איזה סוג של מבנה נתונים?

875
00:40:12,330 --> 00:40:14,332
זה לא מצביע רק לint כשלעצמה.

876
00:40:14,332 --> 00:40:16,165
זה מצביע על
דבר מלבני שלם

877
00:40:16,165 --> 00:40:18,720
וכי דבר מלבני,
אמרנו, נקרא צומת.

878
00:40:18,720 --> 00:40:21,720
וכך אנו סוג של יש ל
באופן רקורסיבי להגדיר את זה כל כך

879
00:40:21,720 --> 00:40:26,270
שצומת, נאמר,
יכיל int נקרא n

880
00:40:26,270 --> 00:40:31,070
ומצביע בשם הבא ו
סוג של מבנה נתונים ש

881
00:40:31,070 --> 00:40:35,770
שנקודות המצביע היא כנראה
הולך להיות צומת struct.

882
00:40:35,770 --> 00:40:41,550
>> אז זה מעצבן מפורט
ורק כדי להיות קפדן,

883
00:40:41,550 --> 00:40:44,100
הסיבה למה אנחנו לא יכולים
רק אומר את זה, אשר בכנות

884
00:40:44,100 --> 00:40:46,860
נראה קריאים הרבה יותר,
משום זוכר שC לקרוא

885
00:40:46,860 --> 00:40:48,710
דברים מלמעלה למטה, משמאל לימין.

886
00:40:48,710 --> 00:40:54,120
זה לא עד שנקבל את פסיק
שצומת מילות מפתח קיימת למעשה.

887
00:40:54,120 --> 00:40:57,980
אז אם אנחנו רוצים להיות זה סוג של
התייחסות מחזורית הפנימי של נתונים

888
00:40:57,980 --> 00:41:02,120
מבנה, שאנחנו צריכים לעשות זה, שבו
אנו אומרים צומת struct בראש, ש

889
00:41:02,120 --> 00:41:06,770
נותן לנו דרך ארוכה יותר לתאר את זה
דבר, אז אנחנו אומרים בתוך צומת struct,

890
00:41:06,770 --> 00:41:09,560
ולאחר מכן בשורה האחרון
אנחנו אומרים, בסדר, C, דרך אגב,

891
00:41:09,560 --> 00:41:12,060
פשוט קוראים כל ארור הזה
דבר צומת ולעצור

892
00:41:12,060 --> 00:41:14,360
באמצעות מילות מפתח struct לגמרי.

893
00:41:14,360 --> 00:41:18,030
אז זה פשוט סוג של תחבירי
טריק שסופו של דבר מאפשר לנו ליצור

894
00:41:18,030 --> 00:41:21,370
משהו שנראה בדיוק כמו זה.

895
00:41:21,370 --> 00:41:25,010
>> אז אם נניח עכשיו שאנחנו יכולים
ליישם את הדבר הזה ב- C,

896
00:41:25,010 --> 00:41:28,040
איך אנחנו למעשה
להתחיל חוצים זה?

897
00:41:28,040 --> 00:41:32,360
ובכן, למעשה, כל מה שאנחנו צריכים לעשות הוא
לחזר משמאל לימין ורק

898
00:41:32,360 --> 00:41:35,960
סוג של להכניס צמתים או למחוק צמתים
או לחפש את דברים בכל מקום שאנחנו רוצים,

899
00:41:35,960 --> 00:41:39,560
אבל כדי לעשות את זה, בואו נלך קדימה ולעשות
דברים קצת יותר אמיתי, כי זה

900
00:41:39,560 --> 00:41:42,560
כבר ברמה נמוכה סופר עד כה.

901
00:41:42,560 --> 00:41:45,700
האם מישהו רוצה ממש להיות ראשון?

902
00:41:45,700 --> 00:41:46,200
אוקיי.

903
00:41:46,200 --> 00:41:47,092
בואו למעלה.

904
00:41:47,092 --> 00:41:47,800
מה השם שלך?

905
00:41:47,800 --> 00:41:48,499
>> דוד: דוד.

906
00:41:48,499 --> 00:41:49,290
DAVID מלאן: דוד.

907
00:41:49,290 --> 00:41:49,998
נחמד לפגוש אותך.

908
00:41:49,998 --> 00:41:50,960
אני גם.

909
00:41:50,960 --> 00:41:52,450
בסדר.

910
00:41:52,450 --> 00:41:53,990
ואנחנו צריכים מספר 9.

911
00:41:53,990 --> 00:41:55,240
לא טוב כמו ראשון, אולי.

912
00:41:55,240 --> 00:41:56,430
אישור, מספר 9.

913
00:41:56,430 --> 00:41:59,667
מספר 17, בבקשה.

914
00:41:59,667 --> 00:42:01,000
תן לי לחזור קצת רחוק יותר.

915
00:42:01,000 --> 00:42:03,980
מספר 22, בבקשה, ו
מה דעתך על עוד אחורה

916
00:42:03,980 --> 00:42:06,344
אם אני יכול לראות את כל ידיים
עם כל האור או לא.

917
00:42:06,344 --> 00:42:08,010
מישהו שהתנדב שם.

918
00:42:08,010 --> 00:42:08,968
האם אתה רוצה לבוא?

919
00:42:08,968 --> 00:42:10,450
הזרוע שלך בכוח עולה.

920
00:42:10,450 --> 00:42:12,340
אישור, 17.

921
00:42:12,340 --> 00:42:13,690
22.

922
00:42:13,690 --> 00:42:15,120
26 יורדים.

923
00:42:15,120 --> 00:42:18,450
האם מישהו אחר רוצה
forcefully-- קדימה עד.

924
00:42:18,450 --> 00:42:21,030
התנדבות בפועל.

925
00:42:21,030 --> 00:42:23,330
>> אז מהר מאוד, אם
אתם יכולים לארגן

926
00:42:23,330 --> 00:42:26,550
את עצמכם בדיוק כמו
בלוטות על המסך.

927
00:42:26,550 --> 00:42:27,510
תודה.

928
00:42:27,510 --> 00:42:29,234
ואתה תהיה 26.

929
00:42:29,234 --> 00:42:30,650
כל ההקדמות הנכונות ומהירה.

930
00:42:30,650 --> 00:42:32,139
אז אני דוד ואתה גם?

931
00:42:32,139 --> 00:42:32,680
דוד: דוד.

932
00:42:32,680 --> 00:42:33,721
DAVID מלאן: ואתה?

933
00:42:33,721 --> 00:42:34,229
ג'ייק: ג'ייק.

934
00:42:34,229 --> 00:42:34,729
לתבוע: סו.

935
00:42:34,729 --> 00:42:35,229
אלכס: אלכס.

936
00:42:35,229 --> 00:42:36,475
רפאל: רפאל.

937
00:42:36,475 --> 00:42:37,100
טיילור: טיילור.

938
00:42:37,100 --> 00:42:37,466
DAVID מלאן: טיילור.

939
00:42:37,466 --> 00:42:37,590
מצוין.

940
00:42:37,590 --> 00:42:39,810
אז אלה הם המתנדבים שלנו
להיום וקדימה

941
00:42:39,810 --> 00:42:43,090
ולהעביר קצת ככה,
ורק קדימה ולשמור

942
00:42:43,090 --> 00:42:47,024
מחזיק המספרים שלך כמו שאתה או שלך
סימן ראשון ושימוש ביד שמאל,

943
00:42:47,024 --> 00:42:48,940
קדימה, רק ליישם
חיצים אלה, רק

944
00:42:48,940 --> 00:42:51,360
כך שיד השמאל שלך היא, פשוטו כמשמעו,
מצביע על מה שאתה צריך להצביע

945
00:42:51,360 --> 00:42:54,610
ב, ולתת לעצמך כמה חדר כך ש
אנחנו יכולים לראות באופן חזותי את הידיים שלך באמת

946
00:42:54,610 --> 00:42:58,120
הצבעה, ואתה יכול פשוט להצביע
סוג של בקרקע הוא בסדר.

947
00:42:58,120 --> 00:43:03,040
>> אז הנה יש לנו רשימה מקושרת של אחד,
שתיים, שלוש, ארבעה, חמישה צמתים בתחילה,

948
00:43:03,040 --> 00:43:05,860
ושים לב שיש לנו זה מיוחד
מצביע בתחילת מי

949
00:43:05,860 --> 00:43:09,770
מפתח, כי אנחנו צריכים לעקוב אחר
של כל רשימת האורך איכשהו.

950
00:43:09,770 --> 00:43:13,590
החבר'ה האלה, למרות שהם עזבו
לימין, גב אל גב בזיכרון,

951
00:43:13,590 --> 00:43:15,950
הם באמת יכולים להיות בכל מקום
בזיכרון של המחשב.

952
00:43:15,950 --> 00:43:18,240
אז החבר'ה האלה יכולים להיות
עומד בכל מקום על הבמה

953
00:43:18,240 --> 00:43:20,960
וזה בסדר, כל עוד הם
למעשה מצביע על אחד אחרת,

954
00:43:20,960 --> 00:43:22,770
אבל כדי לשמור על דברים
, אנחנו נקיים ופשוט

955
00:43:22,770 --> 00:43:25,728
רק למשוך אותם מהשמאל לימין כמו
זה, אבל יכול להיות שיש פערים עצומים

956
00:43:25,728 --> 00:43:26,790
בין צמתים אלה.

957
00:43:26,790 --> 00:43:30,710
>> עכשיו, אם אני רוצה להכניס למעשה חלק
ערך חדש, בואו נלך קדימה ולעשות את זה.

958
00:43:30,710 --> 00:43:33,720
יש לנו הזדמנות עכשיו
לבחור צומת אחר.

959
00:43:33,720 --> 00:43:39,820
אומר בואו נתחיל עם mallocing 55.

960
00:43:39,820 --> 00:43:41,320
האם מישהו אכפת לי להיות malloc?

961
00:43:41,320 --> 00:43:42,280
אישור, בוא למעלה.

962
00:43:42,280 --> 00:43:42,992
מה השם שלך?

963
00:43:42,992 --> 00:43:43,700
קשת: קשת בענן.

964
00:43:43,700 --> 00:43:44,050
DAVID מלאן: קשת בענן?

965
00:43:44,050 --> 00:43:44,810
בסדר.

966
00:43:44,810 --> 00:43:46,600
Malloc קשת.

967
00:43:46,600 --> 00:43:47,450
בואו למעלה.

968
00:43:47,450 --> 00:43:51,610
אז עכשיו אנחנו צריכים לשאול את עצמנו
אלגוריתמי שבו אנחנו יכולים לשים 55.

969
00:43:51,610 --> 00:43:53,610
אז כולנו יודעים,
ברור, שבו היא כנראה

970
00:43:53,610 --> 00:43:55,401
שייך אם אנחנו מנסים
לשמור את זה מסודרים

971
00:43:55,401 --> 00:43:58,299
ואם אתם יכולים לקחת אחד
הצעד אחורה כדי שלא ליפול

972
00:43:58,299 --> 00:43:59,590
השלב, זה יהיה נהדר.

973
00:43:59,590 --> 00:44:01,420
אז בעצם, קשת,
להתחיל מחדש כאן איתי,

974
00:44:01,420 --> 00:44:04,200
כי אנחנו כמחשב עכשיו יכול
רק לראות משתנים אחד בכל פעם.

975
00:44:04,200 --> 00:44:05,190
אז אם זה הצומת הראשונה.

976
00:44:05,190 --> 00:44:07,160
שים לב שהוא לא צומת,
הוא פשוט מצביע,

977
00:44:07,160 --> 00:44:10,270
וזו הסיבה שהוא נמשך להיות
רק בגודל של מצביע, לא

978
00:44:10,270 --> 00:44:11,780
אחד ממלבנים מלאים אלה.

979
00:44:11,780 --> 00:44:16,650
אז אנחנו הולכים לבדוק בכל
איטרציה היא 55 פחות מ 9?

980
00:44:16,650 --> 00:44:17,150
מס '

981
00:44:17,150 --> 00:44:19,060
האם 55 פחות מ 17?

982
00:44:19,060 --> 00:44:19,720
מס '

983
00:44:19,720 --> 00:44:20,800
פחות מ 22?

984
00:44:20,800 --> 00:44:22,020
פחות מ 26?

985
00:44:22,020 --> 00:44:23,390
פחות מ 34?

986
00:44:23,390 --> 00:44:25,890
אז עכשיו, כמובן
קשת שייכת בסופו של הדבר.

987
00:44:25,890 --> 00:44:27,270
אז כדי להיות ברור, ומה ש
היה השם שלך, טיילור?

988
00:44:27,270 --> 00:44:27,895
>> טיילור: טיילור.

989
00:44:27,895 --> 00:44:32,510
DAVID מלאן: אז בין טיילור
יד שמאל והידיים של הקשת כאן,

990
00:44:32,510 --> 00:44:38,324
היד שצריכה להצביע על מה שב
כדי להכניס 55 לרשימה זו?

991
00:44:38,324 --> 00:44:39,240
מה אנחנו צריכים לעשות?

992
00:44:39,240 --> 00:44:39,700
כן?

993
00:44:39,700 --> 00:44:41,140
>> קהל: ידו של טיילור
צריך להצביע שמאל.

994
00:44:41,140 --> 00:44:41,680
>> DAVID מלאן: בדיוק.

995
00:44:41,680 --> 00:44:43,800
אז החדרת צומת
לסוף הרשימה

996
00:44:43,800 --> 00:44:47,140
הוא די פשוט, כי טיילור רק
יש לציין, במקום באדמה

997
00:44:47,140 --> 00:44:49,640
או שקוראים לזה null,
null הוא סוג של ההיעדרות

998
00:44:49,640 --> 00:44:51,640
של מצביע או מיוחד
אפס מצביע, אתה

999
00:44:51,640 --> 00:44:53,740
הולך להצביע עם השמאל שלך
יד בקשת ולאחר מכן קשת,

1000
00:44:53,740 --> 00:44:55,910
איפה כדאי השמאלי שלך
יד כנראה להצביע?

1001
00:44:55,910 --> 00:44:56,570
דאון.

1002
00:44:56,570 --> 00:45:00,140
זה לא טוב אם ידה היא סוג
של הצבעה מכאן או סוג של כל

1003
00:45:00,140 --> 00:45:00,640
באיזו דרך.

1004
00:45:00,640 --> 00:45:02,407
שייחשב
ערך זבל,

1005
00:45:02,407 --> 00:45:04,240
אבל אם היא מצביעה על
כמה ערך ידוע, אנחנו

1006
00:45:04,240 --> 00:45:07,360
קורא לזה אפס או ריק, זה בסדר
כי יש לנו טווח בזה

1007
00:45:07,360 --> 00:45:09,390
ואנחנו יודעים את הרשימה כרגע היא מלאה.

1008
00:45:09,390 --> 00:45:11,550
>> אז מה עוד
מקרה פשוט יחסית?

1009
00:45:11,550 --> 00:45:13,125
האם אנו יכולים malloc 5?

1010
00:45:13,125 --> 00:45:14,010
בואו למעלה.

1011
00:45:14,010 --> 00:45:14,782
מה השם שלך?

1012
00:45:14,782 --> 00:45:15,490
טיפאני: טיפאני.

1013
00:45:15,490 --> 00:45:16,000
DAVID מלאן: אני מצטער?

1014
00:45:16,000 --> 00:45:16,470
טיפאני: טיפאני.

1015
00:45:16,470 --> 00:45:16,880
DAVID מלאן: טיפאני.

1016
00:45:16,880 --> 00:45:17,110
בסדר.

1017
00:45:17,110 --> 00:45:19,071
טיפאני כבר malloced
עם הערך 5.

1018
00:45:19,071 --> 00:45:19,570
בואו למעלה.

1019
00:45:19,570 --> 00:45:23,820
אחד זה קל יחסית, אבל
הבה נבחן סדר פעולות החברה.

1020
00:45:23,820 --> 00:45:25,820
זה היה די קל
עם טיילור בסוף.

1021
00:45:25,820 --> 00:45:30,302
מספר 5 הוא כמובן פחות מ 9,
ולכן יש לנו דוד, יש לנו טיפאני,

1022
00:45:30,302 --> 00:45:31,260
ומה היה השם שלך?

1023
00:45:31,260 --> 00:45:31,680
>> ג'ייק: ג'ייק.

1024
00:45:31,680 --> 00:45:32,470
>> DAVID מלאן: ג'ייק.

1025
00:45:32,470 --> 00:45:34,300
טיפאני, ג'ייק, ודוד.

1026
00:45:34,300 --> 00:45:36,580
שיד צריכה להיות מעודכנת ראשונה?

1027
00:45:36,580 --> 00:45:39,260

1028
00:45:39,260 --> 00:45:40,590
מה אתה רוצה לעשות כאן?

1029
00:45:40,590 --> 00:45:45,244
יש כמה דרכים אפשריות, אבל
יש גם אחד או דרכים הלא נכונות יותר.

1030
00:45:45,244 --> 00:45:46,620
>> קהל: התחל עם השמאלי ביותר.

1031
00:45:46,620 --> 00:45:47,800
>> DAVID מלאן: התחל עם השמאלי ביותר.

1032
00:45:47,800 --> 00:45:49,008
מי השמאלי ביותר כאן אז?

1033
00:45:49,008 --> 00:45:49,700
קהל: ראשית.

1034
00:45:49,700 --> 00:45:50,366
>> DAVID מלאן: אישור.

1035
00:45:50,366 --> 00:45:53,781
אז להתחיל עם ראשון ואיפה אתה
רוצה לעדכן את ידיו של דוד להיות?

1036
00:45:53,781 --> 00:45:54,780
קהל: לקראת 5.

1037
00:45:54,780 --> 00:45:55,446
DAVID מלאן: אישור.

1038
00:45:55,446 --> 00:45:59,026
אז דוד, נקודה בחמש
או טיפאני כאן, ועכשיו?

1039
00:45:59,026 --> 00:46:01,072
>> קהל: טיפאני מצביע על 9?

1040
00:46:01,072 --> 00:46:04,030
DAVID מלאן: מושלם, למעט בינקי של
הראש פשוט סוג של נפל, נכון?

1041
00:46:04,030 --> 00:46:06,820
משום מה לא בסדר עם
התמונה הזאת, פשוטו כמשמעו?

1042
00:46:06,820 --> 00:46:08,070
קהל: שום דבר לא מצביע.

1043
00:46:08,070 --> 00:46:09,945
DAVID מלאן: שום דבר לא
מצביע על ג'ייק עכשיו.

1044
00:46:09,945 --> 00:46:13,360
אנחנו כבר יתום 9, פשוטו כמשמעו,
ו -17, ויש לנו, פשוטו כמשמעו,

1045
00:46:13,360 --> 00:46:18,450
דלף כל הזיכרון הזה, משום שעל ידי
עדכון ידו של דוד הראשון, זה

1046
00:46:18,450 --> 00:46:21,660
קנס ככל שזה נכון
מצביע בטיפאני עכשיו,

1047
00:46:21,660 --> 00:46:25,410
אבל אם לא היה לו אחד
הנולד מצביע על ג'ייק,

1048
00:46:25,410 --> 00:46:27,490
לאחר מכן איבדנו
שלמות של הרשימה.

1049
00:46:27,490 --> 00:46:28,200
אז בואו לבטל.

1050
00:46:28,200 --> 00:46:30,950
אז זה היה דבר טוב
למעוד אבל בואו לתקן עכשיו.

1051
00:46:30,950 --> 00:46:33,624
מה על לעשות במקום הראשון?

1052
00:46:33,624 --> 00:46:34,124
כן?

1053
00:46:34,124 --> 00:46:35,791
>> קהל: טיפאני צריך להצביע על 9?

1054
00:46:35,791 --> 00:46:37,582
DAVID מלאן: אני לא יכול
להתקרב לך את זה.

1055
00:46:37,582 --> 00:46:38,720
מי צריך להצביע על 9?

1056
00:46:38,720 --> 00:46:39,220
>> קהל: טיפאני.

1057
00:46:39,220 --> 00:46:39,390
>> DAVID מלאן: בסדר.

1058
00:46:39,390 --> 00:46:41,200
אז טיפאני צריכה נקודה ראשונה ב9.

1059
00:46:41,200 --> 00:46:43,550
אז טיפאני צריך לקחת
על ערך זהה

1060
00:46:43,550 --> 00:46:45,820
לדוד, שנראה
מיותר לרגע,

1061
00:46:45,820 --> 00:46:48,820
אבל זה בסדר, כי עכשיו, שני
צעד, אנו יכולים לעדכן את ידו של דוד

1062
00:46:48,820 --> 00:46:52,680
כדי להצביע, ולאחר מכן אם בטיפאני
אנחנו פשוט סוג של נקי את הדברים

1063
00:46:52,680 --> 00:46:55,740
כאילו זה כמו סוג של האביב-,
עכשיו זה הכנסה נכונה.

1064
00:46:55,740 --> 00:46:56,700
אז מצוין.

1065
00:46:56,700 --> 00:46:57,970
אז עכשיו אנחנו כמעט שם.

1066
00:46:57,970 --> 00:47:01,075
בואו להכניס סופי אחד
ערך כמו הערך 20.

1067
00:47:01,075 --> 00:47:03,010
אם היינו יכול malloc מתנדב אחד סופי?

1068
00:47:03,010 --> 00:47:04,140
בואו למעלה.

1069
00:47:04,140 --> 00:47:06,224
אז זה אחד זה קצת יותר מסובך.

1070
00:47:06,224 --> 00:47:08,390
אבל באמת, את הקוד אנחנו
כתיבה, אם כי באופן מילולי,

1071
00:47:08,390 --> 00:47:10,610
הוא בדיוק כמו שיש חבורה
אם תנאים של החברה, נכון?

1072
00:47:10,610 --> 00:47:12,318
היו לנו מצב
בדיקה אם הוא שייך

1073
00:47:12,318 --> 00:47:13,840
בסוף, אולי ההתחלה.

1074
00:47:13,840 --> 00:47:15,940
אנחנו זקוקים לסוג של לולאה ל
למצוא את המקום באמצע.

1075
00:47:15,940 --> 00:47:17,400
אז בואו נעשה את זה עם מה שמך?

1076
00:47:17,400 --> 00:47:17,700
>> אריק: אריק.

1077
00:47:17,700 --> 00:47:18,340
>> DAVID מלאן: אריק?

1078
00:47:18,340 --> 00:47:18,660
אריק.

1079
00:47:18,660 --> 00:47:19,368
נחמד לפגוש אותך.

1080
00:47:19,368 --> 00:47:20,490
אז יש לנו 20.

1081
00:47:20,490 --> 00:47:21,220
פחות מחמישה?

1082
00:47:21,220 --> 00:47:21,530
מס '

1083
00:47:21,530 --> 00:47:22,160
פחות מתשעה?

1084
00:47:22,160 --> 00:47:22,410
מס '

1085
00:47:22,410 --> 00:47:23,050
פחות מ 17?

1086
00:47:23,050 --> 00:47:23,550
מס '

1087
00:47:23,550 --> 00:47:23,740
אוקיי.

1088
00:47:23,740 --> 00:47:25,701
הוא שייך לכאן ו
השמות שלך הם שוב?

1089
00:47:25,701 --> 00:47:26,200
לתבוע: סו.

1090
00:47:26,200 --> 00:47:26,880
DAVID מלאן: סו.

1091
00:47:26,880 --> 00:47:27,379
אלכס: אלכס.

1092
00:47:27,379 --> 00:47:28,790
DAVID מלאן: סו, אלכס, ו?

1093
00:47:28,790 --> 00:47:29,290
אריק: אריק.

1094
00:47:29,290 --> 00:47:30,120
DAVID מלאן: אריק.

1095
00:47:30,120 --> 00:47:32,140
ידיים שצריכות להתעדכן ראשון?

1096
00:47:32,140 --> 00:47:32,930
>> קהל: אריק.

1097
00:47:32,930 --> 00:47:33,429
אוקיי.

1098
00:47:33,429 --> 00:47:35,200
אז אריק צריך להצביע על איפה?

1099
00:47:35,200 --> 00:47:35,930
בגיל 22.

1100
00:47:35,930 --> 00:47:36,430
טוב.

1101
00:47:36,430 --> 00:47:38,180
ועכשיו מה הלאה?

1102
00:47:38,180 --> 00:47:40,800
סו אז יכולה להצביע על אריק
ועכשיו, אם אתם רק

1103
00:47:40,800 --> 00:47:44,077
לעשות קצת חדר, וזה בסדר גמור
מבחינה ויזואלית, עכשיו שעשינו ההכנסה.

1104
00:47:44,077 --> 00:47:47,160
אז בואו עכשיו לשקול שאלה אבל
תודה רבה לך על המתנדבים שלנו.

1105
00:47:47,160 --> 00:47:48,090
מאוד יפה מאוד.

1106
00:47:48,090 --> 00:47:50,831
אתה יכול לשמור אותם, אם תרצה.

1107
00:47:50,831 --> 00:47:54,140
ויש לנו מתנת פרידה יפה אם
היית רוצה לקחת את כל לחץ כדור.

1108
00:47:54,140 --> 00:47:56,030
תן לי רק לעבור את זה למטה.

1109
00:47:56,030 --> 00:47:58,430
אז מה הוא אוכל מוכן לכך?

1110
00:47:58,430 --> 00:48:02,430
זה נראה מדהים
ככל שיש לנו עכשיו

1111
00:48:02,430 --> 00:48:06,360
הציג חלופה ל
מערך שהוא לא כל כך מוגבל

1112
00:48:06,360 --> 00:48:07,780
למערך של כמה גודל קבוע.

1113
00:48:07,780 --> 00:48:09,380
הם יכולים לגדול באופן דינמי.

1114
00:48:09,380 --> 00:48:13,220
>> אבל כמו שראינו בשבועות
עבר, אנחנו לא מקבלים שום דבר בחינם,

1115
00:48:13,220 --> 00:48:15,740
כמו בוודאי יש trade-off כאן.

1116
00:48:15,740 --> 00:48:18,890
אז עם הפוך של מקושר
רשימה, הוא דינמי זה?

1117
00:48:18,890 --> 00:48:21,590
זו יכולת לגדול ולמען אמת,
היינו יכול לעשות מחיקה

1118
00:48:21,590 --> 00:48:23,570
ואנחנו יכולים להתכווץ בהתאם לצורך.

1119
00:48:23,570 --> 00:48:24,710
מה מחיר שאנחנו משלמים?

1120
00:48:24,710 --> 00:48:28,510

1121
00:48:28,510 --> 00:48:30,340
כפליים שטח, קודם כל.

1122
00:48:30,340 --> 00:48:34,010
אם אתה מסתכל על התמונה, כבר לא
אני אחסון רשימה של מספרים שלמים.

1123
00:48:34,010 --> 00:48:36,740
אני אחסון רשימה
מספרים שלמים ועוד מצביעים.

1124
00:48:36,740 --> 00:48:38,240
אז אני מכפיל את כמות השטח.

1125
00:48:38,240 --> 00:48:40,740
עכשיו, אולי זה לא כזה
עניין גדול 4 בתים, 8 בתים,

1126
00:48:40,740 --> 00:48:43,160
אבל זה בהחלט יכול להוסיף
לערכות נתונים גדולות.

1127
00:48:43,160 --> 00:48:45,570
מה חסרון אחר?

1128
00:48:45,570 --> 00:48:46,070
כן?

1129
00:48:46,070 --> 00:48:48,010
>> קהל: יש לנו ל
לחצות אותם אחד-אחד.

1130
00:48:48,010 --> 00:48:48,760
DAVID מלאן: כן.

1131
00:48:48,760 --> 00:48:50,260
אנחנו צריכים לעבור אותם אחד-אחד.

1132
00:48:50,260 --> 00:48:53,860
אתה יודע מה, ויתרנו סופר זה
תכונה נוחה של הסוגר מרובע

1133
00:48:53,860 --> 00:48:57,240
סימון, יותר כראוי
ידוע כגישה אקראית,

1134
00:48:57,240 --> 00:48:59,280
שבו אנחנו יכולים פשוט לקפוץ
למרכיב בודד

1135
00:48:59,280 --> 00:49:01,470
אבל עכשיו, אם עדיין היה לי
המתנדבים שלי כאן,

1136
00:49:01,470 --> 00:49:04,660
אם אני רוצה למצוא את
מספר 22, אני פשוט לא יכול

1137
00:49:04,660 --> 00:49:06,620
לקפוץ למדרגת משהו משהו.

1138
00:49:06,620 --> 00:49:10,530
אני צריך להסתכל על הרשימה, הרבה
כמו דוגמאות החיפוש שלנו באופן ליניארי,

1139
00:49:10,530 --> 00:49:12,260
כדי למצוא את המספר 22.

1140
00:49:12,260 --> 00:49:14,340
אז אנחנו כנראה שילמנו מחיר שם.

1141
00:49:14,340 --> 00:49:16,430
אבל אנחנו יכולים בכל זאת
לפתור בעיות אחרות.

1142
00:49:16,430 --> 00:49:18,587
>> למעשה, הרשה לי להציג
רק כמה חזותיים.

1143
00:49:18,587 --> 00:49:20,920
אז אם אתה כבר במורד ל
חדר האוכל של מאת'ר לאחרונה,

1144
00:49:20,920 --> 00:49:23,320
אתה זוכר ש
ערימות של מגשים כזה,

1145
00:49:23,320 --> 00:49:26,300
אנחנו לווה אלה מ
אננברג לפני השיעור.

1146
00:49:26,300 --> 00:49:28,930
אז זה ערימה של מגשים, אם כי,
הוא למעשה נציג

1147
00:49:28,930 --> 00:49:30,860
של מבנה נתוני מדעי מחשב.

1148
00:49:30,860 --> 00:49:32,910
יש מבנה נתונים
במדעי מחשב

1149
00:49:32,910 --> 00:49:38,010
ידוע כערימה שמאוד יפה
משאיל את עצמו לזה בדיוק חזותי.

1150
00:49:38,010 --> 00:49:41,380
אז אם כל אחד ממגשים אלה הוא לא
מגש אבל כמו מספר ורציתי

1151
00:49:41,380 --> 00:49:45,010
כדי לאחסן מספרים, אני
יכול לשים את אחד כאן,

1152
00:49:45,010 --> 00:49:48,320
ואני יכול לשים עוד כאן למטה,
וממשיך לערום מספרים

1153
00:49:48,320 --> 00:49:53,180
על גבי זה, ומה
פוטנציאל מועיל על זה

1154
00:49:53,180 --> 00:49:55,450
הוא שמה המשמעות
של מבנה נתונים זה?

1155
00:49:55,450 --> 00:49:58,045
איזה מספר אני יכול לשלוף
הראשון ביותר בנוחות?

1156
00:49:58,045 --> 00:50:00,640

1157
00:50:00,640 --> 00:50:03,030
המכר לאחרונה אחד שם.

1158
00:50:03,030 --> 00:50:06,430
>> אז זה מה שהיינו קורא ב
מדעי מחשב מבנה נתונים LIFO.

1159
00:50:06,430 --> 00:50:08,070
האחרון ב, יוצא ראשון.

1160
00:50:08,070 --> 00:50:10,800
ואנו רואים לפני זמן רב למה
שעשוי להיות שימושי אך לעת עתה,

1161
00:50:10,800 --> 00:50:12,200
רק לשקול את הרכוש.

1162
00:50:12,200 --> 00:50:15,158
וזה סוג של טיפשים אם אתה חושב
על איך חדר האוכל עושה את זה.

1163
00:50:15,158 --> 00:50:17,910
בכל פעם שהם מגשים נקיים ו
לשים העדכניים ביותר של אלה על גבי,

1164
00:50:17,910 --> 00:50:22,160
אתה יכול להיות נקי בעבר
אבל סופו של דבר מאוד מלוכלך ומאובק

1165
00:50:22,160 --> 00:50:24,360
מגש בתחתית מאוד
אם אתה אף פעם לא באמת

1166
00:50:24,360 --> 00:50:26,820
לרדת לעומק של ש
מחסנית, כי אתה פשוט

1167
00:50:26,820 --> 00:50:29,380
להמשיך לשים החדש ו
אלה נקיים על גבי זה.

1168
00:50:29,380 --> 00:50:31,840
אותו הדבר יכול לקרות
גם בסופרמרקט.

1169
00:50:31,840 --> 00:50:35,450
אם יש לך מקרה תצוגה
חלב וכל זמן CVS

1170
00:50:35,450 --> 00:50:37,610
או מי שמקבל יותר חלב,
אתה פשוט לדחוף חלב

1171
00:50:37,610 --> 00:50:39,880
יש לך כבר לחלק האחורי ו
אתה שם את חדש מלפנים,

1172
00:50:39,880 --> 00:50:43,088
אתה הולך לקבל קצת מגעיל למדי
חלב בסוף מבנה נתונים,

1173
00:50:43,088 --> 00:50:46,390
בגלל זה תמיד בתחתית או
באופן שקול זה תמיד בחלק האחורי.

1174
00:50:46,390 --> 00:50:50,407
>> אבל יש דרך נוספת לחשוב על
הזדנבות נתונים ולמשל, זה.

1175
00:50:50,407 --> 00:50:53,490
אם אתה אחד מאותם אנשים שאוהב
בשורה מחוץ לחנויות אפל

1176
00:50:53,490 --> 00:50:55,610
כאשר מוצר חדש מגיע
את, אתה כנראה

1177
00:50:55,610 --> 00:50:58,780
לא באמצעות נתונים ערימה
מבנה בגלל שאתה

1178
00:50:58,780 --> 00:51:03,070
היה להרחיק כל מי שהוא
בתור כדי לרכוש כמה צעצוע חדש.

1179
00:51:03,070 --> 00:51:06,610
במקום זאת, אתה כנראה באמצעות
איזה סוג של מבנה נתונים

1180
00:51:06,610 --> 00:51:10,050
או איזה סוג של מערכת
בעולם האמיתי?

1181
00:51:10,050 --> 00:51:13,493
אני מקווה שזה קו, או יותר
כראוי או כמו-בריטי יותר, תור.

1182
00:51:13,493 --> 00:51:17,700
ומתברר תור הוא גם
מבנה נתונים במדעי מחשב,

1183
00:51:17,700 --> 00:51:19,700
אבל תור יש מאוד
רכוש שונה.

1184
00:51:19,700 --> 00:51:20,820
זה לא LIFO.

1185
00:51:20,820 --> 00:51:21,990
האחרון ב, יוצא ראשון.

1186
00:51:21,990 --> 00:51:22,800
חלילה.

1187
00:51:22,800 --> 00:51:24,280
זה במקום FIFO.

1188
00:51:24,280 --> 00:51:26,110
ראשון ב, יוצא ראשון.

1189
00:51:26,110 --> 00:51:27,970
וזה דבר טוב
למען ההגינות "

1190
00:51:27,970 --> 00:51:30,428
בוודאי כשאתה עומדים בתור
עד סופר מוקדם בבוקר.

1191
00:51:30,428 --> 00:51:33,400
אם אתה מגיע לשם ראשון, אתה
רוצה לצאת ראשון גם כן.

1192
00:51:33,400 --> 00:51:35,880
>> וכך כל הנתונים האלה
מבנים, תורים וערימות

1193
00:51:35,880 --> 00:51:39,220
וצרורות של אחרים, מתברר לך
יכול לחשוב על כפשוט מערך זה.

1194
00:51:39,220 --> 00:51:41,820
זהו מערך, אולי
גודל קבוע 4, אבל זה יהיה

1195
00:51:41,820 --> 00:51:44,990
להיות סוג של נחמד אם נוכל רק ערימה
מגשים כמעט לאין שיעור גבוה אם

1196
00:51:44,990 --> 00:51:46,780
יש שמגשים או מספרים רבים.

1197
00:51:46,780 --> 00:51:48,840
אז אולי אנחנו רוצים
להשתמש רשימה מקושרת כאן,

1198
00:51:48,840 --> 00:51:51,800
אבל trade-off הולך להיות
פוטנציאל שאנחנו צריכים יותר זיכרון,

1199
00:51:51,800 --> 00:51:55,930
לוקח קצת יותר זמן, אבל אנחנו
לא להגביל את גובה הערימה,

1200
00:51:55,930 --> 00:51:59,550
הרבה כמו תיבת התצוגה של מאת'ר
עשוי להגביל את גודל הערימה,

1201
00:51:59,550 --> 00:52:03,117
ולכן אלה הם החלטות או עיצוב
אפשרויות זמינות לנו בסופו.

1202
00:52:03,117 --> 00:52:04,950
אז עם נתונים אלה
מבנים, שהתחלנו

1203
00:52:04,950 --> 00:52:09,360
רואה גבולות העליונים חדשים פוטנציאלי
על מה שהיה בעבר סופר מהיר

1204
00:52:09,360 --> 00:52:11,260
ושבו יהיה לנו לעזוב
את היום ובי

1205
00:52:11,260 --> 00:52:13,200
אנחנו מקווים להגיע ל
הוא ביום רביעי, אנחנו

1206
00:52:13,200 --> 00:52:15,740
להתחיל להסתכל על נתונים
מבנה המאפשר לנו לחפש

1207
00:52:15,740 --> 00:52:18,260
באמצעות נתונים בזמן סוף יומן שוב.

1208
00:52:18,260 --> 00:52:21,470
וראינו ש, זוכר, בשבוע אפס
ואחד עם חיפוש או הפרד ינארי

1209
00:52:21,470 --> 00:52:22,180
ולכבוש.

1210
00:52:22,180 --> 00:52:26,240
זה חוזר ויותר טוב,
הגביע הקדוש ליום רביעי

1211
00:52:26,240 --> 00:52:29,510
יהיה לבוא עם
מבנה נתונים שפועל באמת

1212
00:52:29,510 --> 00:52:32,070
או באופן תיאורטי ב
זמן קבוע, לפיו

1213
00:52:32,070 --> 00:52:34,760
זה לא משנה כמה
מיליון או מיליארדים של דברים

1214
00:52:34,760 --> 00:52:38,470
יש לנו במבנה נתונים, זה יהיה
תיקח לנו זמן קבוע, אולי צעד אחד

1215
00:52:38,470 --> 00:52:41,387
או שני צעדים או 10 שלבים,
אבל מספרים קבועים של צעדים

1216
00:52:41,387 --> 00:52:42,970
לחפש דרך שמבנה הנתונים.

1217
00:52:42,970 --> 00:52:46,300
שאכן יהיה הגביע הקדוש
אבל עוד על כך ביום רביעי.

1218
00:52:46,300 --> 00:52:49,045
נתראה אחר כך.

1219
00:52:49,045 --> 00:52:53,704
>> [השמעת מוסיקה]

1220
00:52:53,704 --> 00:56:08,448