1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:11,261
[השמעת מוסיקה]

3
00:00:11,261 --> 00:00:12,640
>> דוד י מלאן: בסדר.

4
00:00:12,640 --> 00:00:14,525
זה CS50.

5
00:00:14,525 --> 00:00:16,009
וזה הוא ההתחלה של שבוע 5.

6
00:00:16,009 --> 00:00:18,050
וכמו שאתה אולי שמת לב,
חלק מהחומר

7
00:00:18,050 --> 00:00:21,050
הוא מקבל קצת יותר
מורכב, צפוף יותר הקטן.

8
00:00:21,050 --> 00:00:24,560
>> וזה קל מאוד, במיוחד אם
אתה כבר ברגל לכמה זמן,

9
00:00:24,560 --> 00:00:28,600
למנסה לשרבט ביותר
כל דבר שאנחנו עושים, אנחנו אומרים בכיתה.

10
00:00:28,600 --> 00:00:31,626
אבל מבין, שאינו אולי
הגישה הפדגוגית האידיאלית

11
00:00:31,626 --> 00:00:34,250
ללמידה של חומר מסוג זה,
וחומר באופן כללי יותר.

12
00:00:34,250 --> 00:00:37,250
וכך אנו שמחים
להודיע ​​Gheng של CS50 ש

13
00:00:37,250 --> 00:00:39,780
גונג החל להכין
סט הקנוני של הערות

14
00:00:39,780 --> 00:00:42,100
לקורס, התקווה
והוא ש, אחד, אלה

15
00:00:42,100 --> 00:00:44,030
לא רק לשמש כ
התייחסות ומשאבים

16
00:00:44,030 --> 00:00:47,410
לבחינת חומר והולך
בחזרה דרך חומר שאולי יש לי

17
00:00:47,410 --> 00:00:51,230
ברחתי לך בסיבוב הראשון, אבל
גם כדי שהראש שלך יכול להיות יותר

18
00:00:51,230 --> 00:00:53,740
עד מאשר למטה, כאשר הוא
מגיע זמן להרצות,

19
00:00:53,740 --> 00:00:56,960
כך שאולי אתה עוסק
יותר מהורהר, כ

20
00:00:56,960 --> 00:00:59,170
בניגוד ליותר scribbly.

21
00:00:59,170 --> 00:01:02,510
>> עם זאת אמר, מה שאתה תמצא על
אתר האינטרנט הוא מסמכים מסוג זה.

22
00:01:02,510 --> 00:01:04,660
והודעה, בצד שמאל למעלה, יש
לא רק תוכן,

23
00:01:04,660 --> 00:01:06,920
אבל גם קודי זמן ש
אקפוץ לך באופן מיידי

24
00:01:06,920 --> 00:01:09,077
לחלק המתאים
בוידאו המקוון.

25
00:01:09,077 --> 00:01:11,410
ומה צ'אנג כאן עשה
הוא, במהותו, שתועד

26
00:01:11,410 --> 00:01:13,340
מה שקרה בזה
הרצאה מסוימת.

27
00:01:13,340 --> 00:01:16,370
ורבים מההרצאות
כבר כעת באינטרנט עם כתובת אתר זו.

28
00:01:16,370 --> 00:01:20,110
ואנחנו נמשיך לפרסם את השארית
מאותם עד סוף השבוע,

29
00:01:20,110 --> 00:01:22,380
אז אל לנצל את המשאב הזה.

30
00:01:22,380 --> 00:01:25,740
>> אז בלי עיכובים נוספים,
התחלנו לקלף

31
00:01:25,740 --> 00:01:28,180
השכבה שהייתה
מחרוזת לכמה זמן.

32
00:01:28,180 --> 00:01:30,670
ומה שאנחנו לא אומרים מחרוזת
למעשה הוא בשבוע שעבר?

33
00:01:30,670 --> 00:01:31,720

34
00:01:31,720 --> 00:01:32,900
כוכב אז char.

35
00:01:32,900 --> 00:01:34,900
וכוכב char, גם, מה
לא שבאמת מתכוונים?

36
00:01:34,900 --> 00:01:37,150
ובכן, כל הזמן הזה, אם יש לנו
כבר קורא לפונקציה,

37
00:01:37,150 --> 00:01:40,450
כמו getString, ואחסון
התמורה שנקרא

38
00:01:40,450 --> 00:01:42,910
ערך של getString ב
variable-- זה נקרא

39
00:01:42,910 --> 00:01:47,721
סוג של string-- אנחנו כבר כותבים
שורת קוד שם למעלה מעל.

40
00:01:47,721 --> 00:01:49,970
וזה רק כשאני רואה את שלי
כתב יד מוגדל כאן

41
00:01:49,970 --> 00:01:51,930
אני מבין עד כמה אכזרי זה.

42
00:01:51,930 --> 00:01:54,180
>> עם זאת, הבה נניח כי,
בצד ימין

43
00:01:54,180 --> 00:01:57,070
הוא, בכל זאת, סביר
תיאור של מה ש

44
00:01:57,070 --> 00:01:58,880
היה הולך על כל זה
זמן עם getString.

45
00:01:58,880 --> 00:02:00,380
getString, כמובן, מקבל מחרוזת.

46
00:02:00,380 --> 00:02:01,691
אבל מה זה באמת אומר?

47
00:02:01,691 --> 00:02:04,190
זה אומר שהוא מקבל נתח של
זיכרון ממערכת ההפעלה

48
00:02:04,190 --> 00:02:06,040
על ידי קריאה לפונקציה, נקרא malloc.

49
00:02:06,040 --> 00:02:07,390
אבל יותר על כך בהמשך.

50
00:02:07,390 --> 00:02:09,139
ואז זה מאכלס
נתח זה של זיכרון

51
00:02:09,139 --> 00:02:11,764
עם האותיות למשתמש יש
הקליד ב, ואחריו, כמובן,

52
00:02:11,764 --> 00:02:14,800
אופי null, או קו נטוי
אפס ממש בסוף.

53
00:02:14,800 --> 00:02:18,280
>> בינתיים, בצד השמאל
של הסיפור הזה, כל הזמן הזה,

54
00:02:18,280 --> 00:02:20,850
אנחנו כבר הכריזו משתנים, כמו של.

55
00:02:20,850 --> 00:02:24,770
ומשתנה זה מה שעכשיו
יתחיל לקרוא מצביע.

56
00:02:24,770 --> 00:02:29,190
זה לא תיבה ובתוכה
אנחנו שמים את המחרוזת, ךייבן, כשלעצמה,

57
00:02:29,190 --> 00:02:32,550
אלא שאנחנו מכניסים לכיכר ש
תיבה בצד השמאל מה בדיוק?

58
00:02:32,550 --> 00:02:34,890

59
00:02:34,890 --> 00:02:35,390
כן?

60
00:02:35,390 --> 00:02:37,118
>> קהל: הכתובת של
איפה זה נמצא בזיכרון.

61
00:02:37,118 --> 00:02:38,118
>> דוד י מלאן: בדיוק.

62
00:02:38,118 --> 00:02:40,690
את הכתובת שבי ךייבן
ממוקם בזיכרון.

63
00:02:40,690 --> 00:02:44,650
ולא שבו כל ךייבן ממוקם,
כשלעצמו, אבל באופן ספציפי את כתובת

64
00:02:44,650 --> 00:02:45,150
של מה?

65
00:02:45,150 --> 00:02:46,311

66
00:02:46,311 --> 00:02:46,810
כן?

67
00:02:46,810 --> 00:02:47,460
>> קהל: דמות ראשונה.

68
00:02:47,460 --> 00:02:50,209
>> דוד י מלאן: התו הראשון
בךייבן, אשר, במקרה זה,

69
00:02:50,209 --> 00:02:53,820
הציע שהיה באופן שרירותי
ולא מציאותי 1, OX1,

70
00:02:53,820 --> 00:02:55,910
שרק אומר
מספר הקסדצימלי של 1.

71
00:02:55,910 --> 00:02:57,993
אבל זה כנראה הולך
להיות מספר הרבה יותר גדול

72
00:02:57,993 --> 00:03:01,260
שאולי אנו מפנים את
עם 0x כקידומת,

73
00:03:01,260 --> 00:03:02,806
המייצג את אופי הקסדצימלי.

74
00:03:02,806 --> 00:03:05,930
ובגלל שאנחנו לא צריכים לדעת איפה
שאר הדמויות של ךייבן

75
00:03:05,930 --> 00:03:09,860
הם, בגלל מה שעיצוב פשוט
החלטה שהתקבלה לפני שנים רבות?

76
00:03:09,860 --> 00:03:10,548
כן?

77
00:03:10,548 --> 00:03:11,651
>> קהל: מהלך סרק 0.

78
00:03:11,651 --> 00:03:12,900
דוד י מלאן: כן, בדיוק.

79
00:03:12,900 --> 00:03:18,100
הקו הנטוי 0 מאפשר לך, אם כי ב
זמן ליניארי, לעבור את המחרוזת,

80
00:03:18,100 --> 00:03:20,400
ללכת משמאל לימין,
עם ללולאה, או בזמן ש

81
00:03:20,400 --> 00:03:22,608
לולאה, או משהו כזה
כי, ולקבוע, הו, כאן

82
00:03:22,608 --> 00:03:24,751
זה הסוף של מחרוזת המסוימת הזה.

83
00:03:24,751 --> 00:03:27,000
אז רק עם הכתובת ב
תחילת מחרוזת,

84
00:03:27,000 --> 00:03:30,290
אנחנו יכולים לגשת למכלול
זה, משום שכל הזמן הזה,

85
00:03:30,290 --> 00:03:32,030
מחרוזת רק הייתה כוכב char.

86
00:03:32,030 --> 00:03:36,370
>> אז זה בהחלט בסדר להמשיך להשתמש
ספריית CS50 והפשטה זו,

87
00:03:36,370 --> 00:03:38,440
אם אפשר לומר כך, אבל אנחנו
מתחיל לראות בדיוק

88
00:03:38,440 --> 00:03:41,230
מה שקורה
מתחת כל הזמן הזה.

89
00:03:41,230 --> 00:03:45,260
אז אתה אולי זוכר דוגמא זו,
מדי, מעת האחרונה, להשוות 0,

90
00:03:45,260 --> 00:03:47,300
שלא ממש להשוות.

91
00:03:47,300 --> 00:03:49,070
אבל התחלנו לפתור את זה.

92
00:03:49,070 --> 00:03:52,020
>> אבל כפי שאולי רענון,
אולי אני מעניינת את מישהו

93
00:03:52,020 --> 00:03:54,261
בפיל ורוד היום,
גם שנעשה על ידי צ'אנג?

94
00:03:54,261 --> 00:03:55,760
מה דעתך על שאתה בחזית? [לא ברור].

95
00:03:55,760 --> 00:03:56,660
בואו למעלה.

96
00:03:56,660 --> 00:03:58,740
>> ובינתיים,
שאתה בא, בוא

97
00:03:58,740 --> 00:04:01,670
לשקול לרגע מה
הקוד הזה עושה בעצם.

98
00:04:01,670 --> 00:04:04,917
זה שהכריז שני משתנים עד
עליון, של ולא, וקורא getString.

99
00:04:04,917 --> 00:04:08,250
זה לא תכנית מאוד ידידותי למשתמש,
כי זה לא אומר לך מה לעשות.

100
00:04:08,250 --> 00:04:10,541
אבל בואו רק נניח שאנחנו
התמקדות בחלק העסיסי.

101
00:04:10,541 --> 00:04:14,470
ואז אנחנו עושים, אם זה שווה
שווה t, זה צריך לומר printf,

102
00:04:14,470 --> 00:04:16,170
שהקלדת את אותו הדבר.

103
00:04:16,170 --> 00:04:16,670
שלום.

104
00:04:16,670 --> 00:04:17,050
מה שמך?

105
00:04:17,050 --> 00:04:17,779
>> נל: נל.

106
00:04:17,779 --> 00:04:19,529
דוד י מלאן: נל,
נחמד לפגוש אותך.

107
00:04:19,529 --> 00:04:21,800
אז האתגר שלך ב
יד לפיל הזה

108
00:04:21,800 --> 00:04:25,230
הוא ראשון לצייר לנו תמונה של מה
להיות מיוצג בשני הראשונים אלה

109
00:04:25,230 --> 00:04:25,970
קווים.

110
00:04:25,970 --> 00:04:28,139
אז T S ויכול להיות
מיוצג כיצד על המסך?

111
00:04:28,139 --> 00:04:30,680
ואתה יכול פשוט לצייר אותו עם
האצבע שלך על מסך גדול זה.

112
00:04:30,680 --> 00:04:31,780

113
00:04:31,780 --> 00:04:34,510
>> אז יש שני חצאים ל
כל צד של משוואה ש.

114
00:04:34,510 --> 00:04:37,760
אז יש ים בצד השמאל, ו
אז getString בצד הימין.

115
00:04:37,760 --> 00:04:40,540
ואז יש t בצד השמאל,
ולאחר מכן getString בצד הימין.

116
00:04:40,540 --> 00:04:42,630
אז איך אנחנו יכולים להתחיל
ציור תמונה ש

117
00:04:42,630 --> 00:04:46,340
מייצג את מה שקורה
כאן בזיכרון, היית אומר?

118
00:04:46,340 --> 00:04:49,150
ותן לי לתת לך להסביר
מה שאתה עושה כמו שאתה הולך.

119
00:04:49,150 --> 00:04:49,820
>> ג'נל: אישור.

120
00:04:49,820 --> 00:04:58,890
ובכן, ראשון, זה יהיה שואל
כדי שתוכל לקבל את מחרוזת הקלט.

121
00:04:58,890 --> 00:05:00,439
וזה יהיה store-- הו, מצטער.

122
00:05:00,439 --> 00:05:01,230
דוד י מלאן: אישור.

123
00:05:01,230 --> 00:05:01,730
טוב.

124
00:05:01,730 --> 00:05:03,330
וזה נקרא מה?

125
00:05:03,330 --> 00:05:03,950
אה, אוקיי.

126
00:05:03,950 --> 00:05:04,450
להמשיך.

127
00:05:04,450 --> 00:05:05,575
אני לא התכוונתי להפריע.

128
00:05:05,575 --> 00:05:07,060
ג'נל: מצטער.

129
00:05:07,060 --> 00:05:14,237
אז זה היית קלטו לתוך
כתובת לא of-- בטוח.

130
00:05:14,237 --> 00:05:17,320
אני לא יכול בדיוק זוכר את המספר,
אבל אני מאמין שזה התחיל עם 0.

131
00:05:17,320 --> 00:05:18,420
>> דוד י מלאן: זה בסדר,
כי אני עשיתי את המספרים עד,

132
00:05:18,420 --> 00:05:19,650
כך שאין תשובה נכונה.

133
00:05:19,650 --> 00:05:22,105
>> ג'נל: החל מהקשת 0.

134
00:05:22,105 --> 00:05:24,000
>> דוד י מלאן: אוקיי, אז אלמנט 0.

135
00:05:24,000 --> 00:05:24,765
בטח.

136
00:05:24,765 --> 00:05:28,295
>> נל: ואז אם היה
סתם שתי letter--

137
00:05:28,295 --> 00:05:30,496
>> דוד י מלאן: אישור, אחזור אליך.

138
00:05:30,496 --> 00:05:33,629
>> ג'נל: אז אלמנט 0, ו
אז אלמנט 1 או אלמנט 2.

139
00:05:33,629 --> 00:05:36,670
דוד י מלאן: ושפיסה
התמונה אתה מצייר עכשיו?

140
00:05:36,670 --> 00:05:37,690
הקריאה לgetString?

141
00:05:37,690 --> 00:05:38,830
או ההכרזה על ים?

142
00:05:38,830 --> 00:05:42,890
>> ג'נל: ההכרזה
של ים, אני מאמין.

143
00:05:42,890 --> 00:05:45,980
אה, getString, כי זה היה
להיות שהוזן לתוך כל [? אזור. ?]

144
00:05:45,980 --> 00:05:46,510
>> דוד י מלאן: טוב.

