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

2
00:00:01,110 --> 00:00:10,567

3
00:00:10,567 --> 00:00:11,650
דוד י מלאן: בסדר.

4
00:00:11,650 --> 00:00:15,610
זה CS50, וזה
הוא סוף השבוע ארבע.

5
00:00:15,610 --> 00:00:19,420
והיום אחד מהנושאים
היא זו של זיהוי פלילי דיגיטלי,

6
00:00:19,420 --> 00:00:20,989
אמנות מחל מידע.

7
00:00:20,989 --> 00:00:22,780
ואכן, אף על פי ש
אתה באמצע

8
00:00:22,780 --> 00:00:25,070
עכשיו שלום בשלוש
ובריחה, בשבוע הבא,

9
00:00:25,070 --> 00:00:27,880
הדגש יהיה על
דווקא תחום זה.

10
00:00:27,880 --> 00:00:30,686
>> אז באחד התפקידים הכי מגניב שאי פעם
היה לי היה בחזרה בבית הספר לתואר שני,

11
00:00:30,686 --> 00:00:33,560
כשעבדתי עבור המקומי
מידלסקס קאונטי התובע המחוזי של

12
00:00:33,560 --> 00:00:34,950
משרד, זיהוי פלילי עושה עבודה.

13
00:00:34,950 --> 00:00:37,450
אז בעצם, מסצ'וסטס
משטרת המדינה, בהזדמנות,

14
00:00:37,450 --> 00:00:40,100
כאשר עובד על מקרים היית
להביא דברים כמו כוננים קשיחים

15
00:00:40,100 --> 00:00:42,185
ודיסקטים ו
כרטיסי זיכרון וכדומה.

16
00:00:42,185 --> 00:00:44,060
והם היו למסור אותם
אליי והמורה הרוחני שלי,

17
00:00:44,060 --> 00:00:48,070
והמטרה שלנו הייתה למצוא ראיות,
אם היה, באמצעי התקשורת אלה.

18
00:00:48,070 --> 00:00:50,700
הצצות עכשיו, שאולי ראו
העולם הזה של זיהוי פלילי

19
00:00:50,700 --> 00:00:53,000
בתקשורת, הטלוויזיה והסרטים.

20
00:00:53,000 --> 00:00:55,730
אבל העבודה שהייתה לי, ו
מניח שעולם,

21
00:00:55,730 --> 00:00:57,550
הוא לא בדיוק כמו שהיית רואה את זה.

22
00:00:57,550 --> 00:01:00,794
בואו נסתכל על מה ש
יש לך כנראה ראה.

23
00:01:00,794 --> 00:01:01,460
[וידאו השמעה]

24
00:01:01,460 --> 00:01:02,930
"או-קיי.

25
00:01:02,930 --> 00:01:05,380
עכשיו, בואו לקבל מבט טוב עליך.

26
00:01:05,380 --> 00:01:06,850
>> [השמעת מוסיקה]

27
00:01:06,850 --> 00:01:12,260

28
00:01:12,260 --> 00:01:12,932
>> -Hold זה.

29
00:01:12,932 --> 00:01:13,657
הפעל את זה בחזרה.

30
00:01:13,657 --> 00:01:14,733
>> -Wait דקות.

31
00:01:14,733 --> 00:01:15,233
ללכת ימינה.

32
00:01:15,233 --> 00:01:16,371

33
00:01:16,371 --> 00:01:16,870
ואכן.

34
00:01:16,870 --> 00:01:17,369
להקפיא את זה.

35
00:01:17,369 --> 00:01:17,930
-Full מסך.

36
00:01:17,930 --> 00:01:18,376
>> "או-קיי.

37
00:01:18,376 --> 00:01:18,875
להקפיא את זה.

38
00:01:18,875 --> 00:01:20,160
-Tighten על ש, יהיה לך?

39
00:01:20,160 --> 00:01:22,126
>> -Vector שב
בחור בגלגל האחורי.

40
00:01:22,126 --> 00:01:24,435
>> -Zoom בממש כאן במקום הזה.

41
00:01:24,435 --> 00:01:28,580
>> -עם הציוד הנכון,
תמונה יכולה להיות מוגדלת וחדדה.

42
00:01:28,580 --> 00:01:29,330
>> 'מה זה?

43
00:01:29,330 --> 00:01:30,780
>> "כבר תכנית שיפור.

44
00:01:30,780 --> 00:01:32,170
>> "אתה יכול ברור שעד כל?

45
00:01:32,170 --> 00:01:33,070
>> 'אני לא יודע.

46
00:01:33,070 --> 00:01:34,150
בואו לשפר אותו.

47
00:01:34,150 --> 00:01:35,440
>> -Enhance סעיף A6.

48
00:01:35,440 --> 00:01:36,570

49
00:01:36,570 --> 00:01:38,562
אני משופר הפרט, and--

50
00:01:38,562 --> 00:01:40,020
'אני חושב שיש מספיק כדי לשפר.

51
00:01:40,020 --> 00:01:40,976
לשחרר אותו למסך שלי.

52
00:01:40,976 --> 00:01:42,559
>> 'אני משופר ההשתקפות בעיניה.

53
00:01:42,559 --> 00:01:44,322
'תן מנוהל זו דרך
שיפור וידאו.

54
00:01:44,322 --> 00:01:45,210
>> -Edgar, אתה יכול לשפר את זה?

55
00:01:45,210 --> 00:01:45,710
>> -Hang ב.

56
00:01:45,710 --> 00:01:47,570

57
00:01:47,570 --> 00:01:49,458
>> "יש לי עובד על השתקפות זו.

58
00:01:49,458 --> 00:01:50,402
>> ההשתקפות של מישהו של ואכן.

59
00:01:50,402 --> 00:01:50,902
>> -Reflection.

60
00:01:50,902 --> 00:01:52,870
ואכן זה השתקפות של פניו של האיש.

61
00:01:52,870 --> 00:01:53,694
>> השתקפות -The!

62
00:01:53,694 --> 00:01:54,610
ואכן השתקפות.

63
00:01:54,610 --> 00:01:55,880
-Zoom במראה.

64
00:01:55,880 --> 00:01:57,860
אתה יכול לראות את השתקפות.

65
00:01:57,860 --> 00:01:59,630
>> "אתה יכול לשפר את התמונה מכאן?

66
00:01:59,630 --> 00:02:00,377

67
00:02:00,377 --> 00:02:01,210
"אתה יכול לשפר אותו?

68
00:02:01,210 --> 00:02:02,190
"אתה יכול לשפר אותו?

69
00:02:02,190 --> 00:02:03,066
"בסדר." "החנות לשפר את זה?

70
00:02:03,066 --> 00:02:03,898
"אתה יכול לשפר אותו?

71
00:02:03,898 --> 00:02:04,740
-Hold בשני.

72
00:02:04,740 --> 00:02:05,281
אני לשפר.

73
00:02:05,281 --> 00:02:06,470
-Zoom בדלת.

74
00:02:06,470 --> 00:02:06,970
-Times 10.

75
00:02:06,970 --> 00:02:08,009
-Zoom.

76
00:02:08,009 --> 00:02:08,509
הזז ב.

77
00:02:08,509 --> 00:02:09,340
-More.

78
00:02:09,340 --> 00:02:10,094
-Wait, לעצור.

79
00:02:10,094 --> 00:02:10,750
-Stop.

80
00:02:10,750 --> 00:02:11,250
-Pause זה.

81
00:02:11,250 --> 00:02:13,542
-Rotate 75 מעלות
סביב האנכי, בבקשה.

82
00:02:13,542 --> 00:02:14,750

83
00:02:14,750 --> 00:02:16,127
>> -Stop.

84
00:02:16,127 --> 00:02:19,330
חזור לחלק
על הדלת שוב.

85
00:02:19,330 --> 00:02:21,420
>> -Got משפר תמונה שיכול מפה סיבית?

86
00:02:21,420 --> 00:02:24,420
>> -אולי אנו יכולים להשתמש סינג Pradeep
שיטה לראות בחלונות.

87
00:02:24,420 --> 00:02:25,902
>> -The תוכנה היא מדינה של האמנות.

88
00:02:25,902 --> 00:02:26,866
>> -The ערך עצמי כבוי.

89
00:02:26,866 --> 00:02:29,758
>> -עם תקין
שילוב של algorithms--

90
00:02:29,758 --> 00:02:32,168
>> התאורה נלקחה של -הוא
אלגוריתמים לשלב הבא,

91
00:02:32,168 --> 00:02:34,110
ואני יכול להשתמש בם כדי
לשפר את התצלום הזה.

92
00:02:34,110 --> 00:02:36,840
>> -Lock ובלהגדיל את ציר z.

93
00:02:36,840 --> 00:02:37,351
>> -Enhance.

94
00:02:37,351 --> 00:02:37,850
שפר.

95
00:02:37,850 --> 00:02:38,720
-Enhance.

96
00:02:38,720 --> 00:02:40,070
-Freeze ולשפר.

97
00:02:40,070 --> 00:02:43,420
[END הפעלת וידאו]

98
00:02:43,420 --> 00:02:45,830
דוד י מלאן: אז אלה הם
כל המילים, אבל הם לא היו

99
00:02:45,830 --> 00:02:47,870
שימוש במשפטים בצורה נכונה.

100
00:02:47,870 --> 00:02:52,370
ואכן בעתיד, כל עת,
אנא, אתה שומע מישהו אומר את המילה,

101
00:02:52,370 --> 00:02:54,250
"לשפר", צחקוק רק קצת.

102
00:02:54,250 --> 00:02:57,190
כי כשאתה מנסה לשפר,
למשל, זה מה שקורה.

103
00:02:57,190 --> 00:02:58,580
>> אז הנה תמונה מדהימה.

104
00:02:58,580 --> 00:02:59,720
זה ךייבן של CS50.

105
00:02:59,720 --> 00:03:03,740
ונניח שאנחנו רוצים
להתמקד בניצוץ בעיניים שלו,

106
00:03:03,740 --> 00:03:05,870
או ההשתקפות של
איש רע שהיה באופן ברור

107
00:03:05,870 --> 00:03:07,820
שנתפס על ידי מצלמת האבטחה.

108
00:03:07,820 --> 00:03:10,330
זה מה שקורה כאשר
לך להתמקד על תמונה ש

109
00:03:10,330 --> 00:03:14,060
יש רק מספר סופי
ביטים הקשורים אליו.

110
00:03:14,060 --> 00:03:15,420
>> זה מה שהיית מקבל.

111
00:03:15,420 --> 00:03:19,190
ואכן, בעיניו של דייבן
אינו אלא ארבעה, אולי שישה פיקסלים

112
00:03:19,190 --> 00:03:22,110
שמרכיבים בדיוק את מה ש
היה מנצנץ שם.

113
00:03:22,110 --> 00:03:25,890
אז הבעיה סט ארבעה סופו של דבר יש לי
לך לחקור את העולם הזה, במיוחד

114
00:03:25,890 --> 00:03:28,090
על ידי טבעו של משהו
אנו קוראים לי קובץ / o, שבו

115
00:03:28,090 --> 00:03:31,000
i / o היא רק דרך מפוארת של
אומר קלט ופלט.

116
00:03:31,000 --> 00:03:34,280
>> אז עד כה, כל האינטראקציות
שהיינו לנו עם מחשב

117
00:03:34,280 --> 00:03:36,770
היה במידה רבה עם שלך
מקלדת והמסך,

118
00:03:36,770 --> 00:03:40,770
אבל לא כל כך הרבה עם הדיסק הקשיח,
או שמירה של קבצים מעבר לאלה שאתה

119
00:03:40,770 --> 00:03:41,620
את עצמך לכתוב.

120
00:03:41,620 --> 00:03:44,570
התוכניות שלך עד כה יש לי
לא היה יצירת, ושמירה,

121
00:03:44,570 --> 00:03:46,270
ועדכון הקבצים שלהם.

122
00:03:46,270 --> 00:03:47,150
>> ובכן, מה קובץ?

123
00:03:47,150 --> 00:03:48,105
ובכן, משהו כמו JPEG.

124
00:03:48,105 --> 00:03:50,520
זוהי תמונה אולי אתה
יש להם או להעלות לפייסבוק,

125
00:03:50,520 --> 00:03:51,690
או לראות בכל מקום באינטרנט.

126
00:03:51,690 --> 00:03:54,460
ואכן, תמונה שאנחנו פשוט
מסור של ךייבן היה JPEG.

127
00:03:54,460 --> 00:03:57,570
ומה שמעניין
על קבצים כמו תמונות JPEG

128
00:03:57,570 --> 00:04:02,170
הוא שהם יכולים להיות מזוהים,
בדרך כלל, על ידי דפוסים מסוימים של ביטים.

129
00:04:02,170 --> 00:04:05,200
>> במילים אחרות, מהו דבר ש
מבחין JPEG מGIF

130
00:04:05,200 --> 00:04:08,109
מPING מWord
מסמך מקובץ Excel?

131
00:04:08,109 --> 00:04:09,900
ובכן, זה פשוט שונה
דפוסים של ביטים.

132
00:04:09,900 --> 00:04:12,820
ודפוסים שונים אלה
בדרך כלל בתחילת קבצים אלה.

133
00:04:12,820 --> 00:04:18,200
>> כך שכאשר המחשב שלך פותח Word
doc, או כאשר מחשב נפתח JPEG,

134
00:04:18,200 --> 00:04:20,940
זה נראה בדרך כלל ב
כמה ביטים הראשונים בקובץ.

135
00:04:20,940 --> 00:04:24,059
ואם היא מכירה דפוס,
זה אומר, אה, זה הוא תמונה.

136
00:04:24,059 --> 00:04:25,850
תן לי להציג אותו ל
המשתמש כגרפי.

137
00:04:25,850 --> 00:04:27,870
או, הו, זה נראה כמו Word דוק.

138
00:04:27,870 --> 00:04:30,480
תן לי להראות אותה למשתמש כמאמר.

139
00:04:30,480 --> 00:04:33,020
>> כך למשל, בפורמט JPEG,
מתברר, הם

140
00:04:33,020 --> 00:04:35,460
מתוחכם למדי
מתחת למכסה המנוע.

141
00:04:35,460 --> 00:04:40,140
אבל שלושה הבתים הראשונים ברוב בכל
JPEG להתחיל עם שלושת המספרים האלה.

142
00:04:40,140 --> 00:04:44,680
אז הבתים אפס, אחד, ושתיים, ב
כמעט בכל JPEG, 255, לאחר מכן את המספר

143
00:04:44,680 --> 00:04:46,675
216, לאחר מכן את המספר 255.

144
00:04:46,675 --> 00:04:48,990
>> ומה אתה יכול
להתחיל לעשות בשבוע הבא

145
00:04:48,990 --> 00:04:52,920
למעשה תוקע מתחת
מכסה המנוע של קבצים כמו תמונות JPEG

146
00:04:52,920 --> 00:04:57,210
וכמו קבצי מפת סיביות, ורואה
מה שתמיד היה שם בשביל עוד

147
00:04:57,210 --> 00:04:58,650
כפי שאתה כבר משתמש במחשב.

148
00:04:58,650 --> 00:05:01,860
>> אבל מה שאין בדרך כלל
נכתב כמו מספרים עשרוניים כמו זה.

149
00:05:01,860 --> 00:05:04,620
מדעני מחשב לא
נוטה לדבר בעשרוני.

150
00:05:04,620 --> 00:05:06,139
הם לא באמת מדברים בינארי.

151
00:05:06,139 --> 00:05:07,930
בדרך כלל, כאשר אנו רוצים
להביע את המספרים,

152
00:05:07,930 --> 00:05:10,710
אנחנו בעצם להשתמש הקסדצימלי,
שאולי זכור לך

153
00:05:10,710 --> 00:05:13,027
מ, למשל, בעיה סט
אחת, שקרא תיגר על

154
00:05:13,027 --> 00:05:14,610
שתחשוב על מערכת שונה.

155
00:05:14,610 --> 00:05:17,170
>> אנחנו, כמובן, מכירים
עם עשרוני, אפס עד תשע.

156
00:05:17,170 --> 00:05:18,215
דברנו על בינארי.

157
00:05:18,215 --> 00:05:20,710
ולא באמת יש לנו
להשתמש כל כך הרבה כאן

158
00:05:20,710 --> 00:05:22,470
על החוצה, משום שמחשבים ישתמשו בזה.

159
00:05:22,470 --> 00:05:24,900
אבל מתכנתים מאוד יהיו
לעתים קרובות, אך לא תמיד,

160
00:05:24,900 --> 00:05:29,360
להשתמש הקסדצימלי, שרק אומר
יש לך 16 אותיות באלפבית שלך,

161
00:05:29,360 --> 00:05:31,330
בניגוד לשתיים או 10.

162
00:05:31,330 --> 00:05:34,530
>> אז איך אתה לספור עד גבוה
מתשעה בהקסדצימלי?