145
00:05:46,510 --> 00:05:47,051
בדיוק.

146
00:05:47,051 --> 00:05:49,300
למרות שיעילות זה
מחזיר מערך, כזכור,

147
00:05:49,300 --> 00:05:53,300
כשנחזור מחרוזת, שביכולתנו
מדד למחרוזת שבאמצעות 01 ו2.

148
00:05:53,300 --> 00:05:56,180
מבחינה טכנית, אלה הם כנראה
מיוצג על ידי כתובות אישיות,

149
00:05:56,180 --> 00:05:57,100
אבל זה בסדר.

150
00:05:57,100 --> 00:06:00,170
>> אז נניח, אם אני יכול פשוט מהיר
קדימה למקום שבו הפסקנו

151
00:06:00,170 --> 00:06:04,320
הפעם האחרונה, אם אחד
המחרוזות היו g דואר ב,

152
00:06:04,320 --> 00:06:10,337
קו נטוי 0, ובכך מייצג את גייב של
קלט, איך ייתכן שאנו מייצגים ים עכשיו?

153
00:06:10,337 --> 00:06:12,670
אם זה זיכרון זה
הוחזר על ידי getString?

154
00:06:12,670 --> 00:06:14,415

155
00:06:14,415 --> 00:06:17,610
>> נל: האם זה יהיה
מיוצג על ידי קשת?

156
00:06:17,610 --> 00:06:18,750
>> דוד י מלאן: על ידי קשת?

157
00:06:18,750 --> 00:06:19,130
ובכן, לא.

158
00:06:19,130 --> 00:06:21,171
בואו רק נאמר, באופן ציורי,
תן לי רק קדימה

159
00:06:21,171 --> 00:06:25,710
ומציע ש, אם זה ים, זה
הוא ערך ההחזרה של getString.

160
00:06:25,710 --> 00:06:29,482
ואתה כבר נמשך זה כ0, 1, 2, ש
הוא סביר לחלוטין, כי אנחנו

161
00:06:29,482 --> 00:06:30,940
יכול מדד למחרוזת, ככזה.

162
00:06:30,940 --> 00:06:33,340
אבל רק כדי להיות בקנה אחד עם
הפעם האחרונה, תן לי ללכת קדימה

163
00:06:33,340 --> 00:06:37,310
ושרירותי מציע שזה
היא כתובת 1, זו כתובת 2,

164
00:06:37,310 --> 00:06:39,597
זו היא כתובת 3, וכן הלאה.

165
00:06:39,597 --> 00:06:41,430
וכך, רק כדי להיות סופר
ברור, מה קורה

166
00:06:41,430 --> 00:06:44,580
ללכת בים כתוצאה מכך
השורה הראשונה של קוד, היית אומר?

167
00:06:44,580 --> 00:06:45,420
>> ג'נל: כתובת 1?

168
00:06:45,420 --> 00:06:46,420
>> דוד י מלאן: בדיוק.

169
00:06:46,420 --> 00:06:47,190
אז לטפל 0x1.

170
00:06:47,190 --> 00:06:48,220

171
00:06:48,220 --> 00:06:51,230
ובינתיים, תן לי ללכת קדימה ו
לשכפל הרבה ממה שעשית

172
00:06:51,230 --> 00:06:52,740
ולהוסיף t שלי כאן.

173
00:06:52,740 --> 00:06:56,340
אם הייתי מקליד בגייב
שוב, בפעם שנייה,

174
00:06:56,340 --> 00:07:01,530
כאשר תתבקשו לעשות זאת עם getString, שבו,
כמובן, הוא גייב הולך?

175
00:07:01,530 --> 00:07:02,280
ובכן, presumably--

176
00:07:02,280 --> 00:07:04,935

177
00:07:04,935 --> 00:07:05,975
>> ג'נל: כמו כאן?

178
00:07:05,975 --> 00:07:06,850
דוד י מלאן: כן.

179
00:07:06,850 --> 00:07:08,516
ג'נל: או שזה גם נמצא באותו התיבות?

180
00:07:08,516 --> 00:07:11,940
דוד י מלאן: הרשה לי להציע, כן,
, כך בדיוק בקופסות נוספות אלה.

181
00:07:11,940 --> 00:07:15,230
אבל מה מפתח עכשיו הוא שגם
למרות שאני שציירתי אלה די קרובים

182
00:07:15,230 --> 00:07:18,650
together-- 0x1, זה
הוא 0x2-- במציאות,

183
00:07:18,650 --> 00:07:25,750
זה עכשיו יכול להיות כתובת 0x10,
למשל, ו0x11, ו0x12,

184
00:07:25,750 --> 00:07:26,870
וכן הלאה.

185
00:07:26,870 --> 00:07:29,955
וכך, אם זה המקרה,
מה קורה בסופו של כאן בt?

186
00:07:29,955 --> 00:07:30,830
>> ג'נל: 0x10?

187
00:07:30,830 --> 00:07:31,830
דוד י מלאן: בדיוק.

188
00:07:31,830 --> 00:07:33,180
אז 0x10.

189
00:07:33,180 --> 00:07:34,570
ואז עכשיו, השאלה אחרונה.

190
00:07:34,570 --> 00:07:37,510
יש לך, ללא ספק, היה צריך לעבוד
הכי קשה לפיל עד כה.

191
00:07:37,510 --> 00:07:42,650
עד עכשיו, אם אני מושך את הקוד
שוב, כשאני עושה, בשורה שלוש,

192
00:07:42,650 --> 00:07:47,630
אם ים שווה שווה t, מה אני בעצם
השוויתי שיש לנו נמשך לכאן?

193
00:07:47,630 --> 00:07:49,271
>> ג'נל: שתי כתובות?

194
00:07:49,271 --> 00:07:50,270
דוד י מלאן: בדיוק.

195
00:07:50,270 --> 00:07:53,350
אז אני אומר הוא S שווה שווה לא?

196
00:07:53,350 --> 00:07:56,210
במילים אחרות, הוא 1 שווה שווה ל10?

197
00:07:56,210 --> 00:07:59,710
וכמובן,
תשובה ברורה כרגע היא, לא.

198
00:07:59,710 --> 00:08:02,920
וכך תכנית זו היא סופו של דבר
הולך להדפיס מה, היית אומר?

199
00:08:02,920 --> 00:08:05,770

200
00:08:05,770 --> 00:08:08,405
>> נל: האם זה יהיה,
שהקלדת את אותו הדבר?

201
00:08:08,405 --> 00:08:11,446
>> דוד י מלאן: אז אם
ים הוא 1 ולא הוא 10?

202
00:08:11,446 --> 00:08:13,320
>> ג'נל: הקלדת דברים שונים.

203
00:08:13,320 --> 00:08:13,570
>> דוד י מלאן: בדיוק.

204
00:08:13,570 --> 00:08:14,480
שהקלדת דברים שונים.

205
00:08:14,480 --> 00:08:14,850
בסדר.

206
00:08:14,850 --> 00:08:16,714
אז מחיאות כפות,
אם היינו יכולים, כאן.

207
00:08:16,714 --> 00:08:17,214
[מחיאות כפות]

208
00:08:17,214 --> 00:08:17,708
זה היה כואב.

209
00:08:17,708 --> 00:08:18,208
אני יודע.

210
00:08:18,208 --> 00:08:19,684
יפה עשה.

211
00:08:19,684 --> 00:08:24,690
אז עכשיו בואו תראו אם אנחנו לא יכולים
להפריד את מה שהתיקון היה.

212
00:08:24,690 --> 00:08:28,040
וכמובן, כאשר אנו קבועים זה-
שבו אני עכשיו יהיה לייצג בgreen--

213
00:08:28,040 --> 00:08:29,690
עשינו כמה שיפורים כאן.

214
00:08:29,690 --> 00:08:32,409
ראשית, בדיוק כמו שפיות
לבדוק, אני ראשון אני בודק

215
00:08:32,409 --> 00:08:35,110
אם ים שווה null ולא שווה null.

216
00:08:35,110 --> 00:08:39,440
ורק שיהיה ברור, כאשר אולי
ים או לא להיות null בקוד כזה?

217
00:08:39,440 --> 00:08:43,140

218
00:08:43,140 --> 00:08:44,490
כאשר ים או לא להיות אולי null.

219
00:08:44,490 --> 00:08:44,990
כן?

220
00:08:44,990 --> 00:08:45,990
>> קהל: [לא ברור].

221
00:08:45,990 --> 00:08:49,490

222
00:08:49,490 --> 00:08:50,510
>> דוד י מלאן: בדיוק.

223
00:08:50,510 --> 00:08:52,840
אם המחרוזת שהמשתמש
הקלידה בדרך ארוכה מדי

224
00:08:52,840 --> 00:08:56,140
כדי שיתאים לזיכרון, או כמה
מקרה פינה מוזר כמו ש,

225
00:08:56,140 --> 00:08:59,010
getString, כפי שנראה, פשוטו כמשמעו
היום, בתיעוד שלה,

226
00:08:59,010 --> 00:09:02,330
אומר שזה יחזיר null כ
ערך זקיף מיוחד,

227
00:09:02,330 --> 00:09:05,417
או סתם סוג של סמל מיוחד
זה אומר שמשהו השתבש.

228
00:09:05,417 --> 00:09:07,500
אז אנחנו רוצים לבדוק
כי, משום שמתברר

229
00:09:07,500 --> 00:09:09,720
null שהוא ערך מאוד מסוכן.

230
00:09:09,720 --> 00:09:14,250
>> לעתים קרובות, אם אתה מנסה לעשות משהו עם
null מעורב function-- העברתו

231
00:09:14,250 --> 00:09:17,470
כקלט, לinstance-- פונקציה ש
אולי יהיה מאוד לקרוס ו, עם זה,

232
00:09:17,470 --> 00:09:19,090
לקחת את כל התכנית שלך.

233
00:09:19,090 --> 00:09:22,570
אז שורה שלישית זה כרגע היא רק שפיות
לבדוק, בדיקת שגיאות, אם תרצה.

234
00:09:22,570 --> 00:09:25,450
זה הרגל טוב עכשיו
לנו להיכנס לכל עת שאנו

235
00:09:25,450 --> 00:09:28,050
אנסה להשתמש בערך
יכול, באופן פוטנציאלי, להיות null.

236
00:09:28,050 --> 00:09:32,000
>> עכשיו, בשורה הרביעית כאן,
"אם strcmp (ים, t)," גם,

237
00:09:32,000 --> 00:09:33,180
מה שמתכוון?

238
00:09:33,180 --> 00:09:36,750
ובכן, אנחנו אמרתי שזה היה מאוד בתמציתיות
פונקציה בשם להשוואת מחרוזת.

239
00:09:36,750 --> 00:09:40,370
ומטרתו בחיים היא כדי להשוות
הטיעון הראשון שלה נגדה שני,

240
00:09:40,370 --> 00:09:44,640
אבל לא במונחים של הכתובות שלהם,
כפי שעשינו שלא במתכוון רגע

241
00:09:44,640 --> 00:09:48,270
לפני עם הקוד האדום, אבל
ולא להשוות בין שני אלה

242
00:09:48,270 --> 00:09:53,210
מחרוזות באינטואיטיבי מבחינה אנושית
דרך על ידי השוואה זו, כנגד זה,

243
00:09:53,210 --> 00:09:56,690
נגד זה, נגד זה, ו
אז עוצר אם וכאשר אחד

244
00:09:56,690 --> 00:09:59,590
או שתיהן, האצבעות שלי
להיטי קו נטוי 0.

245
00:09:59,590 --> 00:10:04,530
strcmp כך שנות מישהו יישמו לפני
ליישם עבורנו את הפונקציונליות

246
00:10:04,530 --> 00:10:08,890
שקיוויתי שהיו מקבל
רק על ידי השוואה בין שני ערכים פשוטים.

247
00:10:08,890 --> 00:10:14,929
>> עכשיו בכנות, אני שומר ציור
כל אלה מספרים השונים.

248
00:10:14,929 --> 00:10:17,470
אבל המציאות היא, שהייתי
מה שהופך את אלה עד כל הזמן.

249
00:10:17,470 --> 00:10:19,580
ואז תן לי רק קדימה
ולשרבט את אלה

250
00:10:19,580 --> 00:10:23,100
כדי להבהיר נקודה ש, בסופו של הדבר
של היום ולנוע קדימה,

251
00:10:23,100 --> 00:10:30,160
אנחנו לא באמת הולכים אכפת
מה כתובות דברים הם למעשה

252
00:10:30,160 --> 00:10:30,790
בזיכרון.

253
00:10:30,790 --> 00:10:34,320
אז אני לא הולך לצייר אלה
סוגים של מספרים כל כך הרבה יותר,

254
00:10:34,320 --> 00:10:38,970
אני רק מופשט זה משם
קצת יותר ידידותי עם רק חיצים.

255
00:10:38,970 --> 00:10:42,060
>> במילים אחרות, אם ים הוא מצביע,
טוב, בואו פשוט לצייר אותו, פשוטו כמשמעו,

256
00:10:42,060 --> 00:10:45,430
כמצביע, חץ מצביע
מעצמו למשהו אחר,

257
00:10:45,430 --> 00:10:48,280
ולא לדאוג יותר מדי עוד על
הפרטים הקטנים של כתובות אלה

258
00:10:48,280 --> 00:10:49,910
אשר, שוב, המצאתי בכל מקרה.

259
00:10:49,910 --> 00:10:52,680
אבל נראה כתובות אלה,
לפעמים, כאשר באגים קוד.

260
00:10:52,680 --> 00:10:56,450
>> עכשיו בינתיים, תכנית זו
עד כאן תיקונים, כמובן,

261
00:10:56,450 --> 00:10:58,720
בעיה שעל ידי השוואה
אלה שתי מחרוזות.

262
00:10:58,720 --> 00:11:00,260
אבל נתקלנו בבעיה אחרת.

263
00:11:00,260 --> 00:11:03,180
זה היה מהעותק
לתכנת פעם האחרונה,

264
00:11:03,180 --> 00:11:06,880
לפיו, אני מנסה לנצל
רק התו הראשון במחרוזת.

265
00:11:06,880 --> 00:11:09,620
אבל מה היה הסימפטום
ראינו פעם כאשר האחרונה

266
00:11:09,620 --> 00:11:14,150
משתמש הקליד בערך, כמו
גייב באותיות קטנה, לים,

267
00:11:14,150 --> 00:11:19,310
אז אנחנו מוקצים של אל t,
כמו בשורה השלישית יש,

268
00:11:19,310 --> 00:11:22,900
ולאחר מכן ניסיתי
לנצל סוגר t 0?

269
00:11:22,900 --> 00:11:25,950
מה הייתה ההשפעה של
שינוי סוגר t 0 כאן?

270
00:11:25,950 --> 00:11:27,150
>> קהל: זה השתנה ים.

271
00:11:27,150 --> 00:11:29,360
>> דוד י מלאן: כן,
גם אני שיניתי את של,.

272
00:11:29,360 --> 00:11:31,050
כי מה שבאמת קורה?

273
00:11:31,050 --> 00:11:34,130
ובכן, תן לי לראות אם אני יכול לנקות
את התמונה הזאת, כדלקמן.

274
00:11:34,130 --> 00:11:41,390
>> אם ים הוא, שוב, המילה גרם,
, B, E, קו נטוי, 0, ושל

275
00:11:41,390 --> 00:11:44,084
אנחנו נמשיך ציור כמו קופסא
כאן, אך לא יותר כתובות.

276
00:11:44,084 --> 00:11:45,250
בואו נפסיק לעשות את דברים.

277
00:11:45,250 --> 00:11:47,510
בואו רק לצייר תמונה
כדי לפשט את העולם.

278
00:11:47,510 --> 00:11:52,640
>> כאשר אני מצהיר t עם t מחרוזת,
שיוצר נתח זה של זיכרון.

279
00:11:52,640 --> 00:11:55,850
כיכר קורה להיות 32
ביטים ברוב המחשבים.

280
00:11:55,850 --> 00:11:59,530
למעשה, אם אתה אי פעם שמעת על
מחשב שיש לו ארכיטקטורה 32 סיביות,

281
00:11:59,530 --> 00:12:03,000
באמת מפואר, לדבר, שרק
משמעות הדבר היא שהוא משתמש כתובות 32 סיביות.

282
00:12:03,000 --> 00:12:05,370
וכטכני בצד,
אם תהית אי פעם

283
00:12:05,370 --> 00:12:09,630
מדוע מחשבים ישנים, אם אתה באמת
ניסיתי מרק אותם עם הרבה זיכרון RAM,

284
00:12:09,630 --> 00:12:12,360
רק יכול להיות לכל היותר
של ארבע ג'יגה בייט של זיכרון RAM,

285
00:12:12,360 --> 00:12:14,860
גם זה בגלל ש, פשוטו כמשמעו,
יכול המחשב הישן רק

286
00:12:14,860 --> 00:12:17,250
לספור גבוה ככל 4
מיליארדים, 4 מליארד בייטים,

287
00:12:17,250 --> 00:12:20,590
כי זה היה באמצעות 32 סיביות
מספרים לכתובות.

288
00:12:20,590 --> 00:12:23,260
>> אבל בכל מקרה, בזה
דוגמא, של סיפור הרבה יותר פשוט.

289
00:12:23,260 --> 00:12:27,250
t הוא רק מצביע אחר, או
באמת כוכב char, aka מחרוזת.

290
00:12:27,250 --> 00:12:30,860
ואיך אני רוצה לעדכן את התמונה הזאת
עכשיו עם שהשורה שנייה של קוד,

291
00:12:30,860 --> 00:12:31,950
אחרי הנקודה,, נקודת נקודה?

292
00:12:31,950 --> 00:12:35,845
כשאני עושה את t המחרוזת שווה נקודה ופסיק של,
איך התמונה הזאת תשתנה?

293
00:12:35,845 --> 00:12:37,500

294
00:12:37,500 --> 00:12:38,000
כן?

295
00:12:38,000 --> 00:12:38,916
>> קהל: [לא ברור].

296
00:12:38,916 --> 00:12:41,087

297
00:12:41,087 --> 00:12:42,020
>> דוד י מלאן: כן.

298
00:12:42,020 --> 00:12:42,600
בדיוק.

299
00:12:42,600 --> 00:12:45,620
אני פשוט לשים את חץ מ
תיבה לא לאותה הכתובת,

300
00:12:45,620 --> 00:12:47,570
אותו המכתב הראשון בנתן.

301
00:12:47,570 --> 00:12:50,850
או מבחינה טכנית, אם זה
בחור היה עדיין ב0x1,

302
00:12:50,850 --> 00:12:53,052
זה כאילו שהיה לי
0x1 כאן ו0x1 כאן.

303
00:12:53,052 --> 00:12:54,760
אבל שוב, למי אכפת
על הכתובות?

304
00:12:54,760 --> 00:12:56,345
זה פשוט הרעיון שעכשיו חשוב.

305
00:12:56,345 --> 00:12:57,720
אז זה מה שקורה כאן.

306
00:12:57,720 --> 00:13:02,690
אז כמובן, אם אתה עושה את סוגר t
0, שהוא סימון מערך,

307
00:13:02,690 --> 00:13:05,650
של course-- ולמען אמת, זה נראה
כאילו יש מערך לכאן,

308
00:13:05,650 --> 00:13:07,340
אבל עכשיו יש דבר המוזר הזה.

309
00:13:07,340 --> 00:13:11,160
יודע ששפת תכנות,
C, מציע לכם בתכונה זו,

310
00:13:11,160 --> 00:13:14,650
לפיו, גם אם לא הוא
מצביע, או s הנו מצביע,

311
00:13:14,650 --> 00:13:18,050
אתה עדיין יכול להשתמש בזה מוכר,
סוגר מרובע נוח

312
00:13:18,050 --> 00:13:22,520
הסימון ללכת לאלמנט הראשון,
או האלמנט השני, או כל אלמנט

313
00:13:22,520 --> 00:13:26,130
שהמצביע שמצביע
לכי, ככל הנראה, אותו

314
00:13:26,130 --> 00:13:29,410
הוא, כמו במקרה זה,
מצביע על כמה מערך.

315
00:13:29,410 --> 00:13:30,340
>> אז איך אנחנו יכולים לתקן את זה?

316
00:13:30,340 --> 00:13:33,660
למען האמת, זה המקום שבו יש לי
קצת מוחץ במבט ראשון.

317
00:13:33,660 --> 00:13:35,340
אבל כאן היא גרסה חדשה ומשופרת.

318
00:13:35,340 --> 00:13:37,460
>> אז קודם כל, אני מקבל
להיפטר מספריית CS50,

319
00:13:37,460 --> 00:13:41,170
רק כדי לחשוף שזה אכן
כוכב char, רק מילה נרדפת.

320
00:13:41,170 --> 00:13:43,540
ולא הוא גם כוכב char.

321
00:13:43,540 --> 00:13:48,290
אבל מה קורה ב
צד ימני של קו ש

322
00:13:48,290 --> 00:13:49,970
כאשר t מוקצה ערך?

323
00:13:49,970 --> 00:13:50,790
>> מהו malloc?

324
00:13:50,790 --> 00:13:51,630
מה זה strlen?

325
00:13:51,630 --> 00:13:52,547
מה הוא sizeof (char)?

326
00:13:52,547 --> 00:13:54,380
למה לעזאזל עושה את זה
שורת מבט כל כך מורכב?

327
00:13:54,380 --> 00:13:55,713
מה הוא עושה ברמה גבוהה?

328
00:13:55,713 --> 00:13:56,482

329
00:13:56,482 --> 00:13:57,440
מה זה אחסון בt?

330
00:13:57,440 --> 00:13:58,646
כן?

331
00:13:58,646 --> 00:14:01,104
קהל: זה הקצאה
כמות מסוימת של שטח זיכרון.

332
00:14:01,104 --> 00:14:03,032
זה לאחסון, אני מניח,
אותיות [לא ברור].

333
00:14:03,032 --> 00:14:04,032
>> דוד י מלאן: מושלם.

334
00:14:04,032 --> 00:14:04,540
מושלם.

335
00:14:04,540 --> 00:14:06,650
זה הקצאה מסוימת
כמות שטח זיכרון

336
00:14:06,650 --> 00:14:08,940
לאחסון, ככל הנראה, מכתבי עתיד.

337
00:14:08,940 --> 00:14:11,310
ובפרט, malloc
לכן חוזר מה?

338
00:14:11,310 --> 00:14:13,114

339
00:14:13,114 --> 00:14:14,851
>> קהל: חוזר [לא ברור]?

340
00:14:14,851 --> 00:14:15,850
דוד י מלאן: בדיוק.

341
00:14:15,850 --> 00:14:18,850
חוזר את הכתובת של זיכרון ש,
אשר היא דרך מפוארת לומר,

342
00:14:18,850 --> 00:14:21,640
מחזיר את הכתובת של
הבית הראשון של זיכרון ש.

343
00:14:21,640 --> 00:14:25,460
הנטל הוא עליי לזכור
כמה זיכרון אני ממש

344
00:14:25,460 --> 00:14:27,140
שהוקצה או ביקש malloc ל.

345
00:14:27,140 --> 00:14:28,384
>> עכשיו כמה זה?

346
00:14:28,384 --> 00:14:30,550
ובכן, למרות שיש
הרבה סוגריים כאן,

347
00:14:30,550 --> 00:14:32,970
malloc לוקח רק טיעון אחד.

348
00:14:32,970 --> 00:14:37,250
ואני מפרט strlen של ים, כדי לתת לי
לי בתים רבים כפי שיש בים,

349
00:14:37,250 --> 00:14:37,800
אבל להוסיף אחד.

350
00:14:37,800 --> 00:14:38,300
למה?

351
00:14:38,300 --> 00:14:39,030

352
00:14:39,030 --> 00:14:39,530
כן?

353
00:14:39,530 --> 00:14:40,840
>> קהל: הקו הנטוי 0.

354
00:14:40,840 --> 00:14:41,840
דוד י מלאן: בדיוק.

355
00:14:41,840 --> 00:14:43,423
אנחנו חייבים לעשות קצת ניהול משק בית.

356
00:14:43,423 --> 00:14:45,970
אז בגלל שיש קו נטוי
0, היינו טובים יותר לזכור את זה.

357
00:14:45,970 --> 00:14:47,310
אחרת, אנחנו הולכים
כדי ליצור מחרוזת ש

358
00:14:47,310 --> 00:14:49,170
אין ששליחות קטלנית מיוחדת.

359
00:14:49,170 --> 00:14:52,640
>> בינתיים, רק כדי להיות סופר
אנאלי, יש לי sizeof (char),

360
00:14:52,640 --> 00:14:55,730
רק למקרה שמישהו מפעיל
קוד לא על מכשיר CS50,

361
00:14:55,730 --> 00:14:58,220
אבל אולי במחשב אחר
לגמרי שבו תווים

362
00:14:58,220 --> 00:15:01,470
בייט אחד, על ידי אמנה, אך שני
בתים, או משהו יותר גדול מזה.

363
00:15:01,470 --> 00:15:04,490
זה רק כדי להיות סופר,
סופר התנגד לטעויות.

364
00:15:04,490 --> 00:15:06,940
למרות, במציאות, זה
כנראה הולך להיות 1.

365
00:15:06,940 --> 00:15:11,490
>> עכשיו, בינתיים, אני הולך קדימה ולהעתיק את
מחרוזת, סוגר לא שווה אני סוגר T S.

366
00:15:11,490 --> 00:15:14,962
ואני לדחות לשבוע שעבר
קוד מקור כדי לראות מה קורה.

367
00:15:14,962 --> 00:15:17,670
אבל ממסעדה המפתח, ו
סיבה שאני מכניס את הקוד כעת בירוק,

368
00:15:17,670 --> 00:15:22,520
משום שהשורה האחרון,
סוגר t 0 שווה toupper,

369
00:15:22,520 --> 00:15:25,230
יש ההשפעה של
ניצול שמחרוזת?

370
00:15:25,230 --> 00:15:26,960
t ו / או של?

371
00:15:26,960 --> 00:15:29,280

372
00:15:29,280 --> 00:15:30,580
שהשורה האחרונה של קוד.

373
00:15:30,580 --> 00:15:32,930

374
00:15:32,930 --> 00:15:35,560
>> רק חולצות, משום מה
קרה הפעם,

375
00:15:35,560 --> 00:15:41,500
אם אני מעט לבטל את הצעד האחרון,
מה שקרה הוא, כשאני קורא malloc,

376
00:15:41,500 --> 00:15:45,380
אני בעצם לקבל נתח של זיכרון
כי הוא באותו הגודל כמו המקורי,

377
00:15:45,380 --> 00:15:47,020
כי זה החשבון שעשיתי.

378
00:15:47,020 --> 00:15:50,920
אני אחסון בt כתובת
של נתח זה של זיכרון.

379
00:15:50,920 --> 00:15:53,370
למרות שזה נראה נחמד
ויפה, נחמד וריק,

380
00:15:53,370 --> 00:15:56,882
המציאות היא שיש, מה יהיה לנו
להמשיך לקרוא, ערכי זבל בפה.

381
00:15:56,882 --> 00:15:59,340
נתח זה של זיכרון אולי מאוד
גם היה בשימוש לפני,

382
00:15:59,340 --> 00:16:00,940
כמה שניות, לפני כמה דקות.

383
00:16:00,940 --> 00:16:04,410
אז בהחלט יכולים להיות שיש מספרים
או אותיות לשם, רק במקרה.

384
00:16:04,410 --> 00:16:08,580
אבל הם אינם תקפים, עד ש
עצמי לאכלס נתח זה של זיכרון

385
00:16:08,580 --> 00:16:12,510
עם תווים בפועל, כפי ש
לעשות שבלולאת for יש.

386
00:16:12,510 --> 00:16:13,180
בסדר?

387
00:16:13,180 --> 00:16:16,180
>> אז עכשיו, שיאו של
שלוש דוגמאות האלה

388
00:16:16,180 --> 00:16:20,730
שנשברו לכאורה הפעם האחרונה,
דוגמא החלפה זו, פונקציה זו

389
00:16:20,730 --> 00:16:23,670
עבד במובן
שהחליף וb.

390
00:16:23,670 --> 00:16:25,620
אבל זה לא עבד באיזה מובן אחר?

391
00:16:25,620 --> 00:16:27,616

392
00:16:27,616 --> 00:16:28,614
כן?

393
00:16:28,614 --> 00:16:29,612
>> קהל: [לא ברור].

394
00:16:29,612 --> 00:16:35,600

395
00:16:35,600 --> 00:16:36,700
>> דוד י מלאן: בדיוק.

396
00:16:36,700 --> 00:16:39,530
אם הייתי קורא לפונקציה זו
מanother-- למשל,

397
00:16:39,530 --> 00:16:42,870
מפונקציה כמו עיקרי, שבו
יש לי משתנה, x, y, כפי ש

398
00:16:42,870 --> 00:16:46,160
עשה בשבוע שעבר, אותו קוד,
ואני עובר בx, y

399
00:16:46,160 --> 00:16:49,860
כדי להחליף, ואז להתקשר Swap-- זה,
כמובן, היא הגרסה הנכונה

400
00:16:49,860 --> 00:16:52,220
זה מה שאנחנו עומדים
see-- זה לא עבד.

401
00:16:52,220 --> 00:16:53,770
אז מה הוא את התיקון?

402
00:16:53,770 --> 00:16:56,850
>> ובכן, כל כך פשוט להיות
ברור, תן לי ללכת קדימה

403
00:16:56,850 --> 00:17:05,450
and-- לתת לי שנייה אחת כאן, ותראה
אם אני יכול להראות לך את האחרון, ש

404
00:17:05,450 --> 00:17:12,464
יהיה in-- בואו נראה אם ​​אני יכול למצוא
אישור fast-- אמיתי זה, [לא ברור].

405
00:17:12,464 --> 00:17:18,440

406
00:17:18,440 --> 00:17:19,240
אישור, זה מה שיש.

407
00:17:19,240 --> 00:17:21,000
אז להתעלם מהפקודות אני רק הקלדה.

408
00:17:21,000 --> 00:17:23,780
אני רוצה את זה כדי לאחזר ב
הרגע האחרון ירושלים

409
00:17:23,780 --> 00:17:27,960
מעת האחרונה, ש
הוא התקשר עכשיו אין החלפה.

410
00:17:27,960 --> 00:17:30,200
>> אז לא להחליף מקום שבו
הפסקנו בפעם האחרונה,

411
00:17:30,200 --> 00:17:32,930
לפיו, אני אותחל
x 1 וy 2.

412
00:17:32,930 --> 00:17:35,840
אז אני קורא להחלפה, עובר ב1 ו -2.

413
00:17:35,840 --> 00:17:37,930
ולאחר מכן בפונקציה זו
עבד במובן מסוים,

414
00:17:37,930 --> 00:17:40,750
אבל אין לה קבע
השפעה על x, y.

415
00:17:40,750 --> 00:17:45,430
אז השאלה שעל הפרק היא, איך עכשיו
האם אנו באמת לתקן את הבעיה הזו?

416
00:17:45,430 --> 00:17:47,820
מהו הפתרון בהישג היד?

417
00:17:47,820 --> 00:17:53,150
>> ובכן, בswap.c, שהיא חדשה היום,
שם לב כמה הבדלים.

418
00:17:53,150 --> 00:17:54,700
x, y זהה.

419
00:17:54,700 --> 00:17:57,250
אבל מה הוא באופן ברור
שונה על שורת 25?

420
00:17:57,250 --> 00:17:58,880

421
00:17:58,880 --> 00:18:01,715
מה חדש שם, אם אתה זוכר
מה זה נראה כמו לפני שנייה?

422
00:18:01,715 --> 00:18:02,565
>> קהל: [לא ברור].

423
00:18:02,565 --> 00:18:03,440
>> דוד י מלאן: כן.