163
00:05:34,530 --> 00:05:41,120
אתה הולך 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
, b, c, d, e, f, רק על ידי ועידה.

164
00:05:41,120 --> 00:05:43,540
אבל מה מפתח הוא שכל
אלה הוא סמל יחיד.

165
00:05:43,540 --> 00:05:44,340
אין 10.

166
00:05:44,340 --> 00:05:48,400
אין 11, כשלעצמה, משום שכל אחד
הספרות שלך, בדיוק כמו בעשרוני

167
00:05:48,400 --> 00:05:51,940
ובדיוק כמו בינארי, רק צריך
להיות תו בודד, על ידי אמנה.

168
00:05:51,940 --> 00:05:55,280
>> כך שלאחר מכן הוא האלפבית שיש לנו
עומד לרשותנו להקסדצימלי.

169
00:05:55,280 --> 00:05:58,600
אז מה עושה JPEG נראה כמו אם אתה
היו לכתוב את השלושה ראשונים אלה

170
00:05:58,600 --> 00:06:01,980
ביטים לא כעשרוני אבל,
למשל, כהקסדצימלי?

171
00:06:01,980 --> 00:06:03,640
ולמה הוא hex אפילו כל ששימושי?

172
00:06:03,640 --> 00:06:05,290
>> ובכן, מבט מהיר על ירושלים.

173
00:06:05,290 --> 00:06:09,030
אז אם אני כותב את הקטעים ש
לייצג אחר מספרים העשרוניים אלה

174
00:06:09,030 --> 00:06:12,450
זה יכול להיות קצת חלוד
עכשיו מכמה שבועות אחורה,

175
00:06:12,450 --> 00:06:14,820
אבל ואחד משמאל
נכון הם די קלים.

176
00:06:14,820 --> 00:06:17,990
255 היו לנו המספר הגדול ביותר
יכול לייצג עם שמונה סיביות.

177
00:06:17,990 --> 00:06:18,820
זה היה כל אלה.

178
00:06:18,820 --> 00:06:21,320
אז רק אחד זה המעטה
המעניין הוא האמצעי.

179
00:06:21,320 --> 00:06:24,700
ואם אתה סוג של לעשות את
מתמטיקה, תוכל להסיק כי, אכן,

180
00:06:24,700 --> 00:06:27,949
דפוס זה של אחד ו
אפסים מייצגים 216.

181
00:06:27,949 --> 00:06:30,240
אז בואו פשוט קובעים ל
עכשיו שאלה היא נכונות.

182
00:06:30,240 --> 00:06:31,730
אבל למה זה מעניין?

183
00:06:31,730 --> 00:06:33,970
>> ובכן, בתים, כמובן, הוא שמונה סיביות.

184
00:06:33,970 --> 00:06:38,980
ומתברר שאם אתה חושב
של בתים כשני גושים של ארבעה ביטים,

185
00:06:38,980 --> 00:06:39,500
כמו זה.

186
00:06:39,500 --> 00:06:41,000
תן לי רק להוסיף קצת מרחב.

187
00:06:41,000 --> 00:06:42,550
אז לפני ש, לאחר.

188
00:06:42,550 --> 00:06:46,520
אני רק הוספתי כמה שטח לבן
למען ההדמיה כאן.

189
00:06:46,520 --> 00:06:51,840
איך ייתכן שאנו מהווים כיום ב,
למשל, הקסדצימלי כל ארבעה ביטים,

190
00:06:51,840 --> 00:06:52,880
כל סט של ארבעה ביטים?

191
00:06:52,880 --> 00:06:56,420
>> כך למשל, בצד השמאל
עכשיו, יש לנו 1,111 בינארי.

192
00:06:56,420 --> 00:07:00,420
מהו מספר שבעשרוני,
אם אתה עושה את המתמטיקה?

193
00:07:00,420 --> 00:07:03,780
יש לך את המקום אלה, מקום הזוגות,
מקום ארבע, ומקום השמיניות.

194
00:07:03,780 --> 00:07:04,341
>> קהל: 15.

195
00:07:04,341 --> 00:07:05,340
דוד י מלאן: זה 15.

196
00:07:05,340 --> 00:07:08,340
אז אם אנחנו עושים שמונה ועוד ארבעה
בתוספת שתיים ועוד אחד, אנחנו מקבלים 15.

197
00:07:08,340 --> 00:07:11,790
כדי שאוכל לכתוב את 15 להלן
1111, אבל כל העניין כאן

198
00:07:11,790 --> 00:07:13,190
הוא הקסדצימלי, לא עשרוני.

199
00:07:13,190 --> 00:07:17,310
אז במקום לכתוב את 15, 1-5,
אני הולך לכתוב את זה במשושה,

200
00:07:17,310 --> 00:07:22,311
שאם אתה חושב בחזרה, אם יש לך
אפס דרך f, מה ש15 הולך להיות?

201
00:07:22,311 --> 00:07:22,810
קהל: f.

202
00:07:22,810 --> 00:07:24,434
דוד י מלאן: אז מתברר f זה של.

203
00:07:24,434 --> 00:07:29,140
ואתה יכול לעבוד שיצאת באומרו,
טוב, אם הוא 10, לאחר מכן על אישור, f היא 15.

204
00:07:29,140 --> 00:07:33,250
אז אכן, אנחנו יכולים לשכתב
אותו סט של מספרים כf f.

205
00:07:33,250 --> 00:07:35,750
ואז אם אנחנו עושים קצת מתמטיקה,
אנו להסיק שזה ד.

206
00:07:35,750 --> 00:07:38,650
שמונה הוא די קלים, כי אנחנו
יש לי אחד במקום השמיני.

207
00:07:38,650 --> 00:07:40,620
ואז, יש לנו עוד כמה f של f.

208
00:07:40,620 --> 00:07:44,669
>> אז מה בני אדם נוטה לעשות על ידי אמנה
כאשר הם משתמשים בהקסדצימלי הוא שהם פשוט

209
00:07:44,669 --> 00:07:47,710
לכתוב את זה קצת יותר בתמציתיות,
להיפטר מרוב שהשטח לבן.

210
00:07:47,710 --> 00:07:50,890
ורק כדי להיות סופר ברור לי
קוראים שזה הקסדצימלי,

211
00:07:50,890 --> 00:07:54,670
אמנה הפשוטה בין
בני אדם הוא שאתה כותב אפס

212
00:07:54,670 --> 00:07:58,000
x, שאין לו משמעות אחרת
מ מזהה חזותי של,

213
00:07:58,000 --> 00:07:59,590
כאן מגיע מספר hex.

214
00:07:59,590 --> 00:08:04,210
>> ואז, אתה שם את שתי הספרות, f
f במקרה זה, ולאחר מכן ד, אז f f.

215
00:08:04,210 --> 00:08:06,700
אז סיפור ארוך קצר,
הקסדצימלי פשוט נוטה

216
00:08:06,700 --> 00:08:11,990
כדי להיות שימושי, כי כל אחד משלה
ספרות, אפס דרך f, בצורה מושלמת קווים

217
00:08:11,990 --> 00:08:13,880
עם דפוס של ארבעה ביטים.

218
00:08:13,880 --> 00:08:18,080
>> אז אם יש לך שתי ספרות הקסדצימליים,
אפס עד ו, שוב ושוב,

219
00:08:18,080 --> 00:08:20,256
זה נותן לך בצורה מושלמת
שמונה סיביות או בית אחד.

220
00:08:20,256 --> 00:08:22,380
אז זאת הסיבה שהוא נוטה
להיות מקובל שימושי.

221
00:08:22,380 --> 00:08:24,990
אין אינטלקטואלי
תוכן באמת מעבר לכך,

222
00:08:24,990 --> 00:08:27,010
מלבד השירות שלה בפועל.

223
00:08:27,010 --> 00:08:29,310
>> עכשיו בפורמט JPEG הוא לא רק
קובץ פורמטים לגרפיקה.

224
00:08:29,310 --> 00:08:33,230
אתם אולי זוכרים שיש
קבצים כמו זה בעולם,

225
00:08:33,230 --> 00:08:34,830
לפחות מכמה שנים.

226
00:08:34,830 --> 00:08:37,580
>> אז זה היה למעשה
מותקן במערכת Windows XP

227
00:08:37,580 --> 00:08:39,960
על מיליוני מחשבים אישיים ברחבי העולם.

228
00:08:39,960 --> 00:08:43,000
וזה היה קובץ מפת סיביות, BMP.

229
00:08:43,000 --> 00:08:47,690
וקובץ מפת סיביות, כפי שתראה הבא
שבוע, רק אומר שדפוס של נקודות,

230
00:08:47,690 --> 00:08:51,710
פיקסלים כפי שהם נקראים,
המפה על ביטים, באמת.

231
00:08:51,710 --> 00:08:55,160
>> אם כי אז מה שמעניין,,
על פורמט קובץ זה, BMP, הוא

232
00:08:55,160 --> 00:08:58,590
שמתחת למכסת המנוע, זה
יש יותר מאשר רק שלושה בתים

233
00:08:58,590 --> 00:09:01,020
המרכיבים את הכותרת שלו, כל כך
לדבר, כמה העקיצות הראשונות.

234
00:09:01,020 --> 00:09:03,330
זה באמת נראה קצת
מסובך במבט ראשון.

235
00:09:03,330 --> 00:09:04,704
ואתה רואה את זה בסט P.

236
00:09:04,704 --> 00:09:06,810
ומקבל משהו
מתוך מסוים של זה עכשיו

237
00:09:06,810 --> 00:09:10,720
לא כל כך חשוב, כפי שרק את העובדה
כי בתחילתו של כל מפת סיביות

238
00:09:10,720 --> 00:09:13,823
קובץ, בפורמט גרפי,
יש חבורה של מספרים שלמות.

239
00:09:13,823 --> 00:09:14,980

240
00:09:14,980 --> 00:09:16,720
>> עכשיו מיקרוסופט,
מחבר של פורמט זה,

241
00:09:16,720 --> 00:09:18,820
נוטה לקרוא לאלה
דברים לא ints ותווים

242
00:09:18,820 --> 00:09:22,259
וצוף אבל מילות וד
מילים ומתגעגע ובתים.

243
00:09:22,259 --> 00:09:23,800
אז הם פשוט סוגי נתונים שונים.

244
00:09:23,800 --> 00:09:25,170
הם שמות שונים
לאותו הדבר.

245
00:09:25,170 --> 00:09:26,740
אבל אתה תראה שבP הגדרת ארבע.

246
00:09:26,740 --> 00:09:31,450
>> אבל זה רק אומר שאם אדם
כפול לוחץ כמה קובץ BMP עליו

247
00:09:31,450 --> 00:09:35,015
או הכונן הקשיח שלה, וכעת ייפתח חלון
עד שהראה לו או לה תמונה ש,

248
00:09:35,015 --> 00:09:38,500
זה קרה משום שההפעלה
מערכת ככל הנראה הבחינה לא רק

249
00:09:38,500 --> 00:09:41,460
סיומת הקובץ BMP
בשם הקובץ,

250
00:09:41,460 --> 00:09:45,010
אלא גם את העובדה שיש כמה
כנס לדפוס של ביטים

251
00:09:45,010 --> 00:09:47,490
ממש בהתחלה
של שקובץ מפת סיביות.

252
00:09:47,490 --> 00:09:50,270
>> אבל בואו עכשיו להתמקד ב
קובץ כזה מסובך,

253
00:09:50,270 --> 00:09:52,120
אבל במקום על משהו כזה.

254
00:09:52,120 --> 00:09:55,190
נניח כאן בgedit, אני
רק צריכים ההתחלות

255
00:09:55,190 --> 00:09:57,070
של תכנית זה די פשוט.

256
00:09:57,070 --> 00:09:58,860
יש לי כמה כולל למעלה.

257
00:09:58,860 --> 00:10:02,120
"Structs.h" #include עכשיו יש לי אבל
אני אחזור לזה שברגע.

258
00:10:02,120 --> 00:10:03,974
אבל זה שימושי לעת עתה.

259
00:10:03,974 --> 00:10:05,890
אז זה תכנית
זה הולך ליישם

260
00:10:05,890 --> 00:10:07,335
כמו מסד הנתונים של הרשם.

261
00:10:07,335 --> 00:10:09,710
אז מסד נתונים של תלמידים,
וכל תלמיד בעולם

262
00:10:09,710 --> 00:10:13,190
יש לו שם ובית וכנראה כמה
דברים אחרים, אבל אנחנו נשמור את זה פשוט.

263
00:10:13,190 --> 00:10:15,140
לכל תלמיד שם ובית.

264
00:10:15,140 --> 00:10:17,700
>> אז אם אני רוצה לכתוב
תכנית שמטרתה בחיים

265
00:10:17,700 --> 00:10:19,860
היה רק ​​כדי לחזר מ
אפס על עד שלוש,

266
00:10:19,860 --> 00:10:22,070
אם יש שלושה תלמידים
באוניברסיטת הרווארד.

267
00:10:22,070 --> 00:10:25,350
ואני רק רוצה לקבל, באמצעות GetString,
שם של כל תלמיד והבית,

268
00:10:25,350 --> 00:10:26,600
ואז פשוט להדפיס אותם החוצה.

269
00:10:26,600 --> 00:10:28,630
>> זה כמו סוג של שבוע
אחד, דברים השבוע שני עכשיו,

270
00:10:28,630 --> 00:10:30,810
שבו אני רק רוצה ל
לולאה או משהו כזה.

271
00:10:30,810 --> 00:10:34,500
ואני רוצה לקרוא לGetString כמה
פעמים, ולאחר מכן להדפיס f כמה פעמים.

272
00:10:34,500 --> 00:10:37,340
אז איך ייתכן שאני אף עושה זאת,,
כאשר שני שם ובית

273
00:10:37,340 --> 00:10:39,070
מעורבים לכל תלמיד?

274
00:10:39,070 --> 00:10:42,830
>> אז אולי האינסטינקט הראשון שלי
להיות לעשות משהו כזה.

275
00:10:42,830 --> 00:10:49,620
אולי אני ראשון לומר, גם, לתת לי,
אומר, מערך של מחרוזות שנקראות בשמות.

276
00:10:49,620 --> 00:10:51,530
ואני לא רוצה hardcode שלוש כאן.

277
00:10:51,530 --> 00:10:53,064
מה שאני כן רוצה לשים שם?

278
00:10:53,064 --> 00:10:55,730
אז סטודנטים, כי זה פשוט
קבוע הכריז בראש,

279
00:10:55,730 --> 00:10:57,860
רק אז אני לא צריך hardcode
שלושה במספר מקומות.

280
00:10:57,860 --> 00:11:00,859
בדרך זו, אני יכול לשנות את זה מקום אחד,
וזה משפיע על שינוי בכל מקום.

281
00:11:00,859 --> 00:11:04,470
ולאחר מכן, אני יכול לעשות
מחרוזת בתי סטודנטים.