424
00:18:03,440 --> 00:18:06,680
אז סימן החיבור הוא יצירה חדשה
של תחביר לא רק בתכנית זו,

425
00:18:06,680 --> 00:18:08,560
אבל גם באופן כללי יותר בCS50.

426
00:18:08,560 --> 00:18:10,680
נכון להיום, אני לא חושב ש
אנחנו כבר ראינו דוגמאות

427
00:18:10,680 --> 00:18:14,070
או ממש דיבר עליהם בכל
פרט, אחר מאשר, אולי, מנע

428
00:18:14,070 --> 00:18:16,467
בסעיף, אמפרסנד כמו זה.

429
00:18:16,467 --> 00:18:19,300
ובכן, מתברר אמפרסנד הוא אחד
של החלקים האחרונים של תחביר החדש

430
00:18:19,300 --> 00:18:20,174
אנחנו הולכים ללמוד.

431
00:18:20,174 --> 00:18:23,500
כל פירוש הדבר הוא
כתובת של כמה משתנה.

432
00:18:23,500 --> 00:18:25,070
באיזה כתובת אין x לחיות?

433
00:18:25,070 --> 00:18:26,510
אבל מה כתובת אין y לחיות?

434
00:18:26,510 --> 00:18:28,700
כי אם
בעיה בסיסית לפני

435
00:18:28,700 --> 00:18:32,970
היה שx, y הועברו עכשיו
כעותקים, מה שאנחנו באמת רוצים לעשות

436
00:18:32,970 --> 00:18:38,780
הוא מספק החלפה עם כמו אוצר
המפה שמובילה למקום שבי x, y למעשה

437
00:18:38,780 --> 00:18:41,910
נמצא בזכרון RAM, כך ש
החלפה יכולה לעקוב אחר המפה ש

438
00:18:41,910 --> 00:18:47,760
וללכת לכל מקום בו x או y מסמן את המקום
ולשנות את הערכים בפועל 1 ו -2

439
00:18:47,760 --> 00:18:48,270
יש.

440
00:18:48,270 --> 00:18:50,710
>> אז החלפה צריכה להשתנות מעט מדי.

441
00:18:50,710 --> 00:18:53,760
ובמבט ראשון, כוח זה
נראה קצת דומה לכוכב char.

442
00:18:53,760 --> 00:18:54,850
ואכן זה הוא.

443
00:18:54,850 --> 00:18:59,635
אז הוא מצביע לאיזה סוג של נתונים,
המבוסס על חלק מודגש זה?

444
00:18:59,635 --> 00:19:00,810

445
00:19:00,810 --> 00:19:01,620
אז זה int.

446
00:19:01,620 --> 00:19:04,880
>> אז הוא כבר לא int,
זה הכתובת של int.

447
00:19:04,880 --> 00:19:07,910
ובאופן דומה, ב עכשיו הולך
להיות הכתובת של int.

448
00:19:07,910 --> 00:19:12,470
לכן, כאשר אני מכנה היום החלפה מהראשים,
אני לא הולך לתת לי החלפת 1 ו -2.

449
00:19:12,470 --> 00:19:15,540
אני הולך לתת לו כמו
שור ומשהו ושור ומשהו,

450
00:19:15,540 --> 00:19:19,820
שתי כתובות שיובילו
החלפה למקומות שלהם בפועל

451
00:19:19,820 --> 00:19:21,310
בזיכרון של המחשב שלי.

452
00:19:21,310 --> 00:19:25,580
>> אז עכשיו, יישום שנותר לי
צריך לשנות טיפה.

453
00:19:25,580 --> 00:19:28,650
מה שונה ברור עכשיו
בשלוש שורות קוד הללו?

454
00:19:28,650 --> 00:19:31,350
יש כוכבים הארורים האלה כל
המקום, בסדר?

455
00:19:31,350 --> 00:19:33,014
אז מה קורה כאן?

456
00:19:33,014 --> 00:19:33,514
כן?

457
00:19:33,514 --> 00:19:35,055
>> קהל: זה ברור [לא ברור].

458
00:19:35,055 --> 00:19:36,832

459
00:19:36,832 --> 00:19:37,990
>> דוד י מלאן: בדיוק.

460
00:19:37,990 --> 00:19:41,560
אז בcontext-- זה וזה לא היה
החלטת העיצוב הטובה ביותר, יש להודות,

461
00:19:41,560 --> 00:19:42,530
שנים לפני.

462
00:19:42,530 --> 00:19:45,110
בהקשר, שבו זה
רק שיש לך כוכב,

463
00:19:45,110 --> 00:19:48,240
ואין לך סוג הנתונים,
כמו int, מייד בצד השמאל,

464
00:19:48,240 --> 00:19:53,146
במקום שיש לך סימן שוויון, באופן ברור,
בהקשר זה, כשאתה אומר לככב,

465
00:19:53,146 --> 00:19:56,980
זה אומר ללכת ל
כתובת שהוא ב.

466
00:19:56,980 --> 00:19:58,870
בצע את מפת אוצר, אם אפשר לומר כך.

467
00:19:58,870 --> 00:20:01,720
>> ובינתיים, בשורה 37,
זה אומר את אותו הדבר.

468
00:20:01,720 --> 00:20:05,460
עבור לכתובה, ולשים את מה שיש?

469
00:20:05,460 --> 00:20:09,520
לא משנה מה הוא ב
מיקום שב מציין.

470
00:20:09,520 --> 00:20:10,980
במילים אחרות, ללכת לb.

471
00:20:10,980 --> 00:20:12,130
קבל ערך ש.

472
00:20:12,130 --> 00:20:15,620
עבור ול, לשוויון
לחתום, אופרטור ההשמה,

473
00:20:15,620 --> 00:20:17,010
לשים ערך שיש.

474
00:20:17,010 --> 00:20:19,272
>> באופן דומה, טמפ int הוא רק int.

475
00:20:19,272 --> 00:20:20,730
שום דבר לא צריך להשתנות על טמפ '.

476
00:20:20,730 --> 00:20:24,810
זה פשוט זכוכית חילוף מאננברג
לקצת חלב או מיץ תפוזים.

477
00:20:24,810 --> 00:20:27,630
אבל אני צריך לומר, ללכת לב.

478
00:20:27,630 --> 00:20:31,449
עבור ליעד וש
לשים את הערך בטמפ שם.

479
00:20:31,449 --> 00:20:32,490
אז מה שקורה לאחר מכן?

480
00:20:32,490 --> 00:20:36,540
כשאני בעצם קורא להחליף הפעם, אם
מגש ראשון זה כאן מייצג ראשי,

481
00:20:36,540 --> 00:20:42,270
מגש שני זה מייצג החלפה, כאשר
אני עובר x האמפרסנד וy האמפרסנד

482
00:20:42,270 --> 00:20:47,150
מהראשים להחלפה, רק שיהיה ברור,
מה היא קבלת מסגרת מחסנית זה?

483
00:20:47,150 --> 00:20:48,700

484
00:20:48,700 --> 00:20:49,200
כן?

485
00:20:49,200 --> 00:20:50,180
>> קהל: [לא ברור].

486
00:20:50,180 --> 00:20:51,180
דוד י מלאן: בדיוק.

487
00:20:51,180 --> 00:20:53,129
הכתובת של x ואת הכתובת של y.

488
00:20:53,129 --> 00:20:55,170
ואתה יכול לחשוב על אלה
כמו כתובות דואר.

489
00:20:55,170 --> 00:20:58,772
רחוב אוקספורד 33 ו35
רחוב אוקספורד, ואתה

490
00:20:58,772 --> 00:21:01,230
רוצה להעביר את שני בניינים
כי הם במקומות אלו.

491
00:21:01,230 --> 00:21:04,680
>> זה סוג של רעיון מגוחך,
אבל זה כל מה שאנחנו מתכוונים בכתובת.

492
00:21:04,680 --> 00:21:07,000
איפה בעולם יכול
אתה מוצא שני ints אלה?

493
00:21:07,000 --> 00:21:09,470
איפה בעולם אתה יכול
למצוא שני הבניינים האלה?

494
00:21:09,470 --> 00:21:15,170
אז אם סוף סוף, אחרי כל מה שאני הפעם
להיכנס לקוד המקור של היום ולקמפל

495
00:21:15,170 --> 00:21:22,110
./swap החלפה והריצה, סוף סוף, ל
פעם הראשונה שאנחנו בעצם רואים ש

496
00:21:22,110 --> 00:21:25,330
הערכים שלי יש אכן
כבר החליף בהצלחה.

497
00:21:25,330 --> 00:21:30,860
ועכשיו, אנחנו יכולים אפילו לקחת
פתק של ב, למשל, gdb זה.

498
00:21:30,860 --> 00:21:32,740
>> אז תן לי להיכנס לאותו הקובץ.

499
00:21:32,740 --> 00:21:35,010
תן לי ללכת קדימה ולהפעיל gdb של ./swap.

500
00:21:35,010 --> 00:21:36,590

501
00:21:36,590 --> 00:21:40,547
ועכשיו, בהחלפה, אני הולך ללכת
קדימה ולהגדיר נקודת הפסקה בראשים.

502
00:21:40,547 --> 00:21:42,630
ועכשיו אני הולך
קדימה ולהפעיל את התכנית.

503
00:21:42,630 --> 00:21:45,810
ועכשיו אנחנו רואים את הקוד שלי
עצר בקו זה.

504
00:21:45,810 --> 00:21:48,330
>> אם אני הולך קדימה והדפסה
x, מה אני צריך לראות כאן?

505
00:21:48,330 --> 00:21:49,314

506
00:21:49,314 --> 00:21:49,980
זו שאלה.

507
00:21:49,980 --> 00:21:51,030

508
00:21:51,030 --> 00:21:51,530
אומר שוב?

509
00:21:51,530 --> 00:21:52,295
>> קהל: [לא ברור].

510
00:21:52,295 --> 00:21:53,910
>> דוד י מלאן: אז
מספרים אקראיים, אולי.

511
00:21:53,910 --> 00:21:56,010
אולי אני מקבל מזל, וזה
נחמד ופשוט, כמו 0.

512
00:21:56,010 --> 00:21:57,230
אבל אולי זה חלק מהמספר אקראי.

513
00:21:57,230 --> 00:21:58,090
במקרה זה, יש לי מזל.

514
00:21:58,090 --> 00:21:59,030
זה קורה רק כדי להיות 0.

515
00:21:59,030 --> 00:22:00,780
אבל זה אכן מזל,
כי לא עד ש

516
00:22:00,780 --> 00:22:06,280
הקלד הבא ולאחר מכן x ההדפסה יש ש
שורת קוד, שורת 19, הוצאה להורג.

517
00:22:06,280 --> 00:22:10,942
>> בינתיים, אם אני מקליד הבא שוב, ו
עכשיו להדפיס את y, אני הולך לראות 2.

518
00:22:10,942 --> 00:22:13,900
עכשיו, אם אני מקליד הבא, זה הולך
לקבל קצת מבלבל, כי עכשיו,

519
00:22:13,900 --> 00:22:17,250
printf עומד להופיע על
המסך, כפי שהוא עשה. x הוא 1.

520
00:22:17,250 --> 00:22:18,606
>> בואו נעשה את זה שוב.

521
00:22:18,606 --> 00:22:20,480
ועכשיו, הנה שבו
תתחיל להיות מעניין.

522
00:22:20,480 --> 00:22:21,580

523
00:22:21,580 --> 00:22:26,580
לפני שאני קורא להחלפה או אפילו צעד
לתוך זה, בואו ניקח הצצה קטנה.

524
00:22:26,580 --> 00:22:28,980
x הוא, שוב, 1.

525
00:22:28,980 --> 00:22:33,240
Y הוא, כמובן, את שפיות מהירה
לבדוק, 2, ולכן לא קשה שם.

526
00:22:33,240 --> 00:22:35,740
אבל מה הוא x אמפרסנד?

527
00:22:35,740 --> 00:22:36,760

528
00:22:36,760 --> 00:22:39,350
תשובה, זה סוג של מגניב מבט.

529
00:22:39,350 --> 00:22:43,500
אבל כוכב int בסוגריים הוא רק
דרכו של התוצר המקומי הגולמי של אומר את זה היא כתובת.

530
00:22:43,500 --> 00:22:48,290
זה לא int, זה מצביע ל
int, או הידוע גם כתובת.

531
00:22:48,290 --> 00:22:49,742
>> מה זה הדבר המטורף הזה?

532
00:22:49,742 --> 00:22:51,825
אנחנו אף פעם לא ראינו משהו
כמו שדי לפני.

533
00:22:51,825 --> 00:22:53,650

534
00:22:53,650 --> 00:22:58,120
אז זה הכתובת במחשב שלי
לזכרו של שבו x קורה לחיות.

535
00:22:58,120 --> 00:22:59,040
זה שור ומשהו.

536
00:22:59,040 --> 00:23:01,290
וזה, בכנות, למה
אני כבר התחלתי לצייר חצים,

537
00:23:01,290 --> 00:23:03,340
במקום מספרים,
בגלל שבאמת אכפת לו

538
00:23:03,340 --> 00:23:06,890
שint שלך הוא במסוים
כתובת זה שגדול.

539
00:23:06,890 --> 00:23:12,160
אבל bffff0c4, כל אלה הם
אכן ספרות הקסדצימלי,

540
00:23:12,160 --> 00:23:13,720
שהם 0 דרך f.

541
00:23:13,720 --> 00:23:16,590
>> אז אנחנו לא הולכים להתעכב יותר
ארוך על מה הדברים האלה.

542
00:23:16,590 --> 00:23:19,400
אבל אם אני מדפיס את y,
כמובן, אני רואה 2.

543
00:23:19,400 --> 00:23:22,440
אבל y האמפרסנד, אני רואה את הכתובת הזו.

544
00:23:22,440 --> 00:23:26,527
והודעה, לסקרן,
כמה רחוק הם x, y?

545
00:23:26,527 --> 00:23:27,985
אתה יכול להתעלם ביותר של הכתובת.

546
00:23:27,985 --> 00:23:29,330

547
00:23:29,330 --> 00:23:29,920
ארבעה בתים.

548
00:23:29,920 --> 00:23:33,510
וזה עולה בקנה אחד עם שלנו
מוקדם יותר טוען שעד כמה גדול הוא int?

549
00:23:33,510 --> 00:23:34,130
ארבעה בתים.

550
00:23:34,130 --> 00:23:37,420
אז זה נראה כמו ההזדנבות של כל דבר
יפה, כמו שאתה יכול לקוות, בזיכרון.

551
00:23:37,420 --> 00:23:40,010
>> אז עכשיו, בואו פשוט להריץ קדימה
בסופו של הסיפור הזה.

552
00:23:40,010 --> 00:23:43,290
בואו נלך קדימה והקלידו צעד,
לצלול לתוך פונקצית החלפה.

553
00:23:43,290 --> 00:23:46,880
עכשיו שימו לב, אם אני מקליד, זה
זהה לכתובתו של x.

554
00:23:46,880 --> 00:23:52,130
אם אני מקליד ב, זה זהה
לכתובתו של y.

555
00:23:52,130 --> 00:23:57,020
אז מה כדאי לי לראות אם אני
אומרים, גש לכתובת?

556
00:23:57,020 --> 00:23:58,120
אז להדפיס לככב.

557
00:23:58,120 --> 00:24:00,130
אז כוכב פירושו ללכת לשם, בהקשר זה.

558
00:24:00,130 --> 00:24:02,730
אמפרסנד אומר מה הכתובת של.

559
00:24:02,730 --> 00:24:05,000
אז כוכב אמצעי 1.

560
00:24:05,000 --> 00:24:09,590
וכוכב הדפסה ב נותן לי 2.

561
00:24:09,590 --> 00:24:15,750
>> והרשה לי להניח, לרגע,
כי לפחות את הקוד ש

562
00:24:15,750 --> 00:24:18,950
ממשיך לבצע עכשיו יכול להיות
מנומק באמצעות בדרך זו.

563
00:24:18,950 --> 00:24:21,150
אבל אנחנו לבקר את הרעיון הזה לפני זמן רב.