282
00:11:04,470 --> 00:11:10,250
>> ועכשיו, אני יכול לעשות משהו כזה
עבור (אני int = 0; i <סטודנטים; i ++.

283
00:11:10,250 --> 00:11:14,390
אז אני מקליד מהר, אבל זה
כנראה תחביר מוכר עכשיו.

284
00:11:14,390 --> 00:11:17,030
>> ועכשיו, זה היה אחרונים יותר.

285
00:11:17,030 --> 00:11:22,890
אם אני רוצה לשים בi-th
שמו של הסטודנט, אני חושב שאני עושה את זה.

286
00:11:22,890 --> 00:11:26,480
ולאחר מכן, לא שמות
אבל בתים ממסגרים i.

287
00:11:26,480 --> 00:11:29,930
אני עושה את זה, GetString, ולתת
לי לחזור ולתקן את הקו הזה.

288
00:11:29,930 --> 00:11:30,430
מסכים?

289
00:11:30,430 --> 00:11:31,200
לא מסכים?

290
00:11:31,200 --> 00:11:32,366
זה לא מאוד ידידותי למשתמש.

291
00:11:32,366 --> 00:11:33,890
לא סיפרתי לי המשתמש מה לעשות.

292
00:11:33,890 --> 00:11:36,520
>> אבל עכשיו, אם אני גם
רציתי מאוחר יותר, בואו

293
00:11:36,520 --> 00:11:40,060
למשל, להדפיס את הדברים האלה
out-- כך TODO מאוחר יותר.

294
00:11:40,060 --> 00:11:42,330
אני הולך לעשות יותר עם
זה- זה ניתן לטעון כלומר

295
00:11:42,330 --> 00:11:45,970
יישום נכון של
מקבל שמות ובתים, שלוש

296
00:11:45,970 --> 00:11:48,870
כולל שלהם של כל אחד, ממשתמש.

297
00:11:48,870 --> 00:11:51,280
>> אבל זה לא עיצוב טוב מאוד, נכון?

298
00:11:51,280 --> 00:11:55,220
מה אם תלמיד יש לא רק שם
ובית, אלא גם את מספר תעודת זהות,

299
00:11:55,220 --> 00:11:57,770
ומספר טלפון,
וכתובת דואר אלקטרוני,

300
00:11:57,770 --> 00:12:00,280
ואולי דף בית, ו
אולי ידית טוויטר,

301
00:12:00,280 --> 00:12:03,730
וכל מספר של פרטים אחרים
הקשורים לסטודנט או אדם,

302
00:12:03,730 --> 00:12:04,610
באופן כללי יותר.

303
00:12:04,610 --> 00:12:07,720
איך היינו להתחיל להוסיף
פונקציונלי לתכנית זו?

304
00:12:07,720 --> 00:12:14,080
>> ובכן, אני מרגיש כמו הדרך הפשוטה ביותר עלול
להיות לעשות משהו כמו, נניח,

305
00:12:14,080 --> 00:12:16,490
int סטודנטים מזהי.

306
00:12:16,490 --> 00:12:18,380
אז אני יכול לשים את כל תעודות הזהות שלהם שם.

307
00:12:18,380 --> 00:12:22,240
ולאחר מכן, למשהו
כמו מספרי טלפון,

308
00:12:22,240 --> 00:12:24,400
אני לא בטוח איך
מייצג שפשוט עדיין.

309
00:12:24,400 --> 00:12:30,280
אז בואו נלך קדימה ורק שיחה
זה הטוויטר סטודנטים, ש

310
00:12:30,280 --> 00:12:33,550
הוא קצת מוזר, but--
וחבורת שדות נוספת.

311
00:12:33,550 --> 00:12:36,360
>> אני כבר התחלתי בצורה יעילה
להעתיק ולהדביק כאן.

312
00:12:36,360 --> 00:12:39,416
וזה הולך לגדול די
מסורבל די מהר, נכון?

313
00:12:39,416 --> 00:12:42,290
האם לא יהיה זה נחמד אם היו
בעולם מבנה נתונים ידוע

314
00:12:42,290 --> 00:12:45,600
לא כint או מחרוזת, אבל משהו
רמה גבוהה יותר, הפשטה, כך

315
00:12:45,600 --> 00:12:47,570
לדבר, ידוע כתלמיד?

316
00:12:47,570 --> 00:12:50,220
C לא בא עם המובנה
פונקציונלי לסטודנטים,

317
00:12:50,220 --> 00:12:52,260
אבל מה אם אני רוצה לתת לו כזה?

318
00:12:52,260 --> 00:12:55,640
>> ובכן, מתברר, אני הולך
לפתוח קובץ שנקרא structs.h כאן,

319
00:12:55,640 --> 00:12:57,090
ואתה יכול לעשות בדיוק את זה.

320
00:12:57,090 --> 00:12:58,290
ואנחנו הולכים להתחיל לעשות את זה עכשיו.

321
00:12:58,290 --> 00:13:01,490
ומתחת למכסה המנוע של P סט שלוש,
היית כבר עושה את זה עכשיו.

322
00:13:01,490 --> 00:13:05,920
אין דבר כזה כמו rect גרם כזה או
סגלגל גרם בג שפת תכנות

323
00:13:05,920 --> 00:13:10,570
>> אנשים בסטנפורד מיושמים אלה
סוגי נתונים על ידי שימוש בגישה זו לכאן,

324
00:13:10,570 --> 00:13:13,900
הכרזת נתונים החדשים משלהם
סוגי שימוש במילות מפתח חדשים

325
00:13:13,900 --> 00:13:16,744
struct התקשר ועוד
typedef קרא לאחד.

326
00:13:16,744 --> 00:13:19,660
ואכן, למרות שהתחביר
נראה קצת שונה מדברים

327
00:13:19,660 --> 00:13:23,550
שראינו בעבר, ב
עיקרון, זה פשוט סופר.

328
00:13:23,550 --> 00:13:25,297
>> זה רק אומר "מגדיר את סוג."

329
00:13:25,297 --> 00:13:27,255
זה הולך להיות
מבנה, ומבנה

330
00:13:27,255 --> 00:13:29,400
הוא בדיוק כמו מיכל
לדברים מרובים.

331
00:13:29,400 --> 00:13:31,780
והמבנה שהוא הולך
יש מחרוזת קראה בשם,

332
00:13:31,780 --> 00:13:33,210
ומחרוזת שנקראת בית.

333
00:13:33,210 --> 00:13:37,520
ובואו נקרא, רק מטעמי נוחות,
תלמיד זה כל מבנה הנתונים.

334
00:13:37,520 --> 00:13:40,320
>> אז ברגע שאתה מקבל
פסיק, יש לך עכשיו

335
00:13:40,320 --> 00:13:43,280
נוצר נתונים משלך
סטודנט שנקרא סוג

336
00:13:43,280 --> 00:13:46,420
שעומד כיום לצד int,
ולצוף, וchar, ומחרוזת,

337
00:13:46,420 --> 00:13:50,270
וrect גרם, וסגלגל גרם, וכל מספר
דברים אחרים שאנשים המציאו.

338
00:13:50,270 --> 00:13:53,340
>> אז מה שימושי על זה
עכשיו הוא שאם אני חוזר

339
00:13:53,340 --> 00:13:57,430
לstruct 0 ולסיים את זה
יישום, שכתבתי

340
00:13:57,430 --> 00:14:02,080
מראש כאן, שם לב שכל
של את הלכלוכים הבלתי נמנעים ש

341
00:14:02,080 --> 00:14:05,490
עמד להתחיל קורה כמו שאני הוספתי
מספרי טלפון וציוצים ולכל

342
00:14:05,490 --> 00:14:07,370
אלה דברים אחרים
ההגדרה של תלמיד,

343
00:14:07,370 --> 00:14:11,810
עכשיו זה בתמציתיות עטוף
כאחד בלבד מערך של תלמידים.

344
00:14:11,810 --> 00:14:15,500
>> וכל אחד מהתלמידים האלה עכשיו
יש דברים רבים בתוכו.

345
00:14:15,500 --> 00:14:16,930
אז זה משאיר רק שאלה אחת.

346
00:14:16,930 --> 00:14:19,700
איך אתה מקבל בשם,
והבית, ומזהה,

347
00:14:19,700 --> 00:14:21,640
וכל דבר אחר הוא
בתוכו של התלמיד?

348
00:14:21,640 --> 00:14:22,930
סופר פשוט, כמו גם.

349
00:14:22,930 --> 00:14:25,730
תחביר חדש, אבל רעיון פשוט.

350
00:14:25,730 --> 00:14:29,239
>> אתה פשוט מדד לתוך המערך,
כפי שעשינו בשבוע שעבר וזה.

351
00:14:29,239 --> 00:14:31,030
ומה באופן ברור
יצירה חדשה של תחביר?

352
00:14:31,030 --> 00:14:32,590

353
00:14:32,590 --> 00:14:35,880
רק., שפירושו "להיכנס פנימה
מבנה ולקבל בשם השדה

354
00:14:35,880 --> 00:14:39,030
שם, לקבל את השדה שנקרא הבית,
לקבל את השדה שנקרא תלמיד. "

355
00:14:39,030 --> 00:14:41,940
>> אז בP הגדרת שלוש, אם אתה
עדיין עובד על זה,

356
00:14:41,940 --> 00:14:44,020
ורוב האנשים עדיין
הם, מבינים שככל שאתה

357
00:14:44,020 --> 00:14:46,130
להתחיל להשתמש בדברים כמו
rects גרם ואליפסות גרם

358
00:14:46,130 --> 00:14:50,201
ודברים אחרים שלא נראים
לבוא משבוע אפס, אחת, או שתי,

359
00:14:50,201 --> 00:14:52,950
מבין שזה בגלל שסטנפורד
הכריז כמה סוגי נתונים חדשים.

360
00:14:52,950 --> 00:14:56,160
>> ואכן, זה בדיוק מה שנעשינו
כמו גם לעשות,, בP הגדרת ארבע, כאשר

361
00:14:56,160 --> 00:14:59,880
אנחנו מתחילים להתמודד עם דברים
כמו תמונות, מפות סיביות, ועוד.

362
00:14:59,880 --> 00:15:02,882
אז זה רק טיזר ו
מודל מנטלי למה לבוא.

363
00:15:02,882 --> 00:15:04,590
עכשיו, אני התמהמהתי
קצת הבוקר.

364
00:15:04,590 --> 00:15:09,560
אני היה סוג של סקרן לראות מה
הטפט של מיקרוסופט למעשה

365
00:15:09,560 --> 00:15:10,310
נראה כמו היום.

366
00:15:10,310 --> 00:15:15,200
ומתברר שמישהו בשנת 2006
למעשה הלכתי כמעט בדיוק

367
00:15:15,200 --> 00:15:19,210
באותו המקום לצלם במציאות
מה שנראה כמו שבימים אלה.

368
00:15:19,210 --> 00:15:21,380
השדה הוא עכשיו קצת מגודל.

369
00:15:21,380 --> 00:15:24,850
>> אז דיבר עכשיו של תמונות,
בואו להחזיר ךייבן כאן

370
00:15:24,850 --> 00:15:26,890
על המסך וניקולס,
ורק להזכיר לך

371
00:15:26,890 --> 00:15:30,540
שאם אתה רוצה להצטרף אלינו לארוחת צהריים
יום שישי, ראש זה לכתובת האתר הרגילה שלנו

372
00:15:30,540 --> 00:15:31,440
כאן.

373
00:15:31,440 --> 00:15:33,530
>> אז איפה אנחנו לא נעזוב את ביום שני?

374
00:15:33,530 --> 00:15:35,140
אנחנו הצגנו את הבעיה הזו, נכון?

375
00:15:35,140 --> 00:15:37,610
זה היה לכאורה נכון
יישום ההחלפה,

376
00:15:37,610 --> 00:15:40,460
לפיה אתה לוקח שני ints,
אחד בשם, אחד בשם b,

377
00:15:40,460 --> 00:15:44,130
להחליף אותם, בדיוק כמו לורה עשתה כאן
על במה עם חלב והמים,

378
00:15:44,130 --> 00:15:46,820
על ידי שימוש זמני
משתנה, או כוס ריקה,

379
00:15:46,820 --> 00:15:50,540
כדי שנוכל לשים ב וב
ב בלי בלגן של דברים.

380
00:15:50,540 --> 00:15:51,560
אנחנו השתמשנו במשתנה.

381
00:15:51,560 --> 00:15:52,870
זה נקרא זמני.

382
00:15:52,870 --> 00:15:55,520
>> אבל מה שהיה היסוד
בעיה עם הקוד הזה ביום שני?

383
00:15:55,520 --> 00:15:57,700

384
00:15:57,700 --> 00:15:58,870
מה הייתה הבעיה כאן?

385
00:15:58,870 --> 00:16:00,106

386
00:16:00,106 --> 00:16:00,605
כן.

387
00:16:00,605 --> 00:16:01,970
>> קהל: זה לוקח מקום רב יותר.

388
00:16:01,970 --> 00:16:04,719
>> דוד י מלאן: לוקח יותר
חלל, כי אני משתמש משתנה,

389
00:16:04,719 --> 00:16:05,400
וזה בסדר.

390
00:16:05,400 --> 00:16:07,300
זה נכון, אבל אני
הולך להגיד שזה בסדר.

391
00:16:07,300 --> 00:16:10,030
זה רק 32 סיביות בכנף
תכנית של דברים, כל כך לא ביג דיל.

392
00:16:10,030 --> 00:16:10,655
מחשבות אחרות?

393
00:16:10,655 --> 00:16:12,572
קהל: זה מחליף רק
המשתנים מקומיים.

394
00:16:12,572 --> 00:16:13,571
דוד י מלאן: בדיוק.

395
00:16:13,571 --> 00:16:15,090
זה רק מחליף את המשתנים באופן מקומי.

396
00:16:15,090 --> 00:16:18,173
כי בכל פעם שאתה קורא function--
כאשר היה לי את המגשים מאננברג

397
00:16:18,173 --> 00:16:19,840
הפעם האחרונה, יש לך עיקרי בתחתית.

398
00:16:19,840 --> 00:16:23,560
ברגע שאתה קורא לפונקציה שנקראת
החלפה, החלפה לא מקבלת x, y,

399
00:16:23,560 --> 00:16:24,400
הערכים המקוריים.

400
00:16:24,400 --> 00:16:26,392
מה עושה גט החלפה, לא אנחנו טוענים?

401
00:16:26,392 --> 00:16:27,100
קהל: עותקים.

402
00:16:27,100 --> 00:16:28,090
דוד י מלאן: אז עותקים שלהם.

403
00:16:28,090 --> 00:16:31,120
אז זה נהיה אחד ושני, אם אתה
זוכר את הדוגמא מהזמן האחרון,

404
00:16:31,120 --> 00:16:34,730
אבל עותק של אחד ושני
שהם החליפו בהצלחה.

405
00:16:34,730 --> 00:16:38,550
אך למרבה הצער בסופו של הדבר,
ערכים אלה הם עדיין אותו.

406
00:16:38,550 --> 00:16:41,880
אז אנחנו יכולים לראות את זה עם שלנו
חבר חדש, בתקווה GDB,

407
00:16:41,880 --> 00:16:45,180
שיש לך או TFS וCa של
מנחה אותך לכיוון כדלקמן.

408
00:16:45,180 --> 00:16:51,210
>> אז לא זוכרים החלפה נראית like-- בואו
לפתוח את זה- נראה כך.

409
00:16:51,210 --> 00:16:54,160
אנו אותחלו x לאחד, y לשתי.

410
00:16:54,160 --> 00:16:55,620
היה לי חבורה של f של הדפסה.

411
00:16:55,620 --> 00:16:58,080
אבל אז, על המקש החיוג
כאן היה להחליף, ש

412
00:16:58,080 --> 00:17:00,260
זה בדיוק אנחנו הקוד
פשוט ראיתי לפני רגע.

413
00:17:00,260 --> 00:17:03,180
וזה נכון בהתחלה
מבט חטוף, אבל מבחינה תפקודית,

414
00:17:03,180 --> 00:17:06,800
תכנית זה לא עובדת, משום ש
זה לא באופן קבוע להחליף x, y.

415
00:17:06,800 --> 00:17:10,190
>> אז בואו יראו את זה, חם מהיר
עד כאן עם GDB, ./noswap.

416
00:17:10,190 --> 00:17:11,867

417
00:17:11,867 --> 00:17:15,200
חבורה של מידע מכריע ש
אני להיפטר עם בקרת L לעת עתה.

418
00:17:15,200 --> 00:17:17,516
ועכשיו, אני הולך
קדימה ולהפעיל אותו.

419
00:17:17,516 --> 00:17:19,349
ולמרבה הצער, ש
לא היה כל כך שימושי.

420
00:17:19,349 --> 00:17:22,355
הוא רץ את התכנית פנימית של זה
תכנית בשם GDB, הבאגים,

421
00:17:22,355 --> 00:17:23,730
אבל זה לא נתן לי לחטט.

422
00:17:23,730 --> 00:17:26,229
>> אז איך אני יכול בעצם להשהות
ביצוע בתוך תכנית זו?

423
00:17:26,229 --> 00:17:27,410

424
00:17:27,410 --> 00:17:28,329
אז לשבור.

425
00:17:28,329 --> 00:17:32,340
ואני יכול לשבור בכל
שורת מספר, אחד, 10, 15.

426
00:17:32,340 --> 00:17:35,530
אבל אני גם יכול לשבור באופן סמלי
באומרו עיקרי הפסקה.

427
00:17:35,530 --> 00:17:38,980
וזה הולך להגדיר הפסקה
נקודה, כנראה בשורה 16 ​​בעיקרי.

428
00:17:38,980 --> 00:17:40,050
ואיפה הוא קו 16?

429
00:17:40,050 --> 00:17:42,960
בואו נלך עד הקוד
וללכת עד noswap.

430
00:17:42,960 --> 00:17:46,930
ואכן, שורה 16 ​​היא
הראשון בתכנית.

431
00:17:46,930 --> 00:17:52,130
>> אז עכשיו, אם אני הולך קדימה וסוג
לרוץ הפעם, הזן, זה עצר.

432
00:17:52,130 --> 00:17:53,080
אז בואו לחטט.

433
00:17:53,080 --> 00:17:55,716
הדפסת x-- מדוע הוא אפס x?

434
00:17:55,716 --> 00:17:56,705

435
00:17:56,705 --> 00:17:57,830
ולהתעלם מסימן הדולר.

436
00:17:57,830 --> 00:17:59,725
זה רק בשביל להשתכלל
שימוש בתכנית.

437
00:17:59,725 --> 00:18:00,780

438
00:18:00,780 --> 00:18:03,140
למה הוא x אפס באותו הרגע?

439
00:18:03,140 --> 00:18:03,640
כן.

440
00:18:03,640 --> 00:18:07,061
>> קהל: זה עצר ממש לפני
שורה 16, לא ממש על קו 16.

441
00:18:07,061 --> 00:18:08,060
דוד י מלאן: בדיוק.

442
00:18:08,060 --> 00:18:11,630
GDB, כברירת מחדל, הושהה
ביצוע ממש לפני קו 16.

443
00:18:11,630 --> 00:18:14,820
אז זה לא בוצע, ש
משמעות הדבר היא x היא של ערך כלשהו לא ידוע.

444
00:18:14,820 --> 00:18:17,150
ויש לנו מזל שזה
משהו נקי כמו אפס.

445
00:18:17,150 --> 00:18:20,310
אז עכשיו אם אני מקליד הבא,
עכשיו שהיא ביצעה 16.

446
00:18:20,310 --> 00:18:22,000
זה מחכה לי לבצע 17.

447
00:18:22,000 --> 00:18:23,400
תן לי ללכת קדימה וx הדפסה.

448
00:18:23,400 --> 00:18:24,094
זה אחד.

449
00:18:24,094 --> 00:18:25,260
תן לי ללכת קדימה וy הדפסה.

450
00:18:25,260 --> 00:18:26,176
מה אני צריך לראות עכשיו?

451
00:18:26,176 --> 00:18:27,660

452
00:18:27,660 --> 00:18:28,560
>> קהל: [לא ברור]

453
00:18:28,560 --> 00:18:29,165
>> דוד י מלאן: קצת יותר חזק.

454
00:18:29,165 --> 00:18:30,040
>> קהל: [לא ברור]

455
00:18:30,040 --> 00:18:30,537

456
00:18:30,537 --> 00:18:32,120
דוד י מלאן: לא בדיוק קונסנסוס.

457
00:18:32,120 --> 00:18:34,760
אז כן, אנחנו רואים כמה ערך זבל.

458
00:18:34,760 --> 00:18:37,862
עכשיו, y הוא 134514064 שם.

459
00:18:37,862 --> 00:18:39,320
ובכן, זה רק חלק ערך זבל.

460
00:18:39,320 --> 00:18:41,350
התכנית שלי משתמשת בזכרון RAM
למטרות שונות.

461
00:18:41,350 --> 00:18:42,350
יש פונקציות אחרות.

462
00:18:42,350 --> 00:18:44,040
אנשים אחרים כתבו בתוך המחשב שלי.

463
00:18:44,040 --> 00:18:46,789
אז פיסות אלה היו בשימוש במשך
ערכים אחרים, ומה שאני רואה

464
00:18:46,789 --> 00:18:49,470
הוא השרידים של כמה
שימוש קודם בזיכרון ש.

465
00:18:49,470 --> 00:18:53,350
>> אז לא ביג דיל, כי ברגע
כמו שאני מקליד הבא ולאחר מכן להדפיס y,

466
00:18:53,350 --> 00:18:55,640
זה אותחל ל
הערך שאני רוצה.

467
00:18:55,640 --> 00:18:57,400
אז עכשיו, בואו נלך קדימה קצת יותר מהר.

468
00:18:57,400 --> 00:18:58,540
N לבא.

469
00:18:58,540 --> 00:18:59,570
בואו נעשה את זה שוב.

470
00:18:59,570 --> 00:19:00,530
בואו נעשה את זה שוב.

471
00:19:00,530 --> 00:19:02,404
אבל אני לא רוצה לפגוע
זה כאן, כי אם אני

472
00:19:02,404 --> 00:19:05,110
רוצה לראות מה קורה בתוך
של החלפה, מה הפקודה?

473
00:19:05,110 --> 00:19:05,520
>> קהל: צעדים.

474
00:19:05,520 --> 00:19:06,436
>> דוד י מלאן: צעדים.

475
00:19:06,436 --> 00:19:09,800
אז זה ייכנס לי
פונקציה, ולא על זה.

476
00:19:09,800 --> 00:19:12,270
ועכשיו, זה קצת לא ברור מאליהם
בכנות, אבל זה רק

477
00:19:12,270 --> 00:19:14,581
אומר לי שאני בשורה 33 עכשיו.

478
00:19:14,581 --> 00:19:15,580
ובואו נעשיתי את זה שוב.

479
00:19:15,580 --> 00:19:16,080
טמפ הדפסה.

480
00:19:16,080 --> 00:19:17,129

481
00:19:17,129 --> 00:19:20,170
ערך אשפה, שלילי הפעם,
אבל זה רק עדיין ערך זבל.

482
00:19:20,170 --> 00:19:22,810
אז בואו נעשה זמני הבאה, הדפסה.

483
00:19:22,810 --> 00:19:27,130
זה אותחל ל1, ש
היה הערך של x, aka.

484
00:19:27,130 --> 00:19:29,110
>> עכשיו, שבו הם שלנו וx מגיע?

485
00:19:29,110 --> 00:19:32,510
ובכן, שמנו לב בעיקרי, אנחנו
נקרא x, y את הערכים הללו.

486
00:19:32,510 --> 00:19:34,740
לאחר מכן, אנו עוברים אותם כדי להחליף באופן הבא.

487
00:19:34,740 --> 00:19:37,010
X בא קודם, y פסיק.

488
00:19:37,010 --> 00:19:40,020
ולאחר מכן, החלפה יכולה לקרוא להם x, y.

489
00:19:40,020 --> 00:19:42,630
אבל לבהירות, זה
קורא להם וb.

490
00:19:42,630 --> 00:19:45,970
אבל וb עכשיו הולכים להיות
עותקים של x, y, בהתאמה.

491
00:19:45,970 --> 00:19:50,660
>> אז אם אני חוזר לGDB, זמני
כיום הוא אחת וכיום הוא אחת.

492
00:19:50,660 --> 00:19:56,130
אבל אם אני עושה הבא ועכשיו לעשות הדפסה
, כבר עבר.

493
00:19:56,130 --> 00:20:00,030
חלב כבר נשפך לתוך לשעבר
הזכוכית של מיץ תפוזים, או להיפך.

494
00:20:00,030 --> 00:20:04,750
>> ואם אני עושה הבא שוב, ועכשיו
אם אני להדפיס כבדיקת שפיות,

495
00:20:04,750 --> 00:20:07,687
עדיין שני, אבל ב היא כיום אחד.

496
00:20:07,687 --> 00:20:08,770
למען האמת, הוא עדיין שם.

497
00:20:08,770 --> 00:20:10,670
לא אכפת לי מה הוא זמני.

498
00:20:10,670 --> 00:20:16,850
אבל ברגע שאני עכשיו להקליד, נניח,
תמשיך לחזור, עכשיו אני בסופו של הדבר

499
00:20:16,850 --> 00:20:17,480
התכנית.

500
00:20:17,480 --> 00:20:20,730
ולמרבה הצער, x הוא
עדיין אחד וy הוא עדיין שני.

501
00:20:20,730 --> 00:20:22,272
>> אז מה הייתה התועלת של GDB שם?

502
00:20:22,272 --> 00:20:23,980
זה לא עזר לי לתקן
הבעיה כשלעצמה,

503
00:20:23,980 --> 00:20:26,265
אבל אני מקווה שזה יעזור לי
להבין את זה על ידי מימוש

504
00:20:26,265 --> 00:20:30,000
שכן, ההיגיון שלי הוא נכון, אבל
הקוד שלי הוא לא סופו של דבר שיש

505
00:20:30,000 --> 00:20:31,450
השפעה קבועה.

506
00:20:31,450 --> 00:20:34,570
אז זה בעיה שאנחנו
הולך עכשיו לפתור היום.

507
00:20:34,570 --> 00:20:37,870
>> אבל בואו להגיע לשם בדרך של זה.

508
00:20:37,870 --> 00:20:39,230
מחרוזת היא שקר.

509
00:20:39,230 --> 00:20:41,860
זה, יותר מדי, לא סוג הנתונים
שקיים בג זה

510
00:20:41,860 --> 00:20:44,750
היה שם נרדף לכמה
זמן למשהו אחר,

511
00:20:44,750 --> 00:20:47,300
ואנחנו יכולים לגלות שכדלקמן.

512
00:20:47,300 --> 00:20:53,282
>> תנו לי ללכת קדימה, לפתוח את
תכנית בשם להשוות-0.

513
00:20:53,282 --> 00:20:56,240
ובמקום להקליד את זה,
נתחיל ללכת דרך הקוד

514
00:20:56,240 --> 00:20:58,040
אני כבר כתבתי, אבל
זה רק כמה שורות.

515
00:20:58,040 --> 00:20:59,570
אז זה להשוות-0.

516
00:20:59,570 --> 00:21:02,380
והדבר הראשון שאני עושה
הוא מקבל שורת טקסט.

517
00:21:02,380 --> 00:21:05,610
>> אבל שים לב למה שאני
עושה בפעם הראשונה.

518
00:21:05,610 --> 00:21:07,910
מה שונה באופן ברור על קו 21?

519
00:21:07,910 --> 00:21:10,020

520
00:21:10,020 --> 00:21:11,402
למעשה, חכה רגע.

521
00:21:11,402 --> 00:21:12,110
זהו עותק שני.

522
00:21:12,110 --> 00:21:13,568
זה אפילו לא התכנית הנכונה.

523
00:21:13,568 --> 00:21:14,780
כל ההתראה. תקין, ספוילר

524
00:21:14,780 --> 00:21:16,890
בסדר, אז זה לא משנה ש.

525
00:21:16,890 --> 00:21:18,520
זו התשובה לשאלת עתיד.

526
00:21:18,520 --> 00:21:21,450
>> כאן הוא להשוות-0, ואני
על מנת לקבל שורת טקסט.

527
00:21:21,450 --> 00:21:22,435
התכנית של הרבה יותר פשוט.

528
00:21:22,435 --> 00:21:23,560
אז זה הוא פשוט.

529
00:21:23,560 --> 00:21:28,070
זה כמו שבוע אחד, דברים השבוע שני
ברגע. מחרוזת s = GetString.

530
00:21:28,070 --> 00:21:29,700
עכשיו, אני אומר את זה שוב כאן למטה.

531
00:21:29,700 --> 00:21:31,830
מחרוזת t = GetString.

532
00:21:31,830 --> 00:21:35,300
ואז, הדבר האחרון בזה
תכנית, כפי ששמה מרמז,

533
00:21:35,300 --> 00:21:37,090
הוא אני הולך לנסות להשוות אותם.

534
00:21:37,090 --> 00:21:40,709
>> אז אם של, המחרוזת הראשונה,
שווה = t, אז אני

535
00:21:40,709 --> 00:21:42,250
הולך להגיד לך להקליד את אותו הדבר.

536
00:21:42,250 --> 00:21:44,291
אחר, אני הולך לומר
אתה מקליד דברים שונים.

537
00:21:44,291 --> 00:21:45,880
אז בואו לקמפל ולהריץ את התכנית.

538
00:21:45,880 --> 00:21:48,481
אז להפוך להשוות אפס.

539
00:21:48,481 --> 00:21:48,980
נראה טוב.

540
00:21:48,980 --> 00:21:50,490
אין שגיאות הידור.

541
00:21:50,490 --> 00:21:52,386
>> תן לי ללכת קדימה עכשיו
והקלד ./compare-0.

542
00:21:52,386 --> 00:21:55,230

543
00:21:55,230 --> 00:21:59,220
תן לי ללכת קדימה ואומרים משהו
: ךייבן ומשהו: רוב.

544
00:21:59,220 --> 00:22:00,450
ואני מקליד דברים שונים.

545
00:22:00,450 --> 00:22:01,250
עד כה, כל כך טוב.

546
00:22:01,250 --> 00:22:02,680
נראית תכנית תהיה נכון.

547
00:22:02,680 --> 00:22:03,880
>> אבל בואו להפעיל אותו שוב.

548
00:22:03,880 --> 00:22:05,800
תגיד משהו: גייב.

549
00:22:05,800 --> 00:22:07,140
תגיד משהו: גייב.

550
00:22:07,140 --> 00:22:08,520

551
00:22:08,520 --> 00:22:09,020
בסדר.

552
00:22:09,020 --> 00:22:10,851
אולי אני פגע מקש רווח
או משהו פאנקי.

553
00:22:10,851 --> 00:22:11,600
בואו נעשה את זה שוב.

554
00:22:11,600 --> 00:22:13,020
אז Zamyla.

555
00:22:13,020 --> 00:22:13,970

556
00:22:13,970 --> 00:22:14,470
Zamyla.

557
00:22:14,470 --> 00:22:15,740

558
00:22:15,740 --> 00:22:17,330
דברים שונים.

559
00:22:17,330 --> 00:22:19,430
אז מה קורה פה?

560
00:22:19,430 --> 00:22:23,200
>> אז יש לנו שני קווים של אלה
קוד, GetString להיקרא פעמיים.

561
00:22:23,200 --> 00:22:25,760
ואז, אני פשוט
מנסה להשוות ים ולא.

562
00:22:25,760 --> 00:22:28,370
אבל מה שבאמת אז קורה?

563
00:22:28,370 --> 00:22:31,180
ובכן, של כתב היד שלי עומד
לשחוט דוגמא זו במידה מסוימת.

564
00:22:31,180 --> 00:22:34,630
ובואו בעצם לזרוק
כאן, כמו גם את זה.

565
00:22:34,630 --> 00:22:37,390

566
00:22:37,390 --> 00:22:45,712
>> אז יש לנו קו כמו
מחרוזת s = GetString.

567
00:22:45,712 --> 00:22:48,295
אז זה פשוט הראשון
שורה מעניינת מתכנית ש.

568
00:22:48,295 --> 00:22:49,920

569
00:22:49,920 --> 00:22:52,974
אבל מה כל הזמן הזה היה
קורה מתחת למכסת המנוע?

570
00:22:52,974 --> 00:22:55,890
ובכן, בצד השמאל הוא מחרוזת,
אשר הוא איזה סוג של משתנה,

571
00:22:55,890 --> 00:22:56,785
וזה נקרא ים.

572
00:22:56,785 --> 00:23:00,019
אז אני יודע שזו היא באמצעות זיכרון,
או זיכרון RAM, במחשב שלי איכשהו.

573
00:23:00,019 --> 00:23:02,060
אז אני הולך למופשט
לצייר את זה ככיכר.

574
00:23:02,060 --> 00:23:04,820
32 סיביות, מתברר, אבל
עוד על כך בעתיד.

575
00:23:04,820 --> 00:23:06,410
ואז, מה קורה כאן?

576
00:23:06,410 --> 00:23:08,700
>> ובכן, GetString ברור
מקבל מחרוזת מהמשתמש.

577
00:23:08,700 --> 00:23:11,360
וGetString לי
Zamyla או גייב או ךייבן.

578
00:23:11,360 --> 00:23:14,640
אז בואו לבחור הראשון
של אלה, שהיה ךייבן.

579
00:23:14,640 --> 00:23:19,174
כל כך יעיל, מה GetString לי
לי שבמקרה הראשון היה D--v-e-n.

580
00:23:19,174 --> 00:23:22,690

581
00:23:22,690 --> 00:23:25,045
ואז, מה עוד עשה
זה ייתן לי בסתר?

582
00:23:25,045 --> 00:23:25,920
קהל: [לא ברור]

583
00:23:25,920 --> 00:23:28,720
דוד י מלאן: כן,
האופי / 0 או null.

584
00:23:28,720 --> 00:23:30,550
כך שלמעשה הוא נתן לי מחרוזת.

585
00:23:30,550 --> 00:23:34,550
אבל אנחנו כבר יודעים מקודמים
נראה שמחרוזת היא פשוט מערך

586
00:23:34,550 --> 00:23:37,895
של דמויות, וזה הופסק על ידי
אופי זקיף המיוחד הזה, / 0.

587
00:23:37,895 --> 00:23:39,220

588
00:23:39,220 --> 00:23:42,310
>> אבל אם זה נכון
וזה הוא ריבוע,

589
00:23:42,310 --> 00:23:44,160
זה ברור מלבן גדול הרבה יותר.

590
00:23:44,160 --> 00:23:46,830
ואכן, זו היא,
אני טוען, רק 32 סיביות.

591
00:23:46,830 --> 00:23:49,500
וברור שזה יותר מ 32
ביטים, כי זה כנראה

592
00:23:49,500 --> 00:23:51,583
שמונה ועוד שמונה בתוספת שמונה
בתוספת שמונה בתוספת שמונה,

593
00:23:51,583 --> 00:23:53,320
רק בגלל הבתים בASCII.

594
00:23:53,320 --> 00:23:57,030
איך לעזאזל אנחנו הולכים כדי שיתאימו
להתפלל לקופסה קטנה הזאת כאן?

595
00:23:57,030 --> 00:23:59,880
>> ובכן, מה שGetString בעצם עושה?

596
00:23:59,880 --> 00:24:03,680
ובכן, רשת זו כאן מייצגת
הזיכרון של המחשב שלי או זיכרון RAM.

597
00:24:03,680 --> 00:24:07,564
אז בואו באופן שרירותי אומרים שאם
כל אחד מאלה מייצג בייט,

598
00:24:07,564 --> 00:24:09,730
אז אנחנו יכולים לחשוב על כל
בתים כבעל כתובת,

599
00:24:09,730 --> 00:24:13,830
כמו רחוב 33 אוקספורד, או 34
רחוב אוקספורד רחוב אוקספורד, או 35.

600
00:24:13,830 --> 00:24:16,700
>> אז בדיוק כמו שיש לי בתי כתובות
ויש לי בנייני כתובות,

601
00:24:16,700 --> 00:24:19,810
כך גם בתים בודדים של
יש לי זיכרון כתובות או מספרים

602
00:24:19,810 --> 00:24:21,042
כי לזהות.

603
00:24:21,042 --> 00:24:22,000
עכשיו, זה הוא שרירותי.

604
00:24:22,000 --> 00:24:25,370
אבל לשמור את זה פשוט, אני הולך
להשתמש הקסדצימלי רק על ידי אמנה,

605
00:24:25,370 --> 00:24:28,200
אבל 0x לא אומר כלום אחר
מ "זה הקסדצימלי."

606
00:24:28,200 --> 00:24:31,030
ואני הולך לטעון ש
"D" בסופו של בבית אחד בזיכרון.

607
00:24:31,030 --> 00:24:34,210
>> יש לי שום דבר אחר שקורה ב
זיכרון, כך ךייבן קיבל את המקום הראשון

608
00:24:34,210 --> 00:24:35,509
בבית אחד.

609
00:24:35,509 --> 00:24:36,800
זהו, אם כן, הולך להיות 0x2.

610
00:24:36,800 --> 00:24:37,831

611
00:24:37,831 --> 00:24:38,705
זה הולך 0x3.

612
00:24:38,705 --> 00:24:39,840

613
00:24:39,840 --> 00:24:41,800
זה הולך להיות 0x4.

614
00:24:41,800 --> 00:24:43,025
זה הולך 0x5.

615
00:24:43,025 --> 00:24:44,025
זה הולך להיות 0x6.

616
00:24:44,025 --> 00:24:45,560

617
00:24:45,560 --> 00:24:48,290
>> אבל ברגע שאתה מתחיל לחשוב
על מה עושה את של המחשב

618
00:24:48,290 --> 00:24:50,710
מתחת למכסה המנוע,
אתה יכול להתחיל להסיק

619
00:24:50,710 --> 00:24:54,960
איך אתה, לפני כמה שנים, היית
יישמתי C עצמו.

620
00:24:54,960 --> 00:24:58,360
מה הוא GetString כנראה
returning-- כי זה

621
00:24:58,360 --> 00:25:00,946
מרגיש שזה לא
חוזר ךייבן, כשלעצמה,

622
00:25:00,946 --> 00:25:03,320
בגלל שהוא בוודאי לא הולך
כדי להתאים בbox-- הקטן הזה

623
00:25:03,320 --> 00:25:05,090
אז מה הוא GetString כנראה חוזר?

624
00:25:05,090 --> 00:25:07,958

625
00:25:07,958 --> 00:25:08,920
>> קהל: [לא ברור]

626
00:25:08,920 --> 00:25:10,540
>> דוד י מלאן: המיקום של ךייבן.

627
00:25:10,540 --> 00:25:12,770
וזה כבר עושה את זה
מאז שבוע אחד.

628
00:25:12,770 --> 00:25:16,150
מה GetString הוא באמת
חוזר הוא לא מחרוזת, כשלעצמו.

629
00:25:16,150 --> 00:25:17,780
זה אחד השקרים הלבנים הקטנים.

630
00:25:17,780 --> 00:25:22,520
זה מחזיר את הכתובת של
מחרוזת בזיכרון, הכתובת הייחודית.

631
00:25:22,520 --> 00:25:24,820
להתפלל מתגורר ברחוב אוקספורד 33.

632
00:25:24,820 --> 00:25:29,310
אבל באופן תמציתי יותר, גאווין חי
ב0x1, כתובת מספר אחת.

633
00:25:29,310 --> 00:25:32,280
>> אז מה מקבל לשים את זה
קופסא קטנה אז, שתהיה ברורה,

634
00:25:32,280 --> 00:25:35,930
רק את הכתובת של מחרוזת ש.

635
00:25:35,930 --> 00:25:38,110
אז כל הזמן הזה, זה
יש כבר קורה.

636
00:25:38,110 --> 00:25:41,650
אבל מה זה מרמז על
כרגע הוא אם כל זה שיש לו

637
00:25:41,650 --> 00:25:44,710
הוא מספר בתוכו, מי
לעצור אותך, מתכנת,

638
00:25:44,710 --> 00:25:47,970
מלשים כל מספר ב
כל משתנה ופשוט קופץ

639
00:25:47,970 --> 00:25:49,080
לנתח זה של זיכרון?

640
00:25:49,080 --> 00:25:51,320
ואכן, אנו רואים
זה בפעם הבאה איום.

641
00:25:51,320 --> 00:25:53,500
>> אבל לעת עתה, זה מרגיש לא מספיק.

642
00:25:53,500 --> 00:25:55,630
אם אני אומר, תבין אותי
מחרוזת, אתה נותן לי ךייבן.

643
00:25:55,630 --> 00:25:57,230
אבל אתה לא באמת נותן לי ךייבן.

644
00:25:57,230 --> 00:25:59,310
כל מה שאתה נותן לי הכתובת של דייבן.

645
00:25:59,310 --> 00:26:04,310
איך אני מכן יודע בודאות
בי ךייבן מתחיל וends--

646
00:26:04,310 --> 00:26:07,140
סיפורו של מקבל weird--
בי ךייבן מתחיל ונגמר,

647
00:26:07,140 --> 00:26:10,435
ולאחר מכן, בסמוך
מחרוזת בזיכרון מתחילה?

648
00:26:10,435 --> 00:26:11,520

649
00:26:11,520 --> 00:26:13,620
>> ובכן, אם אתה מוסר
לי בתחילת ךייבן,

650
00:26:13,620 --> 00:26:17,230
בעצם, איך אני אדע
איפה הסוף של השם שלו הוא?

651
00:26:17,230 --> 00:26:20,550
כי אופי null מיוחד, ש
הוא כל כך חשוב יותר עכשיו

652
00:26:20,550 --> 00:26:23,040
אם מחרוזות מתחת
מכסה המנוע הוא פשוט זיהה

653
00:26:23,040 --> 00:26:25,820
באופן ייחודי על ידי מיקומם בזיכרון.

654
00:26:25,820 --> 00:26:28,130
אז כל הזמן הזה, זה
מה שקורה.

655
00:26:28,130 --> 00:26:32,470
>> לכן, כאשר אנחנו מסתכלים עכשיו ב
הקוד כאן, להסביר

656
00:26:32,470 --> 00:26:35,790
אם היית באג בשורה 26.

657
00:26:35,790 --> 00:26:39,560
למה הוא שונה Zamyla וZamyla?

658
00:26:39,560 --> 00:26:41,330
למה הוא שונה גייב וגייב?

659
00:26:41,330 --> 00:26:42,154
כן, בגב.

660
00:26:42,154 --> 00:26:43,390
>> קהל: יש להם כתובות שונות.

661
00:26:43,390 --> 00:26:45,931
>> דוד י מלאן: פשוט כי
יש להם כתובות שונות.

662
00:26:45,931 --> 00:26:48,820
כי כשאתה קורא GetString
שוב, שאני אעשה במהירות כאן,

663
00:26:48,820 --> 00:26:52,870
אם זה קו השני, המחרוזת
t, כפי שעשיתי בתכנית ש,

664
00:26:52,870 --> 00:26:55,030
שווה שיחה נוספת לGetString.

665
00:26:55,030 --> 00:26:56,370

666
00:26:56,370 --> 00:26:58,670
בפעם הבאה שאני קורא
GetString, אני הולך

667
00:26:58,670 --> 00:27:00,190
כדי לקבל נתח של זיכרון שונה.

668
00:27:00,190 --> 00:27:02,220
>> GetString מותר
לשאול ההפעלה

669
00:27:02,220 --> 00:27:03,800
מערכת ליותר ויותר זיכרון.

670
00:27:03,800 --> 00:27:07,894
זה לא הולך לשימוש חוזר באותה
שישה בתים בכל פעם.

671
00:27:07,894 --> 00:27:09,810
זה הולך לקבל חדש
נתח של זיכרון, ש

672
00:27:09,810 --> 00:27:12,780
משמעות הדבר היא לא הולך לקבל
ערך אחר לכאן.

673
00:27:12,780 --> 00:27:15,380
>> לכן, כאשר אני עושה את של שווה =
t, אתה לא משווה

674
00:27:15,380 --> 00:27:17,880
D נגד זה ונגד
זה וV נגד זה.

675
00:27:17,880 --> 00:27:19,588
אתה משווה את זה
נגד זה, ש

676
00:27:19,588 --> 00:27:24,020
כנות הוא useless-- די useful--
הוא די חסר תועלת, כי מי באמת

677
00:27:24,020 --> 00:27:25,830
אכפת איפה המחרוזות נמצאות בזיכרון?

678
00:27:25,830 --> 00:27:26,850
>> ואכן, יש לנו לא.

679
00:27:26,850 --> 00:27:28,980
ואנחנו לא מתכוונים ל
להתחיל במיוחד אכפתיות.

680
00:27:28,980 --> 00:27:34,180
רק במידה שחרקים יכולים להתעורר
ואיומי אבטחה עלולים להתעורר רצון

681
00:27:34,180 --> 00:27:36,100
אנחנו באמת להתחיל לדאוג בקשר לזה.

682
00:27:36,100 --> 00:27:37,230
אז בואו לתקן את הבעיה הזו.

683
00:27:37,230 --> 00:27:39,650
מתברר, לך לתקן את זה סופר פשוט.

684
00:27:39,650 --> 00:27:42,600
>> ובואו למעשה, לפני ש
לחשוף את זה שוב, מה היית עושה

685
00:27:42,600 --> 00:27:47,170
אתה עושה אם בכיתת CS50,
והיה לך ליישום

686
00:27:47,170 --> 00:27:48,600
השוואה נגד שתי מחרוזות.

687
00:27:48,600 --> 00:27:51,440
אתה בבירור לא יכול פשוט להשתמש ים שווה = t.

688
00:27:51,440 --> 00:27:54,090
אבל רק מבחינה לוגית, איך
היית משווה את המחרוזת

689
00:27:54,090 --> 00:27:56,370
נגד מחרוזת זו באמצעות קוד C?

690
00:27:56,370 --> 00:27:56,880
כן.

691
00:27:56,880 --> 00:27:58,780
>> קהל: פשוט תעשה
ללולאה [לא ברורה]

692
00:27:58,780 --> 00:28:00,670

693
00:28:00,670 --> 00:28:01,670
דוד י מלאן: מושלם.

694
00:28:01,670 --> 00:28:02,900
קהל: [לא ברור]

695
00:28:02,900 --> 00:28:03,310
דוד י מלאן: כן.

696
00:28:03,310 --> 00:28:05,390
פשוט להשתמש בלולאה for או
בעוד לולאה או מה.

697
00:28:05,390 --> 00:28:08,710
אבל רק ליישם את הרעיון הבסיסי שאם
זה נתח של זיכרון או מערך

698
00:28:08,710 --> 00:28:11,590
וזה, לחזר על
שניהם באותו הזמן.

699
00:28:11,590 --> 00:28:12,960
ורק להשוות את המכתבים.

700
00:28:12,960 --> 00:28:14,260
>> ואתה חייב להיות
קצת זהיר, כי אתה

701
00:28:14,260 --> 00:28:16,247
לא רוצה אצבע אחת
ללכת העבר האחר

702
00:28:16,247 --> 00:28:18,080
כי מחרוזת אחת היא
יותר מאחר.

703
00:28:18,080 --> 00:28:21,380
אז אתה הולך רוצה לבדוק
הערך המיוחד הזה בסוף, null.

704
00:28:21,380 --> 00:28:24,017
אבל זה באמת, ב
הסוף, פשוט כמו ש.

705
00:28:24,017 --> 00:28:26,100
ולמען אמת, אנחנו לא צריכים
להמציא מחדש את הגלגל ש.

706
00:28:26,100 --> 00:28:27,960
הנה גרסה השנייה.

707
00:28:27,960 --> 00:28:32,910
ומה שאני הולך להגיד כאן הוא ש
במקום להשוות ים שווה = t,

708
00:28:32,910 --> 00:28:38,964
אני במקום שאני מתכוון לומר, אם מחרוזת
השוואה של t הפסיק של שווה = 0.

709
00:28:38,964 --> 00:28:40,130
עכשיו, מה שהמחרוזת להשוות?

710
00:28:40,130 --> 00:28:43,046
>> מתברר, שזה פונקציה ש
מגיע עם C, שמטרתו בחיים

711
00:28:43,046 --> 00:28:44,650
הוא להשוות בין שתי מחרוזות.

712
00:28:44,650 --> 00:28:48,300
ומערבבים להשוות, אם אנו קוראים
דף גבר או תיעוד או CS50

713
00:28:48,300 --> 00:28:50,630
התייחסות, זה יהיה
פשוט להגיד לך התרגשות ש

714
00:28:50,630 --> 00:28:55,730
להשוות תשואות או שליליות
מספר או מספר חיובי או אפס,

715
00:28:55,730 --> 00:28:57,660
שבו אפס אומר שהם שווים.

716
00:28:57,660 --> 00:28:58,570
>> אז רק השערה.

717
00:28:58,570 --> 00:29:00,390
מה יכול זה אומר אם
מערבבים חוזרים להשוות

718
00:29:00,390 --> 00:29:02,110
ערך שלילי או ערך חיובי?

719
00:29:02,110 --> 00:29:02,785

720
00:29:02,785 --> 00:29:04,285
קהל: גדול או פחות מ.

721
00:29:04,285 --> 00:29:05,570
דוד י מלאן: כן,
גדול או פחות מ.

722
00:29:05,570 --> 00:29:08,640
אז אם אתה רוצה למיין את כל
חבורה של מחרוזות בdictionary--

723
00:29:08,640 --> 00:29:12,975
כפי שסופו של דבר את road--
פונקציה מושלמת לשימוש פוטנציאלי,

724
00:29:12,975 --> 00:29:15,850
כי זה הולך לעשות את זה
השוואה של מחרוזות בשבילך, ואומר לי

725
00:29:15,850 --> 00:29:20,060
אתה עושה מגיע לפני b, או עושה
ב לבוא לפני בסדר אלפביתי.

726
00:29:20,060 --> 00:29:21,490
אנחנו יכולים לעשות בדיוק את זה.

727
00:29:21,490 --> 00:29:23,620
>> ואני שם לב שעשיתי אחד אחר
דבר בדוגמא זו.

728
00:29:23,620 --> 00:29:26,870
מה עוד השתנה גבוה יותר
בתפקידו העיקרי זה?

729
00:29:26,870 --> 00:29:28,500

730
00:29:28,500 --> 00:29:29,350
תו *.

731
00:29:29,350 --> 00:29:31,150
וזו היא שהשקר לבן אחר.

732
00:29:31,150 --> 00:29:33,750
כל הזמן הזה, כאשר יש לך
כותב מחרוזת,

733
00:29:33,750 --> 00:29:38,350
יש לנו כבר שכתוב בחשאי
מחרוזת כמו char * כל כך צלצול שלמעשה

734
00:29:38,350 --> 00:29:39,270
מבין אותך.

735
00:29:39,270 --> 00:29:42,450
>> במילים אחרות, בCS50.h
וכפי שאנו רואים את סופו של דבר,

736
00:29:42,450 --> 00:29:45,950
עשינו מחרוזת מילה נרדפת נקראת
זה אותו דבר כמו char *.

737
00:29:45,950 --> 00:29:49,910
ולעת עתה, רק יודע ש
*, בהקשר זה, לפחות,

738
00:29:49,910 --> 00:29:51,286
משמעות הדבר היא הכתובת.

739
00:29:51,286 --> 00:29:52,210
>> הכתובת של מה?

740
00:29:52,210 --> 00:29:56,390
ובכן, העובדה שאמרתי
* Char, ולא int * או לצוף *,

741
00:29:56,390 --> 00:30:00,820
משמעות הדבר היא כי char * הוא
הכתובת של char.

742
00:30:00,820 --> 00:30:06,770
אז הקופסה קטנה הזאת כאן, aka
מחרוזת, הוא באמת של char * סוג,

743
00:30:06,770 --> 00:30:10,490
וזה פשוט דרך מפוארת לומר,
בתיבה זו תלך כתובת.

744
00:30:10,490 --> 00:30:12,430
ומה כתובת שאמנם מתייחסת ל?

745
00:30:12,430 --> 00:30:13,780
ככל הנראה, char.

746
00:30:13,780 --> 00:30:16,410
>> אבל אנחנו בהחלט יכולים
יש לי * int ודברים אחרים.

747
00:30:16,410 --> 00:30:20,790
אבל לעת עתה, char * הוא באמת הכי
פשוט ואחד של עניין.

748
00:30:20,790 --> 00:30:23,310
אז בעיה זה הולכת
לעלות, אם כי, שוב.

749
00:30:23,310 --> 00:30:24,830
>> נניח שאני פותח את התכנית הזאת.

750
00:30:24,830 --> 00:30:27,670
בואו תראו אם עכשיו אנחנו יכולים לחזות
מה לא בסדר עם הקוד הזה.

751
00:30:27,670 --> 00:30:31,140
אז בתכנית זו, להעתיק-0, אני
הולך קדימה ושוב קוראים

752
00:30:31,140 --> 00:30:34,190
GetString ולאחסן את הערך בים.

753
00:30:34,190 --> 00:30:38,800
>> ולאחר מכן, למה אני עושה את זה,
רק כתזכורת מהעבר שבועות?

754
00:30:38,800 --> 00:30:40,960
עשינו לומר GetString ש
לפעמים מחזיר null.

755
00:30:40,960 --> 00:30:42,793
מה זה אומר אם
GetString מחזיר null?

756
00:30:42,793 --> 00:30:45,040

757
00:30:45,040 --> 00:30:46,034
משהו השתבש.

758
00:30:46,034 --> 00:30:48,950
זה כנראה אומר שהמחרוזת היא מדי
גדול, את המחשב של זיכרון.

759
00:30:48,950 --> 00:30:51,724
זה קורה סופר, סופר, סופר
לעתים רחוקות, אבל זה יכול לקרות.

760
00:30:51,724 --> 00:30:53,890
אנחנו רוצים לבדוק את זה,
וזה כל מה שאנחנו עושים.

761
00:30:53,890 --> 00:30:57,910
>> כי אנחנו רואים עכשיו, אם לא
להתחיל לבדוק נוהגים לדברים

762
00:30:57,910 --> 00:31:00,870
כמו null, אתה עלול
בעצם להתחיל ללכת

763
00:31:00,870 --> 00:31:03,106
לכתובות בזיכרון שאינם חוקיים.

764
00:31:03,106 --> 00:31:05,980
ואתה הולך להתחיל התרמה
יותר ויותר תקלות פילוח.

765
00:31:05,980 --> 00:31:08,360
או במקינטוש או PC, פשוט
גורם למחשב להיתקע

766
00:31:08,360 --> 00:31:10,340
או תכנית להקפאה, באופן פוטנציאלי.

767
00:31:10,340 --> 00:31:14,930
>> אז עכשיו, אני טוען בעותק-0.c, ש
אני הולך להעתיק מחרוזות אלה בדרך

768
00:31:14,930 --> 00:31:15,685
של קו 28.

769
00:31:15,685 --> 00:31:16,850

770
00:31:16,850 --> 00:31:18,750
ולאחר מכן, אני הולך
לטעון שבתחתית

771
00:31:18,750 --> 00:31:21,430
כאן שאני הולך
כדי לשנות את אחד מהם.

772
00:31:21,430 --> 00:31:22,330
>> אז שם לב זה.

773
00:31:22,330 --> 00:31:24,370
אני מתקשר strlen ידידנו הוותיק.

774
00:31:24,370 --> 00:31:28,960
ורק להסביר באנגלית
מה הקו הזה 34 עושה?

775
00:31:28,960 --> 00:31:32,480
מה עושה סוגר t 0
מייצג בצד השמאל.

776
00:31:32,480 --> 00:31:32,980
כן.

777
00:31:32,980 --> 00:31:34,339
>> קהל: דמות ראשונה של t?

778
00:31:34,339 --> 00:31:35,880
דוד י מלאן: דמות הראשונה של t.

779
00:31:35,880 --> 00:31:36,379
זהו זה.

780
00:31:36,379 --> 00:31:40,024
תו הראשון של t, אני רוצה
כדי להקצות את גרסתו באותיות גדולות

781
00:31:40,024 --> 00:31:41,190
של התו הראשון בt.

782
00:31:41,190 --> 00:31:43,200
אז זה הוא ניצול
המכתב הראשון.

783
00:31:43,200 --> 00:31:46,340
ואז, הדבר האחרון שאני עושה
בתכנית זו היא שאני טוען כאן

784
00:31:46,340 --> 00:31:50,340
המקורי, זה, והנה ההעתק, t.

785
00:31:50,340 --> 00:31:54,610
>> אבל מבוסס על הסיפור שרק
סיפר ​​על מה שמחרוזות באמת,

786
00:31:54,610 --> 00:31:57,520
מה הוא קו 28 באמת
עושה, ומה הוא

787
00:31:57,520 --> 00:31:59,405
באג וכתוצאה מכך הולך
להיות על המסך?

788
00:31:59,405 --> 00:32:01,300

789
00:32:01,300 --> 00:32:03,500
>> אז קודם כל, השאלה הראשונה, 28.

790
00:32:03,500 --> 00:32:09,040
מה = t המחרוזת של עושה הוא באמת?

791
00:32:09,040 --> 00:32:16,430
אם יש לנו ביד השמאל
צד כאן = t מחרוזת s;

792
00:32:16,430 --> 00:32:19,400
זה נותן לי קופסא אחת
כאן והתיבה אחת כאן.

793
00:32:19,400 --> 00:32:25,530
ונניח שכתובת זו היא 0x,
נניח, 50 הפעם, באופן שרירותי.

794
00:32:25,530 --> 00:32:28,847
מה עושה = t המחרוזת של
לעשות מתחת למכסת המנוע?

795
00:32:28,847 --> 00:32:30,340
>> קהל: [לא ברור]

796
00:32:30,340 --> 00:32:34,100
>> דוד י מלאן: הוא מאחסן את הזיכרון
לטפל שם, אז 0x50 הולך לשם.

797
00:32:34,100 --> 00:32:37,980
אז אם עכשיו, אני הולך לראשון
דמות בt ואותיות גדולות זה,

798
00:32:37,980 --> 00:32:39,535
מה שאני למעשה אני עושה לים?

799
00:32:39,535 --> 00:32:41,300

800
00:32:41,300 --> 00:32:43,450
אני באמת עושה את אותו דבר, נכון?

801
00:32:43,450 --> 00:32:47,680
כי אם כתובת 0x50-- ורק, אני
אין להם הרבה מקום על הלוח כאן,

802
00:32:47,680 --> 00:32:51,750
אבל תניח שזה 0x50 כאן למטה,
אי שם בזיכרון של המחשב שלי.

803
00:32:51,750 --> 00:32:55,825
>> ויש לי, למשל, גייב
באותיות קטנות כאן, כמו זה.

804
00:32:55,825 --> 00:32:57,120

805
00:32:57,120 --> 00:33:01,980
ויש לי אמר סוגר t
0 מקבל מהוונים.

806
00:33:01,980 --> 00:33:04,860
ובכן, סוגר t 0 הוא
את האות הראשונה בt.

807
00:33:04,860 --> 00:33:07,840
אז גרם קצת הולך
ג הגדול להיות אבל הבעיה

808
00:33:07,840 --> 00:33:09,410
הוא, מה זה גם מצביע על?

809
00:33:09,410 --> 00:33:10,300
>> קהל: אותו הדבר.

810
00:33:10,300 --> 00:33:11,841
>> דוד י מלאן: אותו דבר בדיוק.

811
00:33:11,841 --> 00:33:16,342
אז הסבר פשוט אולי,
גם אם התחביר הוא קצת מוזר.

812
00:33:16,342 --> 00:33:17,050
אז בואו נעשיתי את זה.

813
00:33:17,050 --> 00:33:20,210
להכין עותק-0 ולאחר מכן ./copy-0.

814
00:33:20,210 --> 00:33:21,820

815
00:33:21,820 --> 00:33:24,110
תגיד משהו: גייב.

816
00:33:24,110 --> 00:33:26,760
ולרוע מזל, שניהם
שלהם עכשיו הוון,

817
00:33:26,760 --> 00:33:29,500
אבל בשביל זה שבבסיס
סיבה שאנחנו פשוט

818
00:33:29,500 --> 00:33:32,350
עכשיו התמודדות עם כתובות.

819
00:33:32,350 --> 00:33:36,470
>> אז איך אנחנו מתחילים
address-- לא משחק מלים intended--

820
00:33:36,470 --> 00:33:39,270
איך אנחנו מתחילים לטפל
בעיה המסוימת הזה?

821
00:33:39,270 --> 00:33:44,400
ובכן, בcopy1.c, דברים הולכים
כדי לקבל קצת יותר מסובך.

822
00:33:44,400 --> 00:33:49,310
אבל אני טוען
פתרון פשוט מבחינה מושגית.

823
00:33:49,310 --> 00:33:50,852
>> כל כך קשה להשיג במבט ראשון.

824
00:33:50,852 --> 00:33:53,560
לא הולך להיות קל לראשון
פעם שאתה מקליד את זה, אולי,

825
00:33:53,560 --> 00:33:57,440
אבל אם הבעיה היא ש
פשוט עושה = T S רק

826
00:33:57,440 --> 00:33:59,694
עותקי כתובת, מה,
שוב, אם אני יכול להרים עליך,

827
00:33:59,694 --> 00:34:02,110
הולך להיות הפתרון
לבעצם העתקת מחרוזת?

828
00:34:02,110 --> 00:34:04,906

829
00:34:04,906 --> 00:34:06,770
>> קהל: כנראה ש
להשתמש בלולאה שוב.

830
00:34:06,770 --> 00:34:06,890
>> דוד י מלאן: כן.

831
00:34:06,890 --> 00:34:08,390
אז אנחנו הולכים לצריכים לולאה שוב.

832
00:34:08,390 --> 00:34:11,800
וכי אם ברצוננו להעתיק
מחרוזת s למחרוזת אחרת,

833
00:34:11,800 --> 00:34:14,120
אנחנו כנראה רוצים לעשות את זה
תו אחרי תו.

834
00:34:14,120 --> 00:34:17,199
אבל הבעיה היא, אם
זה הוא מקור של,

835
00:34:17,199 --> 00:34:22,159
עכשיו אנחנו צריכים להתחיל באופן מפורש
הקצאת זיכרון עבור t.

836
00:34:22,159 --> 00:34:24,320
>> במילים אחרות, בואו
לצייר מחדש בפעם האחרונה זה אחד.

837
00:34:24,320 --> 00:34:28,659
אם זה מחרוזת s = GetString.

838
00:34:28,659 --> 00:34:30,956

839
00:34:30,956 --> 00:34:32,455
ובואו נשים את זה כאן, גם כן.

840
00:34:32,455 --> 00:34:36,639

841
00:34:36,639 --> 00:34:37,420
זה GetString.

842
00:34:37,420 --> 00:34:39,070

843
00:34:39,070 --> 00:34:43,860
ולאחר מכן, את התמונה למשהו
כמו שהוא הולך להיות כמו קודם,

844
00:34:43,860 --> 00:34:44,360
g--b-e-/ 0.

845
00:34:44,360 --> 00:34:47,294

846
00:34:47,294 --> 00:34:48,960
זה נראה משהו קטן כזה.

847
00:34:48,960 --> 00:34:53,650
וים ולכן, אנחנו קוראים לזה 0x50,
וזה הולך להיות 51, 52.

848
00:34:53,650 --> 00:34:54,409
>> אז זה 0x50.

849
00:34:54,409 --> 00:34:55,679

850
00:34:55,679 --> 00:34:59,690
ולאחר מכן, אני עושה לא מחרוזת.

851
00:34:59,690 --> 00:35:02,450
בזיכרון, שרק הולך
תן לי קצת מרובע כמו זה.

852
00:35:02,450 --> 00:35:04,080
אז מה צעד מפתח עכשיו?

853
00:35:04,080 --> 00:35:09,870
אם אני רוצה להעתיק s לתוך t, מה
ריק אנחנו צריכים למלא כאן?

854
00:35:09,870 --> 00:35:12,050
או מה שאנחנו צריכים לעשות כדי
לעשות ברמה גבוהה?

855
00:35:12,050 --> 00:35:14,101

856
00:35:14,101 --> 00:35:14,600
כן?

857
00:35:14,600 --> 00:35:16,200

858
00:35:16,200 --> 00:35:17,020
מישהו?

859
00:35:17,020 --> 00:35:17,690
כן.

860
00:35:17,690 --> 00:35:19,214
>> קהל: אנחנו צריכים [לא ברורים].

861
00:35:19,214 --> 00:35:21,380
דוד י מלאן: כן, אנחנו
צריך למלא ריק זה.

862
00:35:21,380 --> 00:35:24,340
אני לא יכול להעתיק ולאחר מכן
לנצל את שמו של גייב

863
00:35:24,340 --> 00:35:28,120
עד שאני שואל את מערכת ההפעלה
עבור נתח נוסף של זיכרון

864
00:35:28,120 --> 00:35:30,640
זה לפחות גדול כמו מקורי.

865
00:35:30,640 --> 00:35:32,130
אז זה משאיר אותנו עם שאלה.

866
00:35:32,130 --> 00:35:36,080
>> איך אני שואל את מערכת ההפעלה לא
רק בשביל pointer-- קטן ופשוט

867
00:35:36,080 --> 00:35:38,530
כזה נקרא,
כתובת, pointer-- לא

868
00:35:38,530 --> 00:35:40,980
לתיבה קטנה ופשוט
כמו הזה שנקרא מחרוזת?

869
00:35:40,980 --> 00:35:44,200
איך אני שואל את ההפעלה
מערכת לנתח גדול של זיכרון?

870
00:35:44,200 --> 00:35:48,430
עד כה, אני כבר רק קיבלתי בחזרה ש
בעקיפין על ידי קורא GetString.

871
00:35:48,430 --> 00:35:50,740
אז איך GetString
אפילו מקבל את הזיכרון שלה?

872
00:35:50,740 --> 00:35:53,430
>> ובכן, מתברר שיש
פונקציה כאן אחרת זה

873
00:35:53,430 --> 00:35:55,160
שאנחנו עכשיו נתחיל להשתמש.

874
00:35:55,160 --> 00:35:59,780
עכשיו, זה נראה than-- דרך יותר נסתר
ואני יחיד שיכול לראות it--

875
00:35:59,780 --> 00:36:03,150
קו זה נראה הרבה יותר מסתורי
אז זה צריך במבט ראשון.

876
00:36:03,150 --> 00:36:04,650
אבל בואו להקניט אותו לגזרים.

877
00:36:04,650 --> 00:36:07,950
>> בצד השמאל, יש לי char * t.

878
00:36:07,950 --> 00:36:13,280
אז באנגלית, בואו נתחיל לגבש
משפטים נכונים בז'רגון טכני.

879
00:36:13,280 --> 00:36:19,757
אז זה הקצאה
משתנה מסוג char * נקרא t.

880
00:36:19,757 --> 00:36:21,090
עכשיו, מה זה באמת אומר?

881
00:36:21,090 --> 00:36:23,881
>> ובכן, זה אומר, מה אני הולך
לשים במשתנה הזה שנקרא t?

882
00:36:23,881 --> 00:36:24,780

883
00:36:24,780 --> 00:36:26,402
כתובת של char.

884
00:36:26,402 --> 00:36:28,360
אז זה פשוט פשוט,
דרך סבירה יותר

885
00:36:28,360 --> 00:36:29,930
לתאר את צד השמאל.

886
00:36:29,930 --> 00:36:32,890
כך שיוצרת תיבה זו כאן רק.

887
00:36:32,890 --> 00:36:34,760
אז צד ימין,
ככל הנראה, הוא הולך

888
00:36:34,760 --> 00:36:37,170
להקצות שגדול יותר
נתח של זיכרון איך?

889
00:36:37,170 --> 00:36:38,340
אז בואו להקניט זה לגזרים.

890
00:36:38,340 --> 00:36:41,131
>> זה מדהים במבט ראשון,
אבל מה קורה כאן בפנים?

891
00:36:41,131 --> 00:36:43,740
ראשית, יש malloc, ש
כנראה החבר החדש שלנו,

892
00:36:43,740 --> 00:36:45,450
"זיכרון להקצות."

893
00:36:45,450 --> 00:36:49,560
אז זה הטיעון שעבר
לתוך זה, אז זה ויכוח די גדול.

894
00:36:49,560 --> 00:36:50,970
אז בואו להקניט זה לגזרים.

895
00:36:50,970 --> 00:36:53,410
>> strlen של ים, כמובן, מייצג the--

896
00:36:53,410 --> 00:36:54,142

897
00:36:54,142 --> 00:36:55,600
קהל: מספר התווים.

898
00:36:55,600 --> 00:36:56,710
דוד י מלאן: רק
מספר התווים בים.

899
00:36:56,710 --> 00:36:59,040
אז האורך של ים, את המחרוזת המקורית.

900
00:36:59,040 --> 00:37:00,350
אז G--b-e.

901
00:37:00,350 --> 00:37:02,320
אז זה כנראה ארבעה במקרה זה.

902
00:37:02,320 --> 00:37:05,485
למה אני עושה את +1 לאחר
קורא strlen של ים?

903
00:37:05,485 --> 00:37:06,360
קהל: [לא ברור]

904
00:37:06,360 --> 00:37:07,590
דוד י מלאן: בשביל זה
אופי null מיוחד.

905
00:37:07,590 --> 00:37:11,260
אם אתה שואל אותי מה אורכו של
שמו של גייב, אני הולך לומר ארבעה.

906
00:37:11,260 --> 00:37:14,480
מתחת למכסה המנוע, אם כי, אני צריך
כי הבתים חמישי לאופי null.

907
00:37:14,480 --> 00:37:16,100
אז בגלל זה אני עושה +1.

908
00:37:16,100 --> 00:37:21,730
>> עכשיו רק במקרה שאתה מפעיל את זה
תכנית במחשב אחר מאשר, לומר,

909
00:37:21,730 --> 00:37:24,610
מכשיר CS50,
שבו בגודל של char

910
00:37:24,610 --> 00:37:26,350
עשוי להיות שונה
מcomputer-- שלי

911
00:37:26,350 --> 00:37:30,590
מתברר שאני יכול לקרוא לזה
sizeof מפעיל, פשוט לשאול את המחשב,

912
00:37:30,590 --> 00:37:32,870
מה הוא בגודל של
char במחשב הזה?

913
00:37:32,870 --> 00:37:37,400
>> ועל ידי הכפלת חמישה בזה
דוגמא על ידי הגודל של char, ש

914
00:37:37,400 --> 00:37:40,440
ברוב המחשבים יהיו
להיות רק אחד, malloc

915
00:37:40,440 --> 00:37:44,830
הולך להקצות עבורי זה גדול
נתח של זיכרון כאן בצד הימין.

916
00:37:44,830 --> 00:37:47,140
וזה הולך return--
זה function-- אז זה

917
00:37:47,140 --> 00:37:48,265
הולך להחזיר לי מה?

918
00:37:48,265 --> 00:37:50,914

919
00:37:50,914 --> 00:37:51,830
קהל: הכתובת?

920
00:37:51,830 --> 00:37:53,709
דוד י מלאן: הכתובת של מה?

921
00:37:53,709 --> 00:37:55,250
קהל: מהזיכרון זה מוקצה?

922
00:37:55,250 --> 00:37:56,450
דוד י מלאן: של
זיכרון זה הוקצה.

923
00:37:56,450 --> 00:37:59,189
אז אין לי מושג, בכנות,
לאן זה הולך בסופו של.

924
00:37:59,189 --> 00:38:01,480
אני הולך להציע ש
זה הולך בסופו של ב0x88.

925
00:38:01,480 --> 00:38:02,770

926
00:38:02,770 --> 00:38:06,009
שרירותי לחלוטין, אבל
במקום אחר 0x50,

927
00:38:06,009 --> 00:38:08,800
מכיוון שמערכת ההפעלה, מה ש
Windows ו Mac OS לעשות בשבילי, הוא

928
00:38:08,800 --> 00:38:11,230
לוודא שזה נותן
שלי נתחים שונים של זיכרון RAM.

929
00:38:11,230 --> 00:38:14,210
>> אז זהו הערך שבו זה
נתח של זיכרון עלול בסופו.

930
00:38:14,210 --> 00:38:16,060
אז זה מה שסופו של דבר כאן, 0x88.

931
00:38:16,060 --> 00:38:17,480

932
00:38:17,480 --> 00:38:21,570
אז עכשיו ברור, אני יכול להבין
שזה לא אותו הדבר כמו זה,

933
00:38:21,570 --> 00:38:23,960
בגלל שהם מצביעים על
נתחים שונים של זיכרון.

934
00:38:23,960 --> 00:38:29,980
אז אם אני עכשיו באמת רוצה להעתיק את זה
ב, בואו נעשה את הפתרון המוצע שלך.

935
00:38:29,980 --> 00:38:36,870
>> בואו פשוט ללכת, ליצור ללולאה,
ולעשות סוגר t אני מקבל ים סוגר i.

936
00:38:36,870 --> 00:38:39,760
כי עכשיו אני יכול להשתמש
סימון זה כמו מערך-,

937
00:38:39,760 --> 00:38:43,390
כי למרות שmalloc מאוד
הגנרי מקצה לי זיכרון,

938
00:38:43,390 --> 00:38:45,290
זיכרון הוא בתים רק רציפים.

939
00:38:45,290 --> 00:38:47,240
Byte, בתים, בתים, גב אל גב אל גב.

940
00:38:47,240 --> 00:38:50,030
>> בוודאי שאני יכול כמתכנת
להתייחס אליו כמערך, ש

941
00:38:50,030 --> 00:38:55,090
אומר שאני יכול להשתמש בסופו של דבר מוכר זה
סימון של רק חלק סוגריים מרובעים.

942
00:38:55,090 --> 00:38:56,462

943
00:38:56,462 --> 00:39:00,020
>> אז תן לי להשהות שם, כי
זה הרבה בבת אחת, אפילו

944
00:39:00,020 --> 00:39:03,530
למרות שהרעיון הבסיסי כדי לסכם
היא מחרוזת ש, כל הזמן הזה,

945
00:39:03,530 --> 00:39:05,550
אינו סוג נתונים חדש כשלעצמו.

946
00:39:05,550 --> 00:39:10,150
זה רק מצביע כביכול,
כתובת של אופי,

947
00:39:10,150 --> 00:39:12,650
שרק אומר שזה מספר
כי על ידי אמנה אנושית

948
00:39:12,650 --> 00:39:15,350
אנו נוטים לכתוב כמו 0x משהו.

949
00:39:15,350 --> 00:39:18,590
>> אבל זה רק מספר,
כמו הרחוב אוקספורד 33,

950
00:39:18,590 --> 00:39:20,530
אשר קורה להיות
הכתובת של בניין הפקולטה למדעי המחשב.

951
00:39:20,530 --> 00:39:22,000

952
00:39:22,000 --> 00:39:23,545
כל שאלות על פרטים אישיים?

953
00:39:23,545 --> 00:39:24,790

954
00:39:24,790 --> 00:39:25,289
כן?

955
00:39:25,289 --> 00:39:28,530
>> קהל: למה אנחנו בודקים
עבור t שווה ל null?

956
00:39:28,530 --> 00:39:30,740
>> דוד י מלאן: למה אנחנו
לבדוק t שווה ל null?

957
00:39:30,740 --> 00:39:33,250
אם אנו קוראים את documentation--
question-- נהדר עבור malloc,

958
00:39:33,250 --> 00:39:37,020
זה הולך לומר באותיות קטנות,
לפעמים malloc עשוי לחזור null,

959
00:39:37,020 --> 00:39:38,080
בדיוק כמו GetString.

960
00:39:38,080 --> 00:39:41,820
ואכן, GetString מחזיר null
אם, בתורו, malloc מחזיר null,

961
00:39:41,820 --> 00:39:43,130
בגלל GetString משתמש malloc.

962
00:39:43,130 --> 00:39:46,400
>> וזה עלול לקרות אם מערכת ההפעלה,
Mac OS, Windows, מה, היא פשוט

963
00:39:46,400 --> 00:39:48,130
מתוך זיכרון בשבילך.

964
00:39:48,130 --> 00:39:49,820
אז זה מה שקרה שם.

965
00:39:49,820 --> 00:39:52,910
>> ותן לי לגלות דבר אחד אחר
שאולי פשוט תפוצץ את דעתך

966
00:39:52,910 --> 00:39:55,100
או להיות לגמרי רחוק מדי מעבר לקו.

967
00:39:55,100 --> 00:39:59,770
אבל תנו לי להרים את
אותו דבר עבור לולאה להעתקה,

968
00:39:59,770 --> 00:40:05,480
לפני רגע ש, זוכר היה
זה. סוגר t אני מקבל ים סוגר i.

969
00:40:05,480 --> 00:40:06,740
>> נחמד וידידותי למשתמש.

970
00:40:06,740 --> 00:40:09,330
מרגיש כמו השבוע שני שוב.

971
00:40:09,330 --> 00:40:14,920
אבל גרסה זו באמת יכולה להיות
שוכתב כמו זה, שנראה ברורים מאליהם.

972
00:40:14,920 --> 00:40:18,280
זה מצביע טכניקה הנקראת
חשבון, חשבון כתובת.

973
00:40:18,280 --> 00:40:19,600
אבל למה זה עובד?

974
00:40:19,600 --> 00:40:22,220
>> עכשיו מעצבן,
מחברים של C החליטו להשתמש

975
00:40:22,220 --> 00:40:25,070
הסמל * למטרות שונות.

976
00:40:25,070 --> 00:40:29,020
ראינו את זה בשימוש כבר פעם אחת,
char *, שפירושו "תן לי משתנה

977
00:40:29,020 --> 00:40:31,210
זה הולך להכיל
הכתובת של char. "

978
00:40:31,210 --> 00:40:33,990
* אז char בהקשר זה
פירושו "תן לי משתנה."

979
00:40:33,990 --> 00:40:40,050
>> למרבה הצער, אם אתה משתמש ב* ללא
מילה לפניו, כמו char,

980
00:40:40,050 --> 00:40:41,905
זה עכשיו נקרא
מפעיל dereference.

981
00:40:41,905 --> 00:40:43,530
ואנו רואים יותר מזה לפני זמן רב.

982
00:40:43,530 --> 00:40:44,930
אבל זה רק אומר "ללכת לשם."

983
00:40:44,930 --> 00:40:49,070
זה כמו להגיד, אם מישהו הושיט לי
על פיסת נייר "רחוב 33 אוקספורד,"

984
00:40:49,070 --> 00:40:53,830
אם אני עושה את "הרחוב * 33 אוקספורד," זה אומר ש
"ללכת במורד הכביש לבניין הפקולטה למדעי המחשב."

985
00:40:53,830 --> 00:40:57,220
>> אז * רק אומר ללכת לשם אם
אין מילה לפניו.

986
00:40:57,220 --> 00:40:59,100
אז מה הוא לא, שיהיה ברור?

987
00:40:59,100 --> 00:41:03,250
t הוא הכתובת של הנתח של
זיכרון שניתנו לי בחזרה.

988
00:41:03,250 --> 00:41:06,650
ים הוא הכתובת של מה, שיהיה ברור,
בדוגמא שכבר דנים,

989
00:41:06,650 --> 00:41:07,500
של גייב האותיות הקטנות?

990
00:41:07,500 --> 00:41:08,990

991
00:41:08,990 --> 00:41:10,005
ים הוא הכתובת of--

992
00:41:10,005 --> 00:41:11,585

993
00:41:11,585 --> 00:41:12,460
קהל: המחרוזת.

994
00:41:12,460 --> 00:41:14,126
דוד י מלאן: השם המקורי של גייב.

995
00:41:14,126 --> 00:41:16,660
אז זה הכתובת של
נתח זה של זיכרון.

996
00:41:16,660 --> 00:41:22,220
אז אם אני אומר לא אני- + i, הודעה,
רק ידידנו הוותיק.

997
00:41:22,220 --> 00:41:24,770
זה פשוט משתנה מדד
שiterating מאפס על עד

998
00:41:24,770 --> 00:41:26,960
לאורכו של ים המחרוזת.

999
00:41:26,960 --> 00:41:30,367
אז זה הולך להיות אפס, ואז אחד,
אז שתיים, ואז שלוש, אז ארבעה.

1000
00:41:30,367 --> 00:41:33,200
אז בואו להרכיב חדש
חלקי הפאזל כמו סריטות, אם תרצה,

1001
00:41:33,200 --> 00:41:36,140
למרות, שוב, התחביר
הרבה יותר מסתורי מאשר גירוד.

1002
00:41:36,140 --> 00:41:39,522
אז לא הוא + כתובת
אני הולך לתת לי

1003
00:41:39,522 --> 00:41:42,480
מספר, כי כל אלה הם
מספרים שאנחנו כבר ציור כמשושה.

1004
00:41:42,480 --> 00:41:43,560
אבל הם רק מספרים.

1005
00:41:43,560 --> 00:41:49,960
>> אז אם הכתובת של t שאמרנו
היה 0x88, מה 0x88 בתוספת אפס.

1006
00:41:49,960 --> 00:41:51,564

1007
00:41:51,564 --> 00:41:53,980
גם אם אתה לא מרגיש בנוח
עם hex עדיין, לקחת ניחוש.

1008
00:41:53,980 --> 00:41:54,410
>> קהל: המקורי.

1009
00:41:54,410 --> 00:41:55,850
>> דוד י מלאן: עדיין 0x88.

1010
00:41:55,850 --> 00:41:58,910
אז מה עושה * 0x88 אומר?

1011
00:41:58,910 --> 00:42:02,670
זה אומר, "ללכת לשם", שפירושו
ביעילות, "לשים את האצבע שלך כאן."

1012
00:42:02,670 --> 00:42:06,930
ועכשיו בצד ימין של
ביטוי זה, * ולאחר מכן בparens,

1013
00:42:06,930 --> 00:42:11,586
ים + אומר שאני s, המהווה את
יתייחס כאן לגרם הקטן.

1014
00:42:11,586 --> 00:42:16,220
של 0 + הוא, כמובן, זה, כל מה שהים הוא.

1015
00:42:16,220 --> 00:42:21,230
>> אז עכשיו, זה אותו ים *, שבדיוק כמו * 33
רחוב אוקספורד אומר ללכת לכתובת

1016
00:42:21,230 --> 00:42:22,010
ים.

1017
00:42:22,010 --> 00:42:24,170
אז הנה אצבע זו, יד ימין.

1018
00:42:24,170 --> 00:42:26,050
אז מה אני הולך להעתיק למה?

1019
00:42:26,050 --> 00:42:30,260
הדבר בצד הימין, שהוא
גייב, גרם קצת לכאן, לכאן.

1020
00:42:30,260 --> 00:42:32,750
>> ולכן ההשפעה של ש
איטרציה הראשונה של הלולאה,

1021
00:42:32,750 --> 00:42:36,200
כפי שאתה הציע, אף על פי שזה נראה
משוגע יותר מסובך מכל דבר

1022
00:42:36,200 --> 00:42:42,110
שראינו בעבר, הוא פשוט אומרים
ללכת כאן ולהעתיק את הדמות שכאן.

1023
00:42:42,110 --> 00:42:44,700
זה נותן לך מפה לשני המקומות.

1024
00:42:44,700 --> 00:42:46,130
>> ואנו רואים הרבה יותר מזה.

1025
00:42:46,130 --> 00:42:50,600
אבל לעת עתה, התקווה היא רק כדי
להציג כמה מרעיונות הבסיסיים אלה.

1026
00:42:50,600 --> 00:42:53,550
ואכן, בואו נסתכל על
אחד תכנית סופית כאן,

1027
00:42:53,550 --> 00:42:57,480
ולאחר מכן הפלסטלינה הבטיחה,
שיעשה הכל בסדר.

1028
00:42:57,480 --> 00:42:57,980
בסדר.

1029
00:42:57,980 --> 00:43:01,680
אז תן לי לפתוח up-- שם אנחנו הולכים.

1030
00:43:01,680 --> 00:43:02,850

1031
00:43:02,850 --> 00:43:05,440
אז בואו me-- אנחנו נחזור
לתמונה הזאת לפני זמן רב.

1032
00:43:05,440 --> 00:43:08,360
תן לי לפתוח את הדוגמא אחרונה זה כאן.

1033
00:43:08,360 --> 00:43:09,440

1034
00:43:09,440 --> 00:43:12,710
>> אז הנה הוא סופר, סופר
תכנית שמשיגה

1035
00:43:12,710 --> 00:43:15,050
שום דבר בחיים שעושים את הדברים הבאים.

1036
00:43:15,050 --> 00:43:18,740
היא מצהירה שני משתנים, x הראשון
וy, שאינם מספרים הפעם,

1037
00:43:18,740 --> 00:43:19,240
כשלעצמו.

1038
00:43:19,240 --> 00:43:20,448
הם לא מספרים שלמים, כשלעצמו.

1039
00:43:20,448 --> 00:43:22,899
הם, ככל הנראה, int *.

1040
00:43:22,899 --> 00:43:25,690
כל כך פשוט לאף אחד, מה זה אומר
אם סוג הנתונים שלך, משתנה,

1041
00:43:25,690 --> 00:43:26,860
הוא של * int סוג כוכב?

1042
00:43:26,860 --> 00:43:30,240
זה הכתובת של int.

1043
00:43:30,240 --> 00:43:31,990
>> אז אין לי מושג איפה זה עדיין.

1044
00:43:31,990 --> 00:43:35,150
זה פשוט "פירושו לשים, סופו של דבר,
הכתובת של int כאן. "

1045
00:43:35,150 --> 00:43:38,340
0x50, 0x88, בכל מקום בו הוא ב
זיכרון, כתובת הולכת לשם.

1046
00:43:38,340 --> 00:43:40,200
וזה מה שהוא y
הולך להיות, כמו גם.

1047
00:43:40,200 --> 00:43:44,920
>> אם אני עכשיו אומר x = malloc (sizeof (int)),
זו היא דרך מפוארת לומר,

1048
00:43:44,920 --> 00:43:49,000
היי מערכת הפעלה, באמצעות malloc,
תן לי מספיק זיכרון לגודל

1049
00:43:49,000 --> 00:43:52,370
של int, שהוא כנראה
הולך להיות 32 סיביות או ארבעה בתים.

1050
00:43:52,370 --> 00:43:53,680
>> אז מה עושה malloc לחזור?

1051
00:43:53,680 --> 00:43:55,250
Malloc מחזיר את כתובת.

1052
00:43:55,250 --> 00:43:57,020
אז מה הולך לקבל מאוחסן בx?

1053
00:43:57,020 --> 00:44:00,600
הכתובת של הנתח של
זיכרון, ארבעה הבתים, malloc ש

1054
00:44:00,600 --> 00:44:03,360
פשוט מצאו לי בשאלה
מערכת ההפעלה.

1055
00:44:03,360 --> 00:44:08,240
>> עכשיו בינתיים, שורה
ארבעה כאן, * x = 42.

1056
00:44:08,240 --> 00:44:09,990
רק שיהיה ברור,
מה קורה שם למטה?

1057
00:44:09,990 --> 00:44:11,530
בצד השמאל, * x.

1058
00:44:11,530 --> 00:44:13,610
זה כמו * 33 רחוב אוקספורד.

1059
00:44:13,610 --> 00:44:15,523
אז * x אומר מה?

1060
00:44:15,523 --> 00:44:16,450
>> קהל: עבור ל.

1061
00:44:16,450 --> 00:44:17,908
>> דוד י מלאן: מעבר לכתובת ש.

1062
00:44:17,908 --> 00:44:20,466
בכל מקום שנתח זה של
זיכרון הוא, ללכת אליו.

1063
00:44:20,466 --> 00:44:21,979
ולשים את מה שיש, ללא ספק?

1064
00:44:21,979 --> 00:44:22,520
קהל: 42.

1065
00:44:22,520 --> 00:44:23,580
דוד י מלאן: 42.

1066
00:44:23,580 --> 00:44:25,650
בסדר, y *, אותו רעיון.

1067
00:44:25,650 --> 00:44:26,860
גש לכתובת בy.

1068
00:44:26,860 --> 00:44:31,740
שים את המספר 13 שם,
אבל מה הוא y באותו הרגע?

1069
00:44:31,740 --> 00:44:33,172

1070
00:44:33,172 --> 00:44:34,630
קהל: אין זיכרון לy.

1071
00:44:34,630 --> 00:44:35,710
דוד י מלאן: יש
אין זיכרון לy.

1072
00:44:35,710 --> 00:44:38,215
אז מה עושה y כנראה
להכיל, כפי שאנו כבר אומרים?

1073
00:44:38,215 --> 00:44:38,520
>> קהל: אשפה.

1074
00:44:38,520 --> 00:44:39,480
>> דוד י מלאן: ערך אשפה חלק.

1075
00:44:39,480 --> 00:44:41,320
עכשיו, ערך אשפה הוא עדיין מספר.

1076
00:44:41,320 --> 00:44:43,160
זה עדיין יכול להיחשב בטעות לכתובת.

1077
00:44:43,160 --> 00:44:45,160
זה כאילו מישהו
רשם משהו,

1078
00:44:45,160 --> 00:44:48,002
ואני שלא כהלכה את זה כמשמעות
בניין כמה במורד הרחוב.

1079
00:44:48,002 --> 00:44:50,460
ואם אתה רק מנסה להיכנס
איזה בניין שאינו בבעלות,

1080
00:44:50,460 --> 00:44:53,710
או כמה נתח של זיכרון יש לך לא
היה נתון, דברים רעים עלולים לקרות.

1081
00:44:53,710 --> 00:44:57,740
מחשב עלול לקרוס, או כמה אחר
התנהגות לא נקבע שעלולה לקרות.

1082
00:44:57,740 --> 00:45:01,310
>> אז intro, אז, לינקי הוא זו.

1083
00:45:01,310 --> 00:45:04,290
אני עדיין זוכר, 20
כמה שנים מאוחר יותר מוזרות,

1084
00:45:04,290 --> 00:45:07,200
איפה הייתי כשאני סוף סוף
הבין מצביעים.

1085
00:45:07,200 --> 00:45:09,520
>> כלומר, אם אתה
תצא מכאן בשלוש דקות

1086
00:45:09,520 --> 00:45:12,170
וחושב שאני לא
מבין מצביעים, מבין

1087
00:45:12,170 --> 00:45:14,410
יש לי זכרתי ל20
שנים מסיבה כלשהי מטורפת

1088
00:45:14,410 --> 00:45:17,140
מתי ולמה זה סוף סוף שקוע
ב, יושב עם ההוראה שלי

1089
00:45:17,140 --> 00:45:19,501
, נישאט מהטה בבחור
אחורי של חדר אוכל אליוט.

1090
00:45:19,501 --> 00:45:21,250
עכשיו, אני כבר נזכרתי
זה בגלל שזה היה

1091
00:45:21,250 --> 00:45:23,920
אחד הנושאים שאני, ב
בפרט, נאבק עם.

1092
00:45:23,920 --> 00:45:26,470
ואז, פתאום קלט,
כמו שאני מעז לומר הרבה נושאים

1093
00:45:26,470 --> 00:45:27,460
סופו של דבר.

1094
00:45:27,460 --> 00:45:32,590
ועכשיו, כדי שזה מרגיש כל
מאושר יותר ומשכנע כל עוד,

1095
00:45:32,590 --> 00:45:35,360
בואו נסתכל סופי בנו
שלוש דקות האחרונות כאן בינקי,

1096
00:45:35,360 --> 00:45:37,675
מידידנו, ניק
Parlante מאוניברסיטת סטנפורד.

1097
00:45:37,675 --> 00:45:38,910

1098
00:45:38,910 --> 00:45:41,580
>> [וידאו השמעה]

1099
00:45:41,580 --> 00:45:42,750
>> היי, בינקי.

1100
00:45:42,750 --> 00:45:43,500
תתעורר!

1101
00:45:43,500 --> 00:45:45,960
זה זמן בשביל כיף מצביע.

1102
00:45:45,960 --> 00:45:47,012
>> 'מה זה?

1103
00:45:47,012 --> 00:45:48,723
למד על מצביעים?

1104
00:45:48,723 --> 00:45:50,580
אה, טופי!

1105
00:45:50,580 --> 00:45:53,563
>> "טוב, כדי להתחיל, אני מניח שאנחנו
הולך צריך כמה עצות.

1106
00:45:53,563 --> 00:45:54,390
>> "או-קיי.

1107
00:45:54,390 --> 00:45:57,930
קוד זה מקצה שני מצביעים,
אשר יכול להצביע על מספרים שלמים.

1108
00:45:57,930 --> 00:45:58,430
"או-קיי.

1109
00:45:58,430 --> 00:46:02,140
ובכן, אני רואה שני מצביעים, אבל הם
אין נראה שיש להצביע לכל דבר.

1110
00:46:02,140 --> 00:46:02,980
>> -That נכון.

1111
00:46:02,980 --> 00:46:05,100
בתחילה, מצביעים
אינו מצביע על שום דבר.

1112
00:46:05,100 --> 00:46:08,030
הדברים שהם מצביעים עליהם בשם
pointees, והקמתם של

1113
00:46:08,030 --> 00:46:09,370
צעד נפרד.

1114
00:46:09,370 --> 00:46:10,220
>> אה, נכון, נכון.

1115
00:46:10,220 --> 00:46:10,950
ידעתי ש.

1116
00:46:10,950 --> 00:46:12,385
Pointees הם נפרדים.

1117
00:46:12,385 --> 00:46:14,315
Er, אז איך אתה להקצות pointee?

1118
00:46:14,315 --> 00:46:15,340

1119
00:46:15,340 --> 00:46:15,960
>> "או-קיי.

1120
00:46:15,960 --> 00:46:18,970
ובכן, את הקוד הזה מקצה
pointee השלם חדש,

1121
00:46:18,970 --> 00:46:20,950
וx סטי חלק זה להצביע על זה.

1122
00:46:20,950 --> 00:46:22,050

1123
00:46:22,050 --> 00:46:23,230
>> היי, זה נראה טוב יותר.

1124
00:46:23,230 --> 00:46:25,060
אז להפוך אותו לעשות משהו.

1125
00:46:25,060 --> 00:46:25,990
>> "או-קיי.

1126
00:46:25,990 --> 00:46:30,455
אני יהיה dereference x המצביע
לאחסן את המספר 42 לpointee.

1127
00:46:30,455 --> 00:46:32,830
על הטריק הזה, אני אצטרך שלי
שרביט קסמים של ביטול הפניה.

1128
00:46:32,830 --> 00:46:34,130

1129
00:46:34,130 --> 00:46:36,080
>> שרביט קסמי -Your של ביטול הפניה?

1130
00:46:36,080 --> 00:46:37,357

1131
00:46:37,357 --> 00:46:38,190
That-- זה נהדר.

1132
00:46:38,190 --> 00:46:39,340

1133
00:46:39,340 --> 00:46:41,080
>> -זהו מה הקוד נראה.

1134
00:46:41,080 --> 00:46:44,110
אני רק להגדיר את המספר, ו[ POP]

1135
00:46:44,110 --> 00:46:44,700
>> היי, נראה.

1136
00:46:44,700 --> 00:46:46,140
הנה זה מתחיל.

1137
00:46:46,140 --> 00:46:50,980
>> 'אז עושה dereference על x כדלקמן
החצים כדי לגשת pointee.

1138
00:46:50,980 --> 00:46:53,160
במקרה זה, חנות 42 שם.

1139
00:46:53,160 --> 00:46:57,710
היי נסה להשתמש בו כדי לאחסן את המספר
13 באמצעות המצביע האחר, y.

1140
00:46:57,710 --> 00:46:58,760
>> "או-קיי.

1141
00:46:58,760 --> 00:47:03,270
אני פשוט אלך לכאן כדי y,
ולקבל את הסט עד מספר 13.

1142
00:47:03,270 --> 00:47:07,930
ולאחר מכן, לקחת את השרביט של
ביטול הפניה ורק [BUZZ]

1143
00:47:07,930 --> 00:47:08,960
>> אה!

1144
00:47:08,960 --> 00:47:09,500
>> אה, היי!

1145
00:47:09,500 --> 00:47:11,090
זה לא עבד.

1146
00:47:11,090 --> 00:47:15,630
אומר, בינקי, אני לא חושב שביטול הפניה למבנה
y הוא רעיון טוב, כי אתה יודע,

1147
00:47:15,630 --> 00:47:17,850
הקמת pointee
הוא צעד נפרד.

1148
00:47:17,850 --> 00:47:20,450
ואני לא חושב שאי פעם עשינו את זה.

1149
00:47:20,450 --> 00:47:21,480
>> נקודת -Good.

1150
00:47:21,480 --> 00:47:21,980
'כן.

1151
00:47:21,980 --> 00:47:25,680
אנחנו הקצו את y המצביע, אבל אנחנו
אף פעם לא להגדיר אותו כך שיצביע על pointee.

1152
00:47:25,680 --> 00:47:27,190

1153
00:47:27,190 --> 00:47:28,616
>> -Very שומרי מצוות.

1154
00:47:28,616 --> 00:47:30,240
היי, אתה נראה טוב שם, בינקי.

1155
00:47:30,240 --> 00:47:33,400
האם אתה יכול לתקן את זה כדי שנקודתי y
לאותו pointee כx?

1156
00:47:33,400 --> 00:47:34,000
>> -Sure.

1157
00:47:34,000 --> 00:47:36,780
אני אשתמש בשרביט הקסמים שלי
של הקצאת פוינטר.

1158
00:47:36,780 --> 00:47:38,740
>> 'האם זה הולך להיות
בעיה כמו בעבר?

1159
00:47:38,740 --> 00:47:39,240
'לא.

1160
00:47:39,240 --> 00:47:40,660
זה לא נוגע pointees.

1161
00:47:40,660 --> 00:47:44,450
זה פשוט משנה את מצביע אחד ל
מצביע על אותו הדבר כמו אחר.

1162
00:47:44,450 --> 00:47:45,450
>> אה, אני רואה.

1163
00:47:45,450 --> 00:47:48,200
עכשיו נקודות y לאותו המקום כמו x.

1164
00:47:48,200 --> 00:47:48,910
אז תחכה.

1165
00:47:48,910 --> 00:47:49,950
עכשיו, y הוא קבוע.

1166
00:47:49,950 --> 00:47:51,120
יש לו pointee.

1167
00:47:51,120 --> 00:47:54,510
אז אתה יכול לנסות את השרביט של
ביטול הפניה שוב לשלוח מעל 13.

1168
00:47:54,510 --> 00:47:56,510
>> -אה, על אישור.

1169
00:47:56,510 --> 00:47:58,160
כאן זה הולך. [POP]

1170
00:47:58,160 --> 00:47:59,340
>> היי, תראה את זה.

1171
00:47:59,340 --> 00:48:00,750
עכשיו ביטול הפניה למבנה עבודות על y.

1172
00:48:00,750 --> 00:48:04,991
ומכיוון שהמצביעים משתפים
שpointee אחד, שניהם רואים 13.

1173
00:48:04,991 --> 00:48:05,490
'כן.

1174
00:48:05,490 --> 00:48:06,870
שיתוף, לא משנה מה.

1175
00:48:06,870 --> 00:48:08,820
אז אנחנו הולכים להתחלף עכשיו?

1176
00:48:08,820 --> 00:48:09,440
>> אה, תראה.

1177
00:48:09,440 --> 00:48:10,830
אנחנו מחוץ לזמן.

1178
00:48:10,830 --> 00:48:11,570
>> -But--

1179
00:48:11,570 --> 00:48:13,530
>> פשוס לזכור שלושה כללי מצביע.

1180
00:48:13,530 --> 00:48:16,560
טלפון אחד, את המבנה הבסיסי
הוא שיש לך מצביע,

1181
00:48:16,560 --> 00:48:18,680
והוא מצביע על לpointee.

1182
00:48:18,680 --> 00:48:20,640
אבל והמצביע
pointee הם נפרדים,

1183
00:48:20,640 --> 00:48:22,610
והשגיאה הנפוצה
הוא להגדיר מצביע,

1184
00:48:22,610 --> 00:48:25,000
אבל לשכוח לתת לו pointee.

1185
00:48:25,000 --> 00:48:28,170
>> מספר שתיים, ביטול הפנית מצביע
מתחיל במצביע

1186
00:48:28,170 --> 00:48:31,050
וכדלקמן חיצו מעל
כדי לגשת pointee.

1187
00:48:31,050 --> 00:48:33,400
כפי שכולנו יודעים, זה
עובד רק אם יש

1188
00:48:33,400 --> 00:48:36,270
pointee, איזה סוג של
חוזר לכלל מספר אחת.

1189
00:48:36,270 --> 00:48:39,000
>> מספר שלוש, מצביע
משימה לוקחת מצביע אחד

1190
00:48:39,000 --> 00:48:42,320
ומשנה אותו כך שיצביע על
אותו pointee כמצביע אחר.

1191
00:48:42,320 --> 00:48:44,160
אז אחרי המשימה,
שני מצביעים

1192
00:48:44,160 --> 00:48:45,910
יצביע לאותו pointee.

1193
00:48:45,910 --> 00:48:47,990
לפעמים, זה נקרא שיתוף.

1194
00:48:47,990 --> 00:48:49,740
וזה כל מה שיש בו, באמת.

1195
00:48:49,740 --> 00:48:50,277
ביי ביי עכשיו.

1196
00:48:50,277 --> 00:48:51,110
[END הפעלת וידאו]

1197
00:48:51,110 --> 00:48:52,568
דוד י מלאן: זהו זה לCS50.

1198
00:48:52,568 --> 00:48:55,110
אנחנו אראה אותך בשבוע הבא.

1199
00:48:55,110 --> 00:48:56,064