564
00:24:21,150 --> 00:24:23,850
אז גרסה זו של החלפה
נכון עכשיו ומאפשר לי

565
00:24:23,850 --> 00:24:26,650
שלנו להחליף סוג נתונים המסוים הזה.

566
00:24:26,650 --> 00:24:29,120
>> אז כל שאלות אז על החלפה?

567
00:24:29,120 --> 00:24:29,890
על כוכב?

568
00:24:29,890 --> 00:24:30,690
על כתובת של?

569
00:24:30,690 --> 00:24:33,270
ואתה תראה, עם
בעיה להגדיר 4, סוג של,

570
00:24:33,270 --> 00:24:37,310
אבל בעיה להגדיר 5, בהחלט, איך אלה
הדברים שימושיים ולקבל הרבה יותר

571
00:24:37,310 --> 00:24:39,584
בנוח איתם, כתוצאה.

572
00:24:39,584 --> 00:24:40,430
שום דבר בכלל?

573
00:24:40,430 --> 00:24:40,930
בסדר.

574
00:24:40,930 --> 00:24:44,350
אז malloc שוב הוא,, פונקציה זו
שרק מקצה זיכרון, זיכרון

575
00:24:44,350 --> 00:24:45,330
הקצאה.

576
00:24:45,330 --> 00:24:47,024
ולמה זה שימושי?

577
00:24:47,024 --> 00:24:48,940
ובכן, כל הזמן הזה,
אתה כבר משתמש malloc.

578
00:24:48,940 --> 00:24:52,230
אם אתה מחשיב עכשיו איך
getString עבודות, מן הסתם, זה

579
00:24:52,230 --> 00:24:56,140
היה שואל מישהו לנתח של
זיכרון, בכל עת המשתמש מקליד מחרוזת

580
00:24:56,140 --> 00:24:59,040
ב, כי אנחנו בהחלט
לא ידע, כצוות CS50,

581
00:24:59,040 --> 00:25:02,710
עד כמה גדול המיתרים הללו שבני אדם
הולכים להקליד יכול להיות.

582
00:25:02,710 --> 00:25:07,910
>> אז בואו, בפעם הראשונה, מתחילים
לקלף בחזרה איך עובד ספריית CS50,

583
00:25:07,910 --> 00:25:10,990
בדרך של כמה דוגמאות
שיוביל אותנו לשם.

584
00:25:10,990 --> 00:25:15,300
אז אם אני פותח את gedit
ולפתוח scanf 0,

585
00:25:15,300 --> 00:25:17,055
אנחנו הולכים לראות את הקוד הבא.

586
00:25:17,055 --> 00:25:18,720

587
00:25:18,720 --> 00:25:23,530
Scanf 0, זמין באתר האינטרנט ל
היום, יש מספר קטן יחסית של שורות קוד

588
00:25:23,530 --> 00:25:25,351
כאן, 14 דרך 20.

589
00:25:25,351 --> 00:25:26,600
ובואו נראה מה הוא עושה.

590
00:25:26,600 --> 00:25:28,920
היא מצהירה int x נקרא,.

591
00:25:28,920 --> 00:25:30,850
זה אומר מספר כמו משהו, בבקשה.

592
00:25:30,850 --> 00:25:33,940
ועכשיו זה אומר, אני% scanf, וx.

593
00:25:33,940 --> 00:25:35,620
אז יש כל מיני דברים חדשים שיש.

594
00:25:35,620 --> 00:25:38,420
>> אבל scanf, אתה יכול סוג של חושב
נכון להיפוכו של printf.

595
00:25:38,420 --> 00:25:40,090
printf, כמובן, הדפסים למסך.

596
00:25:40,090 --> 00:25:44,410
סוג scanf של סריקות מהמשתמש של
מקלדת משהו שהוא או היא הוקלדה.

597
00:25:44,410 --> 00:25:46,550
>> היא i% בדיוק כמו printf.

598
00:25:46,550 --> 00:25:49,410
משמעות הדבר היא לצפות
משתמש להקליד int.

599
00:25:49,410 --> 00:25:52,820
ועכשיו, למה אתה חושב שאני
יכול להיות שעובר scanf & x?

600
00:25:52,820 --> 00:25:54,030

601
00:25:54,030 --> 00:25:57,770
אם המטרה בחיים של scanf
הוא לקבל משהו מהמשתמש,

602
00:25:57,770 --> 00:26:02,480
מהי המשמעות של
העברתו, וx, עכשיו?

603
00:26:02,480 --> 00:26:02,980
כן?

604
00:26:02,980 --> 00:26:03,896
>> קהל: [לא ברור].

605
00:26:03,896 --> 00:26:05,540

606
00:26:05,540 --> 00:26:06,540
דוד י מלאן: בדיוק.

607
00:26:06,540 --> 00:26:12,900
לא משנה מה אני, האדם, להקליד, הקלט שלי
הוא הולך להיות נשמר במיקום זה.

608
00:26:12,900 --> 00:26:17,660
זה לא מספיק, זוכר, רק
לעבור בx, משום שראינו כבר,

609
00:26:17,660 --> 00:26:21,630
כל פעם שאתה עובר רק משתנה גלם,
כמו int, לתפקיד אחר,

610
00:26:21,630 --> 00:26:25,640
בטוח, זה יכול לשנות את זה
משתנה, אבל לא באופן קבוע.

611
00:26:25,640 --> 00:26:27,360
זה לא יכול להיות השפעה על ראשי.

612
00:26:27,360 --> 00:26:29,420
זה יכול לשנות רק העותק המקומי שלה.

613
00:26:29,420 --> 00:26:32,560
אבל אם, במקום זאת, אתה לא
תן לי את int בפועל,

614
00:26:32,560 --> 00:26:36,640
אבל אתה נותן לי כיוונים ל
int ש, אני עכשיו, להיות scanf,

615
00:26:36,640 --> 00:26:41,050
בוודאי, אני יכול לעקוב אחר ש
לטפל ולשים מספר שם

616
00:26:41,050 --> 00:26:43,280
אז יש לך גישה אליו גם כן.

617
00:26:43,280 --> 00:26:45,120
>> לכן, כאשר אני מפעיל תכנית זו, בואו נראה.

618
00:26:45,120 --> 00:26:49,660
הפוך scanf 0 לוכסן נקודה, scanf 0.

619
00:26:49,660 --> 00:26:54,030
ואם אני עכשיו להקליד מספר
כמו 50, תודה על 50.

620
00:26:54,030 --> 00:26:58,150
אם אני עכשיו להקליד מספר כמו
1 שלילי, ל1 השלילי.

621
00:26:58,150 --> 00:27:04,200
עכשיו אני מקליד מספר כמו 1.5, HM.

622
00:27:04,200 --> 00:27:06,030
מדוע התכנית שלי מתעלמת ממני?

623
00:27:06,030 --> 00:27:07,300

624
00:27:07,300 --> 00:27:09,880
ובכן, בגלל שפשוט, אמרתי לי
זה לצפות int בלבד.

625
00:27:09,880 --> 00:27:10,380
בסדר.

626
00:27:10,380 --> 00:27:11,630
אז זה גרסה אחת של זה.

627
00:27:11,630 --> 00:27:16,600
בואו ניקח את דברים ברמה גבוהה ו
מציע שזה לא טוב.

628
00:27:16,600 --> 00:27:20,530
וכאן טמון דוגמא פשוטה מאוד
איך אנחנו יכולים להתחיל כתיבת קוד

629
00:27:20,530 --> 00:27:24,450
שאנשים אחרים יכולים לנצל או
להתפשר על ידי עושה דברים רעים.

630
00:27:24,450 --> 00:27:28,336
אז שורה 16, כל כך דומה
ברוחו ללפני,

631
00:27:28,336 --> 00:27:29,960
אבל אני לא הכריז עליו int זה זמן.

632
00:27:29,960 --> 00:27:32,970
אני מכריז כוכב char זה, aka מחרוזת.

633
00:27:32,970 --> 00:27:35,190
>> אבל מה זה באמת אומר?

634
00:27:35,190 --> 00:27:38,790
אז אם אני לא לציין address-- ו
אני קורא לזה באופן שרירותי, חיץ,

635
00:27:38,790 --> 00:27:43,370
אבל אני יכול לקרוא לזה זה, להיות simple--
ואז אני עושה את זה, אסביר לי,

636
00:27:43,370 --> 00:27:48,630
אם אתה יכול, על בסיס הקודם
היגיון, מה הוא עושה scanf בשורה 18,

637
00:27:48,630 --> 00:27:55,000
אם% s לעבור וחיץ,
אשר היא כתובת?

638
00:27:55,000 --> 00:27:58,210
מה הוא scanf, אם תחיל את
בדיוק באותו היגיון כמו גרסה 0,

639
00:27:58,210 --> 00:28:00,640
הולך לנסות לעשות כאן, כאשר
משהו משתמש מקליד?

640
00:28:00,640 --> 00:28:02,630

641
00:28:02,630 --> 00:28:03,409
כן?

642
00:28:03,409 --> 00:28:04,407
>> קהל: [לא ברור].

643
00:28:04,407 --> 00:28:07,401

644
00:28:07,401 --> 00:28:08,890
>> דוד י מלאן: בדיוק.

645
00:28:08,890 --> 00:28:11,577
Scanf, על ידי ההיגיון קודם לכן,
הוא הולך לקחת את המחרוזת

646
00:28:11,577 --> 00:28:13,410
שמוקלד האנושית
in-- זה עכשיו מחרוזת,

647
00:28:13,410 --> 00:28:15,790
זה לא מספר, ככל הנראה,
אם הוא או היא cooperates--

648
00:28:15,790 --> 00:28:19,310
וזה הולך לנסות לשים את זה
מחרוזת בזיכרון בכל מה כתובת

649
00:28:19,310 --> 00:28:20,340
חיץ מציין.

650
00:28:20,340 --> 00:28:23,870
וזה נהדר, כי חיץ
נועד אכן להיות כתובת.

651
00:28:23,870 --> 00:28:30,470
>> אבל אני טוען שתכנית זו היא מרכבה ב
דרך מאוד רצינית, כי מה הוא הערך

652
00:28:30,470 --> 00:28:31,330
חיץ כברירת מחדל?

653
00:28:31,330 --> 00:28:33,380

654
00:28:33,380 --> 00:28:34,790
מה יש לי אותחל ל?

655
00:28:34,790 --> 00:28:35,770
מה נתח של זיכרון?

656
00:28:35,770 --> 00:28:37,480

657
00:28:37,480 --> 00:28:38,620
יש לי לא, נכון?

658
00:28:38,620 --> 00:28:42,265
>> אז למרות שאני כבר הוקצה
כוכב char זה נקרא כבר לא של,

659
00:28:42,265 --> 00:28:48,030
זה נקרא במקום, buffer-- כך
בואו נצייר את שמו של משתנה

660
00:28:48,030 --> 00:28:53,380
עכשיו כbuffer-- אם יש לי לא
נקרא getString או malloc כאן,

661
00:28:53,380 --> 00:28:56,030
שלמעשה אומר ש
חיץ הוא רק חלק ערך זבל.

662
00:28:56,030 --> 00:28:57,030
>> עכשיו מה זה אומר?

663
00:28:57,030 --> 00:29:00,220
זה אומר שיש לי אמר לי scanf
לצפות מחרוזת מהמשתמש.

664
00:29:00,220 --> 00:29:01,300
ואתם יודעים מה?

665
00:29:01,300 --> 00:29:03,883
לא משנה מה הדבר הזה מצביע
to-- ואני מצייר סימן שאלה,

666
00:29:03,883 --> 00:29:07,060
אבל במציאות, זה הולך להיות
משהו כמו OX1, 2, 3, נכון?

667
00:29:07,060 --> 00:29:10,730
זה חלק מהערך מזויף שרק
במקרה היה שם לפני.

668
00:29:10,730 --> 00:29:13,440
אז במילים אחרות, זה
כאילו חיץ הוא רק

669
00:29:13,440 --> 00:29:16,180
מצביע על משהו בזיכרון.

670
00:29:16,180 --> 00:29:17,610
אין לי מושג מה.

671
00:29:17,610 --> 00:29:24,130
>> אז אם אני מקליד בגייב עכשיו, זה הולך
כדי לנסות לשים g--b-e / 0 שם.

672
00:29:24,130 --> 00:29:25,530
אבל מי יודע מה זה?

673
00:29:25,530 --> 00:29:27,480
ובעבר, כל
זמן שניסינו לגעת

674
00:29:27,480 --> 00:29:29,770
זיכרון שאינו שייך
לנו, מה קרה?

675
00:29:29,770 --> 00:29:31,020

676
00:29:31,020 --> 00:29:32,870
או כמעט בכל פעם.

677
00:29:32,870 --> 00:29:34,310
אשמת פילוח, נכון?

678
00:29:34,310 --> 00:29:37,829
>> החץ הזה, אין לי מושג איפה זה
הצבעה. זה רק חלק ערך אקראי.

679
00:29:37,829 --> 00:29:40,370
וכמובן, אם אתה מפרש
ערך אקראי ככתובת,

680
00:29:40,370 --> 00:29:42,610
אתה הולך ללכת ל
כמה יעד אקראי.

681
00:29:42,610 --> 00:29:46,810
אז אכן אולי גייב התרסקות
התכנית שלי במקרה הזה כאן.

682
00:29:46,810 --> 00:29:50,600
>> אז מה אנחנו יכולים לעשות את זה כמעט כמו רע?

683
00:29:50,600 --> 00:29:52,660
חשוב על זה שלישי ו
הדוגמא האחרונה של scanf.

684
00:29:52,660 --> 00:29:53,890

685
00:29:53,890 --> 00:29:56,870
גרסה זו היא טובה יותר באיזה מובן?

686
00:29:56,870 --> 00:29:57,990

687
00:29:57,990 --> 00:30:01,400
אם אתה חש בנוח עם
בעיה קודמת, זה טוב יותר.

688
00:30:01,400 --> 00:30:02,250
למה?

689
00:30:02,250 --> 00:30:03,250
>> קהל: [לא ברור].

690
00:30:03,250 --> 00:30:06,235

691
00:30:06,235 --> 00:30:07,110
דוד י מלאן: טוב.

692
00:30:07,110 --> 00:30:09,970
אז המקרה הזה של קו 16
הוא טוב יותר, במובן

693
00:30:09,970 --> 00:30:12,030
שאנחנו באופן מפורש
הקצאת חלק זיכרון.

694
00:30:12,030 --> 00:30:14,190
אנחנו לא באמצעות malloc,
אנחנו משתמשים בשבוע 2

695
00:30:14,190 --> 00:30:16,060
גישה של רק הגדרה של מערך.

696
00:30:16,060 --> 00:30:18,130
ושאמרנו בעבר כי מחרוזת
הוא פשוט מערך של תווים,

697
00:30:18,130 --> 00:30:19,690
אז זה לגיטימי לחלוטין.

698
00:30:19,690 --> 00:30:22,910
אבל זה, כמובן, כ
שים לב שאתה, גודל קבוע, 16.

699
00:30:22,910 --> 00:30:25,440
>> אז תכנית זו היא
בטוח לחלוטין, אם אני מקליד

700
00:30:25,440 --> 00:30:29,760
במחרוזות תווים אחת, שני אופי
מחרוזות, 15 מחרוזות תווים.

701
00:30:29,760 --> 00:30:34,970
אבל ברגע שאני מתחיל להקליד 16,
17, 18, 1,000 מחרוזות תווים,

702
00:30:34,970 --> 00:30:37,390
שבו היא המחרוזת שהולכת בסופו?

703
00:30:37,390 --> 00:30:39,570
זה הולך בסופו של חלקו כאן.

704
00:30:39,570 --> 00:30:42,820
אבל אז מי יודע מה עוד
הוא מעבר לגבולות

705
00:30:42,820 --> 00:30:44,270
של מערך המסוים הזה?

706
00:30:44,270 --> 00:30:48,015
>> זה כאילו שיש לי
הכריז 16 תיבות כאן.

707
00:30:48,015 --> 00:30:49,300

708
00:30:49,300 --> 00:30:52,690
אז במקום להוציא את כל 16, אנחנו
רק להעמיד פנים שאני נמשך 16.

709
00:30:52,690 --> 00:30:56,540
אבל אם אני לאחר מכן נסה לקרוא מחרוזת
זה עוד הרבה זמן, כמו 50 תווים,

710
00:30:56,540 --> 00:31:01,270
אני הולך להתחיל לשים
, b, c, d, x, y, z.

711
00:31:01,270 --> 00:31:04,916
וזה הוא ככל הנראה
כמה מקטע זיכרון אחר

712
00:31:04,916 --> 00:31:06,790
כי, שוב, עלול לגרום
התכנית שלי לקרוס,

713
00:31:06,790 --> 00:31:10,600
כי אני כבר לא ביקשתי
כל דבר יותר מסתם 16 בתים.

714
00:31:10,600 --> 00:31:12,260
>> אז למי אכפת?

715
00:31:12,260 --> 00:31:13,880
ובכן, הנה ספריית CS50.

716
00:31:13,880 --> 00:31:17,220
וביותר לכך הוא פשוט
כמו הוראות למעלה.

717
00:31:17,220 --> 00:31:21,670
ספריית CS50, כל הזמן הזה,
יש לו את הקו הזה בשורה 52.

718
00:31:21,670 --> 00:31:23,680
ראינו typedef, או
תוכל לראות typedef

719
00:31:23,680 --> 00:31:27,930
בpset 4, שרק יוצר
מילה נרדפת לפי הכוכבים char יכולים להיות יותר

720
00:31:27,930 --> 00:31:29,290
פשוט מכונה מחרוזת.

721
00:31:29,290 --> 00:31:31,540
אז זה אחד
כמה גלגלים עזר

722
00:31:31,540 --> 00:31:34,120
אנחנו השתמשנו בחשאי מתחת למכסת המנוע.

723
00:31:34,120 --> 00:31:36,490
>> בינתיים, הנה הפונקציה, getchar.

724
00:31:36,490 --> 00:31:38,190
עכשיו כנראה, אין גוף אליו.

725
00:31:38,190 --> 00:31:40,273
ולמעשה, אם אני שומר
גלילה, אני לא ממש

726
00:31:40,273 --> 00:31:42,080
לראות את כל יישומים
של פונקציות אלה.

727
00:31:42,080 --> 00:31:43,140

728
00:31:43,140 --> 00:31:45,516
כבדיקת שפיות, למה זה?

729
00:31:45,516 --> 00:31:46,795
>> קהל: [לא ברור].

730
00:31:46,795 --> 00:31:47,670
דוד י מלאן: כן.

731
00:31:47,670 --> 00:31:48,950
אז זה בקובץ הכותרת.

732
00:31:48,950 --> 00:31:52,520
וקבצי כותרת מכילים אב טיפוס,
ועוד כמה דברים אחרים, כך נראה,

733
00:31:52,520 --> 00:31:53,780
כמו typedefs.

734
00:31:53,780 --> 00:31:56,910
אבל בCS50.c, שיש לנו
אף פעם לא נתתי לך על הסף,

735
00:31:56,910 --> 00:32:02,100
אבל כבר במכשיר CS50 כל
הפעם, עמוק בתוך התיקיות שלה,

736
00:32:02,100 --> 00:32:04,990
שם לב שיש כל
חבורה של פונקציות בכאן.

737
00:32:04,990 --> 00:32:06,720
>> למעשה, בואו לגלול למטה.

738
00:32:06,720 --> 00:32:08,810
בואו נתעלם רובם, לעת עתה.

739
00:32:08,810 --> 00:32:12,670
אבל לגלול למטה כדי getInt
ולראות איך getInt עובד.

740
00:32:12,670 --> 00:32:13,890
אז הנה getInt.

741
00:32:13,890 --> 00:32:17,727
ואם אי פעם באמת היה אכפת לך איך להגיע
int עובד, כאן הוא התיעוד שלה.

742
00:32:17,727 --> 00:32:19,560
ובין הדברים
זה אומר שזה אומר לך

743
00:32:19,560 --> 00:32:21,340
מה הטווחים של ערכים שהיא יכולה לחזור.

744
00:32:21,340 --> 00:32:24,400
זה בעצם שלילי של 2 מליארד
ל2 חיוביים מיליארדים, פלוס מינוס.

745
00:32:24,400 --> 00:32:26,420
>> ומתברר, כל זה
זמן, למרות שאנחנו אף פעם לא

746
00:32:26,420 --> 00:32:28,570
היה לך לבדוק את זה,
אם משהו משתבש,

747
00:32:28,570 --> 00:32:30,680
מתברר שכל
הפעם, יש getInt

748
00:32:30,680 --> 00:32:33,600
כבר חוזר מיוחד
קבוע, לא ריק,

749
00:32:33,600 --> 00:32:36,760
אלא int_max, שהוא
האמנה רק של מתכנת.

750
00:32:36,760 --> 00:32:38,846
זה אומר שכאן הוא ערך מיוחד.

751
00:32:38,846 --> 00:32:41,470
הקפד לבדוק את זה, רק
במקרה שמשהו משתבש.

752
00:32:41,470 --> 00:32:43,261
אבל אנחנו אף פעם לא הפרענו לי
עם כי עד כה,

753
00:32:43,261 --> 00:32:45,200
כי שוב, זה
נועד לפשט.

754
00:32:45,200 --> 00:32:46,950
>> אבל איך getInt מיושם?

755
00:32:46,950 --> 00:32:48,450
ובכן, אחד, זה לא לוקח ארגומנטים.

756
00:32:48,450 --> 00:32:49,390
אנחנו יודעים את זה.

757
00:32:49,390 --> 00:32:50,820
זה מחזיר int.

758
00:32:50,820 --> 00:32:51,950
אנחנו יודעים את זה.

759
00:32:51,950 --> 00:32:54,460
אז איך זה עובד מתחת למכסת המנוע?

760
00:32:54,460 --> 00:32:58,290
>> אז יש כנראה אינסופי
לולאה, לפחות את המראה של אחד.

761
00:32:58,290 --> 00:33:00,290
שים לב שאנו משתמשים getString.

762
00:33:00,290 --> 00:33:04,000
אז זה מעניין. getInt
קוראת הפונקציה שלנו, getString.

763
00:33:04,000 --> 00:33:05,645
ועכשיו למה זה עלול להיות המקרה?

764
00:33:05,645 --> 00:33:07,400

765
00:33:07,400 --> 00:33:09,842
למה אני מתגונן
כאן בשורה 165?

766
00:33:09,842 --> 00:33:11,390

767
00:33:11,390 --> 00:33:15,639
מה יכול לקרות בקנה
164, רק שיהיה ברור?

768
00:33:15,639 --> 00:33:16,930
זה את אותה תשובה כמו קודם.

769
00:33:16,930 --> 00:33:18,660

770
00:33:18,660 --> 00:33:20,089
יכול להיות רק מתוך זיכרון.

771
00:33:20,089 --> 00:33:23,130
משהו משתבש עם getString,
אנחנו חייבים להיות מסוגלים להתמודד עם זה.

772
00:33:23,130 --> 00:33:27,070
והסיבה שאני לא אחזיר null הוא
כי, מבחינה טכנית, null הוא מצביע.

773
00:33:27,070 --> 00:33:29,120
getInt יש לחזור int.

774
00:33:29,120 --> 00:33:31,060
אז יש לי באופן שרירותי
החליט, בעצם,

775
00:33:31,060 --> 00:33:34,600
כי 2 מיליארדים, פחות או יותר, הוא הולך
להיות ערך מיוחד שאני אף פעם לא יכול

776
00:33:34,600 --> 00:33:35,970
למעשה לקבל מהמשתמש.

777
00:33:35,970 --> 00:33:39,930
זה רק ערך אחד אני הולך
לבזבז לייצג קוד שגיאה.

778
00:33:39,930 --> 00:33:41,540
>> אז עכשיו, דברים לקבל קצת מפואר.

779
00:33:41,540 --> 00:33:44,670
וזה לא ממש את אותו התפקיד
כמו קודם, אבל זה דומה מאוד.

780
00:33:44,670 --> 00:33:50,120
אז שם לב, אני מצהיר כאן, בקו
172, שני n int וג char.

781
00:33:50,120 --> 00:33:53,600
ואז אני משתמש בשורה פאנקי זה,
sscanf, שמתברר

782
00:33:53,600 --> 00:33:55,990
אינו סורק מחרוזת מהמקלדת.

783
00:33:55,990 --> 00:33:59,226
זה עומד מחרוזת קיימות ש
המשתמש כבר הקליד ב.

784
00:33:59,226 --> 00:34:02,100
אז אני כבר נקראתי getString, ש
משמעות הדבר היא שיש לי מחרוזת בזיכרון.

785
00:34:02,100 --> 00:34:05,020
sscanf הוא מה שהיית
לקרוא לפונקצית ניתוח.

786
00:34:05,020 --> 00:34:07,760
זה נראה במחרוזת יש לי
הקליד ב, תו אחרי תו,

787
00:34:07,760 --> 00:34:09,250
ועושה משהו מועיל.

788
00:34:09,250 --> 00:34:10,969
המחרוזת שמאוחסן בקו.

789
00:34:10,969 --> 00:34:13,560
ואני יודע שרק על ידי הולך
לגבות כאן ואומר, אוי, אישור,

790
00:34:13,560 --> 00:34:15,143
אני קראתי לזה לא של הזמן הזה, אבל קו.

791
00:34:15,143 --> 00:34:15,989

792
00:34:15,989 --> 00:34:18,080
>> ועכשיו זה קצת שונה.

793
00:34:18,080 --> 00:34:22,480
אבל זה למעשה אומר, מסיבות
אנחנו מעט ננפנף בידות שלנו בימינו,

794
00:34:22,480 --> 00:34:26,070
שאנחנו בודקים ל
לראות אם משתמש הקליד ב

795
00:34:26,070 --> 00:34:29,909
וint ואולי דמות אחרת.

796
00:34:29,909 --> 00:34:33,610
אם משתמש הקליד בint, זה
הולך להיות מאוחסן בn, כי אני

797
00:34:33,610 --> 00:34:36,739
לעבור את זה על ידי כתובת,
טריק חדש שראינו היום.

798
00:34:36,739 --> 00:34:41,570
אם המשתמש גם הקלדה
ב123x כמו, x ש

799
00:34:41,570 --> 00:34:45,060
הוא הולך בסופו של
מכתב בתו ג.

800
00:34:45,060 --> 00:34:48,739
>> עכשיו מתברר sscanf ש
יגיד לי, בתבונה,

801
00:34:48,739 --> 00:34:54,750
כמה משתנים היה sscanf
בהצלחה מסוגלת למלא.

802
00:34:54,750 --> 00:34:58,770
אז לפי ההיגיון הזה, אם הפונקציה
אני מיישם הוא getInt,

803
00:34:58,770 --> 00:35:00,900
אבל אני בודק,
פוטנציאל, עבור המשתמש

804
00:35:00,900 --> 00:35:04,190
להקלדה בint
ואחריו משהו אחר,

805
00:35:04,190 --> 00:35:08,580
מה אני רוצה sscanf של
ערך החזרה באמת להיות?

806
00:35:08,580 --> 00:35:10,950
אם המטרה היא להגיע
רק int מהמשתמש?

807
00:35:10,950 --> 00:35:13,980

808
00:35:13,980 --> 00:35:19,300
>> אז אם sscanf חוזר
2, מה זה אומר?

809
00:35:19,300 --> 00:35:21,660
משתמש הקליד ב
משהו כמו, פשוטו כמשמעו,

810
00:35:21,660 --> 00:35:24,770
123x, וזה רק שטויות.

811
00:35:24,770 --> 00:35:27,490
זה מצב שגיאה, ו
אני רוצה לבדוק את זה.

812
00:35:27,490 --> 00:35:32,960
>> אז אם משתמש מקליד את זה, על ידי
ההיגיון הזה, מה עושה sscanf לחזור,

813
00:35:32,960 --> 00:35:33,740
היית אומר?

814
00:35:33,740 --> 00:35:35,070

815
00:35:35,070 --> 00:35:39,130
אז זה הולך לחזור 2, כי
123 הוא הולכים לכאן,

816
00:35:39,130 --> 00:35:41,580
וx הולך בסופו של כאן.

817
00:35:41,580 --> 00:35:43,970
אבל אני לא רוצה x כדי לקבל מולא.

818
00:35:43,970 --> 00:35:48,580
אני רוצה sscanf להצליח רק ב
המילוי הראשון של המשתנים שלה.

819
00:35:48,580 --> 00:35:52,490
ואז בגלל זה אני
רוצה sscanf לחזור 1.

820
00:35:52,490 --> 00:35:55,750
>> ואם זה קצת מעל הראש
לרגע, זה בסדר לגמרי.

821
00:35:55,750 --> 00:36:00,030
מבין זאת, כי אחד
ערכים של getInt וgetString

822
00:36:00,030 --> 00:36:03,630
הוא שאנחנו עושים לעזאזל של
הרבה בדיקת שגיאות כמו זה כל כך

823
00:36:03,630 --> 00:36:07,130
כי, נכון להיום, אתה יכול פחות או יותר
הקלד כל דבר במקלדת שלך,

824
00:36:07,130 --> 00:36:08,490
ואנחנו נתפוס אותו.

825
00:36:08,490 --> 00:36:10,592
ואנחנו בהחלט,
צוות, בהחלט לא

826
00:36:10,592 --> 00:36:13,300
להיות המקור של באג בך
תכנית, בגלל שאנחנו בהתגוננות

827
00:36:13,300 --> 00:36:16,270
בדיקה לכל הטיפשים
דברים שהמשתמש עשוי לעשות,

828
00:36:16,270 --> 00:36:18,900
כמו הקלדת מחרוזת, כאשר
אתה באמת רוצה int.

829
00:36:18,900 --> 00:36:21,350
אז לnow-- אנחנו נבוא
בחזרה לזה לפני long--

830
00:36:21,350 --> 00:36:23,710
אבל כל הזמן הזה,
יש לי getString וgetInt

831
00:36:23,710 --> 00:36:29,950
היה מתחת למכסת המנוע באמצעות זה
רעיון בסיסי של כתובות זיכרון.

832
00:36:29,950 --> 00:36:32,580
>> אז עכשיו, בואו נעשה את הדברים
קצת יותר ידידותי למשתמש.

833
00:36:32,580 --> 00:36:38,740
כזכור, מהינקי האחרון
time-- אם העכבר שלי יהיה cooperate-- כך

834
00:36:38,740 --> 00:36:42,560
היו לנו קוד, זה ש
בכנות, הוא די שטותי.

835
00:36:42,560 --> 00:36:45,330
קוד זה אינו משיג דבר
שימושי, אבל זה היה הדוגמא

836
00:36:45,330 --> 00:36:48,330
פרופסור שParlante
משמש כדי לייצג

837
00:36:48,330 --> 00:36:51,840
מה קורה ב
התכנית הכרוכה בזיכרון.

838
00:36:51,840 --> 00:36:54,850
>> אז בואו לספר זה
סיפור בקצרה סופר.

839
00:36:54,850 --> 00:36:58,720
שתי שורות הראשונות אלה, ב
אנגלית, אין מה, היית אומר?

840
00:36:58,720 --> 00:37:01,230

841
00:37:01,230 --> 00:37:05,430
רק באופן סביר אנושי, אבל
מעט מונחים טכניים, לקחת דקירה.

842
00:37:05,430 --> 00:37:06,346
קהל: [לא ברור].

843
00:37:06,346 --> 00:37:07,705

844
00:37:07,705 --> 00:37:11,080
>> דוד י מלאן: אישור, אתה הקמת
כתובות לx שלך ומשתני y.

845
00:37:11,080 --> 00:37:15,520
לא ממש, כי x, y אינו
משתנים במובן המסורתי.

846
00:37:15,520 --> 00:37:18,054
x ו y הם כתובות
או ישמור את כתובת.

847
00:37:18,054 --> 00:37:19,220
אז בואו ננסה את זה עוד פעם אחת.

848
00:37:19,220 --> 00:37:21,010
התחלה לא רעה, אם כי.

849
00:37:21,010 --> 00:37:21,510
כן?

850
00:37:21,510 --> 00:37:22,426
>> קהל: [לא ברור].

851
00:37:22,426 --> 00:37:23,966

852
00:37:23,966 --> 00:37:24,840
דוד י מלאן: טוב.

853
00:37:24,840 --> 00:37:26,173
אני חושב שזה קצת יותר נקי.

854
00:37:26,173 --> 00:37:28,630
הכרזת שני מצביעים, שני מספרים שלמים.

855
00:37:28,630 --> 00:37:30,150
ואנחנו קוראים להם x, y.

856
00:37:30,150 --> 00:37:32,790
או אם היינו לצייר
זה כתמונה, שוב,

857
00:37:32,790 --> 00:37:36,410
זוכר בפשטות שכל
אנחנו עושים עם זה שורה הראשונה

858
00:37:36,410 --> 00:37:39,690
הוא ציור תיבה כמו זו,
עם קצת ערך זבל בזה,

859
00:37:39,690 --> 00:37:41,920
וקורא לזה X, ולאחר מכן
קופסא אחרת כמו זה,

860
00:37:41,920 --> 00:37:43,880
עם קצת ערך זבל
בזה, קורא לזה y.

861
00:37:43,880 --> 00:37:45,810
אנחנו כבר הכריזו שני
מצביעים שסופו של דבר

862
00:37:45,810 --> 00:37:47,860
ישמור את הכתובת של int.

863
00:37:47,860 --> 00:37:49,170
אז זה כל מה שיש.

864
00:37:49,170 --> 00:37:53,290
>> לכן, כאשר בינקי עשה את זה,
חימר רק נראה כך.

865
00:37:53,290 --> 00:37:55,350
וניק פשוט סוג של
עטוף חצים,

866
00:37:55,350 --> 00:37:57,590
כאילו הם לא מצביעים לשום מקום
בפרט, כי הם פשוט

867
00:37:57,590 --> 00:37:58,250
ערכי זבל.

868
00:37:58,250 --> 00:38:01,670
הם לא אותחלו במפורש
בכל מקום בפרט.

869
00:38:01,670 --> 00:38:03,980
>> עכשיו השורה הבאה של
קוד, כזכור, היה זה.

870
00:38:03,980 --> 00:38:07,510
אז באופן סביר ידידותי למשתמש,
אבל אנגלית הטכנית במידה מה,

871
00:38:07,510 --> 00:38:09,790
מה היא שורת קוד הזאת עושה?

872
00:38:09,790 --> 00:38:10,391
כן?

873
00:38:10,391 --> 00:38:11,333
>> קהל: [לא ברור].

874
00:38:11,333 --> 00:38:12,746

875
00:38:12,746 --> 00:38:13,950
>> דוד י מלאן: מושלם.

876
00:38:13,950 --> 00:38:17,016
זה הקצאת הנתח של
זיכרון זה בגודל של int.

877
00:38:17,016 --> 00:38:18,140
וזה חצי מהתשובה.

878
00:38:18,140 --> 00:38:20,056
אתה ענה נכון
מחצית מהביטוי.

879
00:38:20,056 --> 00:38:22,473
מה שקורה ב
צד השמאלי של סימן השוויון?

880
00:38:22,473 --> 00:38:22,972
כן?

881
00:38:22,972 --> 00:38:24,814
קהל: ומקצה
זה לx משתנה?

882
00:38:24,814 --> 00:38:27,690
>> דוד י מלאן: ומקצה
זה לx משתנה.

883
00:38:27,690 --> 00:38:31,650
אז כדי לסכם, מקצה צד ימני
מספיק זיכרון כדי לאחסן int.

884
00:38:31,650 --> 00:38:34,150
אבל באופן ספציפי malloc
מחזיר את הכתובת

885
00:38:34,150 --> 00:38:37,270
של נתח זה של זיכרון, שיש לך
רק הציע מקבל מאוחסן בx.

886
00:38:37,270 --> 00:38:42,560
>> אז מה ניק עשה בפעם קודמת עם בינקי הוא
הוא גרר את המצביע שיצא, החימר,

887
00:38:42,560 --> 00:38:46,820
להצביע עכשיו בנתח לבן של זיכרון
כי הוא שווה לגודל של int.

888
00:38:46,820 --> 00:38:49,360
ואכן, שאמורה
לייצג ארבעה בתים.

889
00:38:49,360 --> 00:38:55,310
>> עכשיו, השורה הבאה של קוד
עשיתי את זה, x הכוכב מקבל 42.

890
00:38:55,310 --> 00:38:58,530
אז 42 הוא פשוטים על
צד ימני, משמעות חיים.

891
00:38:58,530 --> 00:39:00,500
צד שמאלי, x כוכב פירושו מה?

892
00:39:00,500 --> 00:39:01,600

893
00:39:01,600 --> 00:39:03,280
גם שאולי יש לי gone-- זה בסדר.

894
00:39:03,280 --> 00:39:04,220
אישור.

895
00:39:04,220 --> 00:39:06,875
>> קהל: בעיקרון,
ללכת ל[ לא ברור]

896
00:39:06,875 --> 00:39:07,750
דוד י מלאן: טוב.

897
00:39:07,750 --> 00:39:08,760
קהל: [לא ברור].

898
00:39:08,760 --> 00:39:09,760
דוד י מלאן: בדיוק.

899
00:39:09,760 --> 00:39:11,979
צד שמאל פירושו ללכת לx.

900
00:39:11,979 --> 00:39:12,520
x הוא כתובת.

901
00:39:12,520 --> 00:39:15,520
זה כמו רחוב 33 אוקספורד, או OX1.

902
00:39:15,520 --> 00:39:18,690
וx כוכב פירושו ללכת לזה
לטפל ולשים את מה שיש?

903
00:39:18,690 --> 00:39:19,520
42.

904
00:39:19,520 --> 00:39:21,290
>> אז אכן, זה בדיוק מה שניק עשה.

905
00:39:21,290 --> 00:39:23,740
הוא התחיל עם על ידי,
בעצם, מבחינה נפשית

906
00:39:23,740 --> 00:39:26,270
הפנה אצבע מאשימה
x, בעקבות החץ

907
00:39:26,270 --> 00:39:30,670
לקופסא הלבנה על יד ימין
צד, ולשים את המספר 42 שם.

908
00:39:30,670 --> 00:39:34,120
אבל אז יש דברים
קצת מסוכן, נכון?

909
00:39:34,120 --> 00:39:35,860
בינקי של עומד לאבד את ראשו.

910
00:39:35,860 --> 00:39:39,465
>> y הכוכב שווה 13, מזל רע, פירושו מה?

911
00:39:39,465 --> 00:39:43,620
אז אמצעי y כוכב ללכת לכתובת בy.

912
00:39:43,620 --> 00:39:45,630
אבל מה היא הכתובת בy?

913
00:39:45,630 --> 00:39:47,899

914
00:39:47,899 --> 00:39:49,440
בסדר, זה ערך זבל, נכון?

915
00:39:49,440 --> 00:39:50,800
ציירתי אותו כסימן שאלה.

916
00:39:50,800 --> 00:39:54,850
ניק משך אותו כחץ מכורבל.

917
00:39:54,850 --> 00:39:59,600
וברגע שאתה מנסה
לעשות y כוכב, אומר ללכת לשם,

918
00:39:59,600 --> 00:40:03,872
אבל יש לא לגיטימי
כתובת, זה חלק מיקום מזויף,

919
00:40:03,872 --> 00:40:05,080
התכנית הולכת לקרוס.

920
00:40:05,080 --> 00:40:08,580
וראשו של בינקי הוא הולך
לעוף מכאן, כפי שהוא עשה.

921
00:40:08,580 --> 00:40:12,130
>> אז בסופו של הדבר, תכנית זו
היה רק ​​פגם החוצה שטוח.

922
00:40:12,130 --> 00:40:13,540
זו הייתה תכנית מרכבה.

923
00:40:13,540 --> 00:40:14,760
וזה צריך להיות קבוע.

924
00:40:14,760 --> 00:40:18,260
והדרך היחידה, באמת, כדי לתקן את זה
יהיה, למשל, את הקו הזה,

925
00:40:18,260 --> 00:40:21,010
שאנחנו אפילו לא הגענו ל, כי
התכנית התרסקה מוקדם מדי.

926
00:40:21,010 --> 00:40:26,170
אבל אם היינו לתקן את זה, מה ש
אפקט עושה עושה לי x שווה y?

927
00:40:26,170 --> 00:40:30,010
ובכן, זה בעצם מצביע y ב
מה ערך של x הוא מצביע ב.

928
00:40:30,010 --> 00:40:32,430
>> אז בסיפורו של ניק,
או סיפורו של בינקי, שניהם

929
00:40:32,430 --> 00:40:34,640
x, y היה מצביע על
הנתח הלבן של זיכרון,

930
00:40:34,640 --> 00:40:38,300
כך שלבסוף, כאשר אתה
אל לככב y שווה 13 שוב,

931
00:40:38,300 --> 00:40:43,080
אתה בסופו של דבר לשים 13 ב
המיקום המתאים.

932
00:40:43,080 --> 00:40:47,640
אז כל הקווים האלה הם בצורה מושלמת
לגיטימי, פרט לזו אחת,

933
00:40:47,640 --> 00:40:51,730
כשזה קרה לפני ש
למעשה הוקצה y ערך כלשהו.

934
00:40:51,730 --> 00:40:54,290
>> עכשיו לשמחתי, שאתה לא יודע
יש לי למצוא היגיון בתוך כל

935
00:40:54,290 --> 00:40:56,560
מסוגים אלה של בעיות בעצמך.

936
00:40:56,560 --> 00:40:59,310
תן לי ללכת קדימה ולפתוח
עד חלון מסוף כאן

937
00:40:59,310 --> 00:41:03,050
ולפתוח, רק לרגע,
תכנית סופר קצרה ש

938
00:41:03,050 --> 00:41:04,360
גם הוא סוג של טעם.

939
00:41:04,360 --> 00:41:05,152
זה מכוער.

940
00:41:05,152 --> 00:41:06,610
זה לא להשיג שום דבר שימושי.

941
00:41:06,610 --> 00:41:10,180
אבל זה להדגים סוגיות
של זיכרון, אז בואו נסתכל.

942
00:41:10,180 --> 00:41:11,830
>> ראשי, סופר פשוט.

943
00:41:11,830 --> 00:41:14,830
זה כנראה קורא פונקציה,
f, ולאחר מכן מחזירה 0.

944
00:41:14,830 --> 00:41:16,310
זה קצת קשה לבלגן הזה.

945
00:41:16,310 --> 00:41:18,540
אז ראשי הוא די טוב, עד כה.

946
00:41:18,540 --> 00:41:20,100
>> אז f היא בעייתית.

947
00:41:20,100 --> 00:41:22,120
ופשוט לא לשים הרבה
מאמץ ליום זה

948
00:41:22,120 --> 00:41:23,990
כאן, לשמור את הפוקוס על הקוד.

949
00:41:23,990 --> 00:41:25,740
יש f שני קווים.

950
00:41:25,740 --> 00:41:27,610
ובואו נראה מה עכשיו קורה.

951
00:41:27,610 --> 00:41:29,840
אז מצד האחד
here-- ותנו לי לעשות

952
00:41:29,840 --> 00:41:32,680
זה עולה בקנה אחד עם הקודם
example-- מצד האחד,

953
00:41:32,680 --> 00:41:35,830
הצד השמאלי הוא
עושה את מה ש, באנגלית?

954
00:41:35,830 --> 00:41:36,493
זה is--

955
00:41:36,493 --> 00:41:37,701
קהל: יצירת מצביע.

956
00:41:37,701 --> 00:41:40,830
דוד י מלאן: יצירת מצביע
לint וקוראים לזה x.

957
00:41:40,830 --> 00:41:43,789
אז זה יוצר את אחת קופסות האלה
אני כל הזמן ציור על מסך המגע.

958
00:41:43,789 --> 00:41:45,913
ועכשיו, ביד ימין
צד, malloc, כמובן,

959
00:41:45,913 --> 00:41:47,420
מקצה נתח של זיכרון.

960
00:41:47,420 --> 00:41:49,989
ורק שיהיה ברור, איך
הרבה זיכרון זה כנראה

961
00:41:49,989 --> 00:41:52,030
הקצאה, אם אתה רק
לעשות סוג של המתמטיקה כאן?

962
00:41:52,030 --> 00:41:53,200

963
00:41:53,200 --> 00:41:54,040
>> אז זה 40 בתים.

964
00:41:54,040 --> 00:41:57,400
ואני יודע שרק בגלל שאני יודע
int, על מכשיר CS50, לפחות,

965
00:41:57,400 --> 00:41:58,060
הוא ארבעה בתים.

966
00:41:58,060 --> 00:41:59,610
אז 10 פעמים 4 הוא 40.

967
00:41:59,610 --> 00:42:04,924
אז זה אחסון x, כתובת
של את הראשון של 40 ints ש

968
00:42:04,924 --> 00:42:07,340
הוקצו שטח בחזרה,
לגבות, לגבות, לגב.

969
00:42:07,340 --> 00:42:08,470
>> וזה מה שחשוב על malloc.

970
00:42:08,470 --> 00:42:11,261
זה לא לוקח קצת זיכרון
כאן, קצת פה, קצת פה.

971
00:42:11,261 --> 00:42:14,220
זה נותן לך חתיכה אחת של זיכרון,
בסמיכות, מההפעלה

972
00:42:14,220 --> 00:42:15,240
מערכת.

973
00:42:15,240 --> 00:42:18,500
>> עכשיו מה לגבי זה,
x סוגר 10 שווה 0?

974
00:42:18,500 --> 00:42:19,470
שורה שרירותית של קוד.

975
00:42:19,470 --> 00:42:21,100
זה לא להשיג שום דבר שימושי.

976
00:42:21,100 --> 00:42:26,128
אבל זה מעניין,
כי סוגר x 10--?

977
00:42:26,128 --> 00:42:26,628
כן?

978
00:42:26,628 --> 00:42:27,912
>> קהל: [לא ברור]?

979
00:42:27,912 --> 00:42:30,500
>> דוד י מלאן: סוגר x
10 לא צריכים להיות null.

980
00:42:30,500 --> 00:42:35,070
פירוט null מגיע רק למשחק
עם מחרוזות, בסוף המחרוזת.

981
00:42:35,070 --> 00:42:36,700
אבל מחשבה טובה.

982
00:42:36,700 --> 00:42:39,615
>> כמה גדול הוא מערך זה, אפילו
אם כי אני כבר הוקצה 40 בתים?

983
00:42:39,615 --> 00:42:42,560

984
00:42:42,560 --> 00:42:43,690
זה 0 עד תשע, נכון?

985
00:42:43,690 --> 00:42:45,120
זה 10 ints, סך הכל.

986
00:42:45,120 --> 00:42:48,790
40 בתים, אבל 10 ints,
אינדקס 0 דרך 0.

987
00:42:48,790 --> 00:42:50,930
>> אז מה הוא שסוגר x 10?

988
00:42:50,930 --> 00:42:53,090
זה בעצם חלק
ערך זבל לא ידוע.

989
00:42:53,090 --> 00:42:54,780
זה זיכרון שלא שייך לי.

990
00:42:54,780 --> 00:42:59,650
אני לא צריך להיות נגיעה ש
בתים מספר 41, 42, 43, 44.

991
00:42:59,650 --> 00:43:01,420
אני הולך מעט רחוק מדי.

992
00:43:01,420 --> 00:43:04,490
>> ואכן, אם אני מפעיל את זה
תכנית, ייתכן מאוד לקרוס.

993
00:43:04,490 --> 00:43:05,790
אבל לפעמים, יהיה לנו מזל.

994
00:43:05,790 --> 00:43:07,706
וכך, רק כדי להפגין
זה- ולמען אמת,

995
00:43:07,706 --> 00:43:11,000
אתה אף פעם לא יודע לפני שאתה
אל it-- בואו נריץ את זה.

996
00:43:11,000 --> 00:43:12,480
זה לא לקרוס למעשה.

997
00:43:12,480 --> 00:43:15,032
>> אבל אם אני משנה את זה, עבור
למשל, להיות כמו 1,000,

998
00:43:15,032 --> 00:43:16,740
כדי להפוך את זה באמת
מכוון, בואו לראות

999
00:43:16,740 --> 00:43:18,710
אם אנחנו יכולים לקבל את זה כדי לקרוס הפעם.

1000
00:43:18,710 --> 00:43:20,070
בסדר, זה לא לקרוס.

1001
00:43:20,070 --> 00:43:22,600
מה דעתך על 100,000?

1002
00:43:22,600 --> 00:43:25,000
בואו לעצבו מחדש, ועכשיו להפעיל מחדש את זה.

1003
00:43:25,000 --> 00:43:25,500
אישור.

1004
00:43:25,500 --> 00:43:25,960
אוף.

1005
00:43:25,960 --> 00:43:26,460
בסדר.

1006
00:43:26,460 --> 00:43:29,090
אז כנראה, שוב, אלה
מקטעי זיכרון, אם אפשר לומר כך,

1007
00:43:29,090 --> 00:43:32,660
הם גדולים באופן סביר, כדי שנוכל
מזל שוב ושוב.

1008
00:43:32,660 --> 00:43:36,510
אבל סופו של דבר, ברגע שאתה מקבל מגוחך
ובאמת ללכת רחוק על המסך,

1009
00:43:36,510 --> 00:43:39,120
אתה נוגע בזיכרון, כי באמת,
ממש לא שייך לך.

1010
00:43:39,120 --> 00:43:40,870
>> אבל בכנות, אלה
מיני חרקים הולכים

1011
00:43:40,870 --> 00:43:43,020
להיות קשה יותר ויותר
כדי להבין בעצמך.

1012
00:43:43,020 --> 00:43:47,880
אך לשמחתם, כמתכנתים, יש לנו
כלים המאפשרים לנו לעשות את זה בשבילנו.

1013
00:43:47,880 --> 00:43:50,140
אז זה, אולי, אחד
של התוכניות המכוערות ביותר,

1014
00:43:50,140 --> 00:43:52,060
אפילו מכוער יותר מהתפוקה של gdb.

1015
00:43:52,060 --> 00:43:55,670
אבל תמיד יש לו קו או
שניים שהם סופר שימושיים.

1016
00:43:55,670 --> 00:44:00,310
>> Valgrind היא תכנית שמסייעת לי
אתה לא באגים בתכנית, כשלעצמה,

1017
00:44:00,310 --> 00:44:03,500
אבל למצוא זיכרון הקשורות
בעיות, במיוחד.

1018
00:44:03,500 --> 00:44:07,590
זה באופן אוטומטי להפעיל הקוד שלך ל
אתה ולחפש לפחות שני דברים.

1019
00:44:07,590 --> 00:44:10,680
אחת, עשית משהו
מקרי כמו מגע זיכרון

1020
00:44:10,680 --> 00:44:11,980
שלא שייך לך?

1021
00:44:11,980 --> 00:44:13,590
זה יעזור לך למצוא אותם מקרים.

1022
00:44:13,590 --> 00:44:15,710
>> ושני, זה יעזור לי
אתה מוצא משהו שנקרא

1023
00:44:15,710 --> 00:44:19,270
דליפות זיכרון, שיש לנו
לגמרי התעלם, בתמימות,

1024
00:44:19,270 --> 00:44:21,380
לכמה זמן ואושר.

1025
00:44:21,380 --> 00:44:23,140
אבל מתברר, כל
הפעם, בכל פעם ש

1026
00:44:23,140 --> 00:44:26,620
שנקראת getString ב
כל כך הרבה התוכניות שלנו,

1027
00:44:26,620 --> 00:44:28,930
אתה שואל הפעלה
מערכת לזיכרון,

1028
00:44:28,930 --> 00:44:32,070
אבל יש לך זיכרון
אי פעם לתת לו

1029
00:44:32,070 --> 00:44:36,169
בחזרה, unalloc עושה, או
חופשי, כפי שהוא נקרא.

1030
00:44:36,169 --> 00:44:37,960
לא, כי יש לנו לא
ביקשתי ממך לעשות זאת.

1031
00:44:37,960 --> 00:44:41,250
>> אבל כל הזמן הזה, התוכניות
אתה כבר כותב בC

1032
00:44:41,250 --> 00:44:43,800
כבר דולף זיכרון,
מבקש ההפעלה

1033
00:44:43,800 --> 00:44:46,190
מערכת ליותר ויותר
זיכרון עבור מחרוזות ומה לא,

1034
00:44:46,190 --> 00:44:47,870
אך מעולם לא החזיר אותו.

1035
00:44:47,870 --> 00:44:50,080
ועכשיו זה קצת
של פשטנות,

1036
00:44:50,080 --> 00:44:53,550
אבל אם יש לך אי פעם להריץ את Mac שלך או
המחשב שלך די זמן, פתיחת חלק

1037
00:44:53,550 --> 00:44:55,790
הרבה תוכניות,
אולי לסגור תוכניות,

1038
00:44:55,790 --> 00:44:57,795
ואף על פי ש
מחשב לא התרסק,

1039
00:44:57,795 --> 00:45:01,690
זה מתחיל להיות כל כך הרבה יותר איטי,
כאילו שזה באמת

1040
00:45:01,690 --> 00:45:04,290
באמצעות הרבה זיכרון או
משאבים, למרות ש,

1041
00:45:04,290 --> 00:45:06,070
אם אתה אפילו לא
לגעת במקלדת,

1042
00:45:06,070 --> 00:45:10,430
שיכול be-- אבל לא יכולתי always--
להיות שהתוכניות שאתה מפעיל

1043
00:45:10,430 --> 00:45:11,920
יש להם דליפות זיכרון.

1044
00:45:11,920 --> 00:45:15,645
והם כל זמן שואלים את מערכת ההפעלה ליותר ו
יותר זיכרון, אבל שוכח על זה,

1045
00:45:15,645 --> 00:45:18,470
לא ממש משתמש בו, אבל
לכן לוקח זיכרון משם

1046
00:45:18,470 --> 00:45:20,500
מתוכניות אחרות שאולי תרצו את זה.

1047
00:45:20,500 --> 00:45:23,940
אז זה הסבר נפוץ.

1048
00:45:23,940 --> 00:45:25,940
עכשיו הנה שבי Valgrind של
פלט הוא לגמרי

1049
00:45:25,940 --> 00:45:29,290
זוועתי פחות אלה
יותר ונוח יותר כאחד.

1050
00:45:29,290 --> 00:45:32,690
אבל המעניין
דברים נכון עד כאן.

1051
00:45:32,690 --> 00:45:37,060
זה אומר לי לכתוב לא חוקי של
גודל ארבעה קורה בתכנית זו,

1052
00:45:37,060 --> 00:45:40,640
בפרט, בשורה 21 של memory.c.

1053
00:45:40,640 --> 00:45:45,450
>> אם אני הולך לשורה 21, HM, יש אכן
הוא כתיבה לא חוקית בגודל ארבעה.

1054
00:45:45,450 --> 00:45:46,250
למה גודל ארבעה?

1055
00:45:46,250 --> 00:45:49,500
ובכן, number-- זה וזה
יכול להיות anything-- הוא int.

1056
00:45:49,500 --> 00:45:50,450
אז זה ארבעה בתים.

1057
00:45:50,450 --> 00:45:52,550
אז אני שם את ארבעה בתים
שבו הם לא שייכים.

1058
00:45:52,550 --> 00:45:55,080
זה מה שValgrind
הוא למעשה אומר לי.

1059
00:45:55,080 --> 00:45:57,600
יתר על כן, גם זה יהיה
תגיד לי, כפי שנראה,

1060
00:45:57,600 --> 00:46:01,490
כפי שאתה מפעיל את זה בpset עתיד, אם ו
כשאתה כבר דלף זיכרון, שאכן

1061
00:46:01,490 --> 00:46:05,300
יש לי, כי אני כבר בשם
malloc, אבל יש לי לא ממש

1062
00:46:05,300 --> 00:46:08,010
בשם, במקרה זה, ללא תשלום,
שסופו של דבר יראו

1063
00:46:08,010 --> 00:46:09,830
הוא היפוכו של malloc.

1064
00:46:09,830 --> 00:46:10,860

1065
00:46:10,860 --> 00:46:12,930
>> אז עכשיו, אני חושב, דוגמא אחרונה.

1066
00:46:12,930 --> 00:46:14,050

1067
00:46:14,050 --> 00:46:16,690
אז זה אחד מהם קצת יותר
מסתורי, אבל זה אולי

1068
00:46:16,690 --> 00:46:19,180
הסיבה הגדולה ביותר ל
להיות זהיר עם זיכרון,

1069
00:46:19,180 --> 00:46:24,490
ותוכניות הסיבה שרבות
ו / או שרתי אינטרנט, אפילו עד עצם היום הזה,

1070
00:46:24,490 --> 00:46:28,200
הם השתלטו על הרעים איפשהו
באינטרנט שאיכשהו

1071
00:46:28,200 --> 00:46:33,390
משלוח מנות מזויפות לשרת שלך
מנסה להתפשר החשבונות שלך,

1072
00:46:33,390 --> 00:46:36,420
או לקחת את הנתונים שלך, או סתם
בדרך כלל להשתלט על מכונה.

1073
00:46:36,420 --> 00:46:38,910
גלישת מאגר, כ
שם מרמז, אמצעים

1074
00:46:38,910 --> 00:46:40,740
גדות לא int, אבל חיץ.

1075
00:46:40,740 --> 00:46:43,490
וחיץ הוא רק דרך מפוארת
לומר שזה חבורה של זיכרון.

1076
00:46:43,490 --> 00:46:46,710
>> ואכן, אני נקרא מחרוזת
לפני חיץ, במקומו של.

1077
00:46:46,710 --> 00:46:49,234
מכיוון שאם זה חיץ,
כמו במובן של YouTube,

1078
00:46:49,234 --> 00:46:52,400
או בכל זמן שאתה צופה בוידאו,
שאולי ראה את מילת החציצה,

1079
00:46:52,400 --> 00:46:53,040
הנקודה, נקודה, נקודה.

1080
00:46:53,040 --> 00:46:54,240
זה מעצבן מאוד.

1081
00:46:54,240 --> 00:46:55,990
וזה רק אומר ש
שנגן הווידאו שלך

1082
00:46:55,990 --> 00:46:58,710
מנסה להוריד הרבה
של בתים, הרבה בתים

1083
00:46:58,710 --> 00:47:00,170
מוידאו מהאינטרנט.

1084
00:47:00,170 --> 00:47:02,920
אבל זה איטי, כך שהוא מנסה
להוריד חבורה שלהם

1085
00:47:02,920 --> 00:47:06,430
כדי למלא את מאגר, מיכל, כך ש
יש לך מספיק בתים שלאחר מכן יכול

1086
00:47:06,430 --> 00:47:09,174
להראות לך וידאו,
בלי לעצור כל הזמן.

1087
00:47:09,174 --> 00:47:11,340
אבל מתברר, שאתה יכול
יש לי חיץ לזה גדול.

1088
00:47:11,340 --> 00:47:15,710
אבל תנסה לשים את כמות הנתונים זו ב
זה, ומאוד דברים רעים יכולים לקרות.

1089
00:47:15,710 --> 00:47:22,780
כך למשל, בואו נסתכל על
טיזר האחרון של ירושלים.

1090
00:47:22,780 --> 00:47:24,720
זוהי תכנית אחרת
כי, במבט ראשון,

1091
00:47:24,720 --> 00:47:26,540
לא עושה שום דבר סופר שימושי.

1092
00:47:26,540 --> 00:47:29,590
יש לו תפקיד ראשי
שקורא פונקציה ש, f.

1093
00:47:29,590 --> 00:47:36,640
ופונקציה ש, f, עד כאן, יש לי
מערך תווים, הנקרא ג, בגודל 12.

1094
00:47:36,640 --> 00:47:39,340
ואז זה מנצל את זה
פונקציה חדשה בשם strncpy.

1095
00:47:39,340 --> 00:47:40,430

1096
00:47:40,430 --> 00:47:45,190
>> מתברר כי, עם זה פשוט,
קו פשוט של קוד, רק שתי שורות,

1097
00:47:45,190 --> 00:47:49,130
עשינו כל התכנית שלי,
ולכן, כל המחשב שלי,

1098
00:47:49,130 --> 00:47:54,000
והחשבון שלי למשתמש, ושלי קשה
לנהוג שעלול להיות פגיע לאף אחד

1099
00:47:54,000 --> 00:47:58,170
מי יודע, והוא טוב מספיק כדי להפעיל
תכנית זו עם שורת הפקודה מסוימת

1100
00:47:58,170 --> 00:47:58,900
טיעון.

1101
00:47:58,900 --> 00:48:03,400
במילים אחרות, אם האיש הרע הזה
מעמיד על ידי הקלדה בתוך argvargv [1]

1102
00:48:03,400 --> 00:48:08,750
במקלדת מאוד בעלת מבנה מיוחד
מחרוזת, לא abc, 123, אבל במהותו,

1103
00:48:08,750 --> 00:48:15,180
סימנים בינארי שמייצגים הפעלה
קוד, תכנית שהוא או היא כתבה,

1104
00:48:15,180 --> 00:48:19,190
עם תוכנה פשוטה זו, שהיא
נציג של אלפי תוכניות

1105
00:48:19,190 --> 00:48:23,610
כי הם דומים פגיעים, מעזים לומר,
הוא או היא סופו של דבר יכולה למחוק את כל

1106
00:48:23,610 --> 00:48:26,680
הקבצים בכונן הקשיח שלי, לקבל
מהבהב הפקודה, כך הוא או היא יכולה

1107
00:48:26,680 --> 00:48:30,170
להקליד פקודות בכוחות עצמם,
דוא"ל את כל הקבצים לעצמי.

1108
00:48:30,170 --> 00:48:34,660
כל דבר שאני יכול לעשות, הוא
או שהיא יכולה לעשות עם הקוד הזה.

1109
00:48:34,660 --> 00:48:36,575
>> אנחנו לא ממש לפתור את זה עדיין.

1110
00:48:36,575 --> 00:48:38,700
ולמעשה, זה הולך
כרוך קצת תמונה

1111
00:48:38,700 --> 00:48:41,470
כמו זה, שבו אנו בקרוב נבוא
כדי להבין מה טוב.

1112
00:48:41,470 --> 00:48:44,480
אבל היום, בואו יסתיימו ב
מה, אני מקווה, מעט יותר

1113
00:48:44,480 --> 00:48:48,360
בדיחה xkcd מובנת,
עד שנתחדש בפעם הבאה.

1114
00:48:48,360 --> 00:48:51,100

1115
00:48:51,100 --> 00:48:51,600
בסדר.

1116
00:48:51,600 --> 00:48:53,446
לראות אותך ביום רביעי.

1117
00:48:53,446 --> 00:48:54,754
>> [השמעת מוסיקה]

1118
00:48:54,754 --> 00:48:57,790
>> דובר: ועכשיו, עמוק
מחשבות, על ידי ךייבן Farnham.

1119
00:48:57,790 --> 00:49:00,890

1120
00:49:00,890 --> 00:49:04,770
זיכרון הוא כמו לקפוץ לתוך ערימת
עלים זהובים ביום ראשון אחר הצהריים.

1121
00:49:04,770 --> 00:49:09,000
רוח נושבת, משליך שלך
hair-- הו, אני מתגעגע לימים when--

1122
00:49:09,000 --> 00:49:11,100

1123
00:49:11,100 --> 00:49:12,650
>> [שחוק]

1124
00:49:12,650 --> 00:49:13,750