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

2
00:00:03,395 --> 00:00:11,031

3
00:00:11,031 --> 00:00:13,280
דוד י מלאן: זה כמו
סמינר הלימודים הראשונה היום.

4
00:00:13,280 --> 00:00:14,060
אוקיי.

5
00:00:14,060 --> 00:00:15,024
אז מאוד גשום בחוץ.

6
00:00:15,024 --> 00:00:17,690
זה נוטה לקרות בימי רביעי,
אבל כל עוד ההזדמנות

7
00:00:17,690 --> 00:00:18,700
לשאלות היום.

8
00:00:18,700 --> 00:00:22,210
אז בואו נתחיל מלמעשה
עם הסרט ברגע.

9
00:00:22,210 --> 00:00:24,560
אבל יתחילו בחגיגיות כמו תמיד.

10
00:00:24,560 --> 00:00:28,000
>> זה CS50, וזה
הוא סוף השבוע 4.

11
00:00:28,000 --> 00:00:30,820
אז אם יצאתי לך לראות
טלוויזיה או סרט שבי

12
00:00:30,820 --> 00:00:34,690
יש כמה מומחי מחשב ו
המשטרה, או ה- FBI, או כמה סוכנות

13
00:00:34,690 --> 00:00:36,930
מנסה לתפוס כמה
יריב, גם, שיש לך

14
00:00:36,930 --> 00:00:40,850
כנראה שמע את הביטוי "לשפר"
לפי טכנאי שאיכשהו

15
00:00:40,850 --> 00:00:44,750
קסם מתקרב לאין שיעור
רחוק כדי לראות את הפושעים

16
00:00:44,750 --> 00:00:48,640
זהות או מספר לוחית הרישוי
באפילו הבלחה של מראה

17
00:00:48,640 --> 00:00:50,390
או הנצנוץ של עין של מישהו.

18
00:00:50,390 --> 00:00:55,196
אז אכן, בואו נסתכל
כמה כאלה סצנות מהוליווד.

19
00:00:55,196 --> 00:00:55,862
[וידאו השמעה]

20
00:00:55,862 --> 00:00:59,243
או קיי, עכשיו בואו לקבל מבט טוב עליך.

21
00:00:59,243 --> 00:01:06,488

22
00:01:06,488 --> 00:01:07,415
>> -תחזיק את זה.

23
00:01:07,415 --> 00:01:08,267
הפעל את זה בחזרה.

24
00:01:08,267 --> 00:01:09,121
>> -חכה דקה.

25
00:01:09,121 --> 00:01:11,300
פנה ימינה.

26
00:01:11,300 --> 00:01:12,209
>> : רווחה, להקפיא את זה.

27
00:01:12,209 --> 00:01:12,750
-מסך מלא.

28
00:01:12,750 --> 00:01:13,558
או קיי, להקפיא את זה.

29
00:01:13,558 --> 00:01:14,820
-Tighten על ש, יהיה לך?

30
00:01:14,820 --> 00:01:16,530
-Vector שב
בחור בגלגל האחורי.

31
00:01:16,530 --> 00:01:19,400
-Zoom בכאן במקום הזה.

32
00:01:19,400 --> 00:01:22,846
-עם הציוד הנכון, התמונה
יכול להיות מוגדל ומחודד.

33
00:01:22,846 --> 00:01:24,065
-מה זה?

34
00:01:24,065 --> 00:01:25,600
"זאת תכנית שיפור.

35
00:01:25,600 --> 00:01:26,860
"אתה יכול ברור שעד כל?

36
00:01:26,860 --> 00:01:27,890
-אני לא יודע.

37
00:01:27,890 --> 00:01:29,050
בואו לשפר אותו.

38
00:01:29,050 --> 00:01:31,575
>> A6 סעיף -Enhance.

39
00:01:31,575 --> 00:01:33,642
>> -אני משופר הפרט,
and-- אני חושב שיש

40
00:01:33,642 --> 00:01:35,433
מספיק כדי לשפר,
לשחרר אותו למסך שלי.

41
00:01:35,433 --> 00:01:37,080
-אני משופר ההשתקפות בעיניה.

42
00:01:37,080 --> 00:01:38,830
>> בוא להפעיל את זה דרך
שיפור וידאו.

43
00:01:38,830 --> 00:01:40,100
-Edgar, אתה יכול לשפר את זה?

44
00:01:40,100 --> 00:01:41,875
>> -חכה.

45
00:01:41,875 --> 00:01:44,010
>> "יש לי כבר עובד על השתקפות זו.

46
00:01:44,010 --> 00:01:44,995
>> ההשתקפות של-מישהו.

47
00:01:44,995 --> 00:01:45,495
-Reflection.

48
00:01:45,495 --> 00:01:47,399
"מצאתי השתקפות של פניו של האיש.

49
00:01:47,399 --> 00:01:48,065
השתקפות בחור'.

50
00:01:48,065 --> 00:01:48,981
"מצאתי השתקפות.

51
00:01:48,981 --> 00:01:50,600
-Zoom במראה.

52
00:01:50,600 --> 00:01:52,712
, אתה יכול לראות את השתקפות.

53
00:01:52,712 --> 00:01:54,350
"אתה יכול לשפר את התמונה מכאן?

54
00:01:54,350 --> 00:01:55,370
"אתה יכול לשפר אותו ממש כאן?

55
00:01:55,370 --> 00:01:56,210
"אתה יכול לשפר את זה?

56
00:01:56,210 --> 00:01:56,900
אתה יכול לשפר אותו?

57
00:01:56,900 --> 00:01:57,870
>> "בסדר." "החנות לשפר את זה?

58
00:01:57,870 --> 00:01:58,717
>> "אתה יכול לשפר את זה?

59
00:01:58,717 --> 00:02:00,050
-Hold בשני, אני לשפר.

60
00:02:00,050 --> 00:02:00,924
-Zoom בדלת.

61
00:02:00,924 --> 00:02:01,700
-Times 10.

62
00:02:01,700 --> 00:02:02,586
-Zoom.

63
00:02:02,586 --> 00:02:03,490
-לעבור לגור.

64
00:02:03,490 --> 00:02:03,990
-יותר.

65
00:02:03,990 --> 00:02:04,690
"חכה, לעצור.

66
00:02:04,690 --> 00:02:05,190
-Stop.

67
00:02:05,190 --> 00:02:05,970
-Pause זה.

68
00:02:05,970 --> 00:02:09,460
-Rotate 75 מעלות
סביב האנכי, בבקשה.

69
00:02:09,460 --> 00:02:10,962
-Stop.

70
00:02:10,962 --> 00:02:14,040
חזור לחלק
על הדלת, שוב.

71
00:02:14,040 --> 00:02:15,860
>> -Got משפר תמונה שיכול מפה סיבית?

72
00:02:15,860 --> 00:02:18,776
>> היי, אולי נוכל להשתמש בPradeep
שיטת סן לראות בחלונות.

73
00:02:18,776 --> 00:02:20,372
תוכנת -זהו היא מדינה של האמנות.

74
00:02:20,372 --> 00:02:21,845
>> בחור' ערכים עצמי כבוי.

75
00:02:21,845 --> 00:02:24,300
>> -עם תקין
שילוב של algorithm--

76
00:02:24,300 --> 00:02:26,755
>> החיסול נלקח של -הוא
אלגוריתמים לרמה הבאה,

77
00:02:26,755 --> 00:02:28,730
ואני יכול להשתמש בם כדי
לשפר את התצלום הזה.

78
00:02:28,730 --> 00:02:31,286
>> -Lock ובלהגדיל את ציר z.

79
00:02:31,286 --> 00:02:32,560
>> -Enhance.

80
00:02:32,560 --> 00:02:33,100
>> -Enhance.

81
00:02:33,100 --> 00:02:33,600
>> -Enhance.

82
00:02:33,600 --> 00:02:34,960
-Freeze ולשפר.

83
00:02:34,960 --> 00:02:37,180
>> [סוף ההשמעה]

84
00:02:37,180 --> 00:02:41,160
>> דוד י מלאן: בסדר, כל כך
כל אלה הם למעשה מילות.

85
00:02:41,160 --> 00:02:44,450
הם פשוט מתוחים יחד ב
דרך שלא הגיוני למעשה.

86
00:02:44,450 --> 00:02:48,400
ולמעשה, קורסים, CS50 וכמותו
נוטה להרוס הרבה טלוויזיה וסרטים

87
00:02:48,400 --> 00:02:48,900
בשבילך.

88
00:02:48,900 --> 00:02:52,330
כי כאשר מומחי מחשב אלה
הם מטלטל את תנאים ואומרים

89
00:02:52,330 --> 00:02:56,860
דברים מפוארים כמו
וקטורים עצמיים, וציר z,

90
00:02:56,860 --> 00:02:59,572
וכל מספר אחר
למעשה מונחים טכניים יותר,

91
00:02:59,572 --> 00:03:02,030
הם באמת רק בחוטים
מילות יחד לעתים קרובות מדי.

92
00:03:02,030 --> 00:03:05,020
האם זה אחד מתקוותינו הוא ש,
כתופעת לוואי של נטילת קורסים

93
00:03:05,020 --> 00:03:08,245
ככה, יהיה יותר אנשים ב
עולם בעצם להיות מסוגל לשקול ב

94
00:03:08,245 --> 00:03:12,040
ורק מעט שבמעט להשפיע
איכות ודיוק של הסרטים האלה?

95
00:03:12,040 --> 00:03:14,350
>> למעשה, בואו נסתכל על מציאות.

96
00:03:14,350 --> 00:03:18,070
אז הנה התמונה של צוות
מרי, אחד מעמיתי ההוראה שלנו.

97
00:03:18,070 --> 00:03:20,050
ונניח שהיא
חשוד במשהו.

98
00:03:20,050 --> 00:03:23,730
ובכל זאת, יש ניצוץ של
כמה ראיה בעינה,

99
00:03:23,730 --> 00:03:25,480
או בהשתקפות של משקפיה.

100
00:03:25,480 --> 00:03:30,760
ובכן, אם אנחנו עושים בדיוק כמו הסרטים
מציע, שבו אנו זום ו" לשפר ",

101
00:03:30,760 --> 00:03:34,080
זה כמה מידע
הוא בפנייה של מרי

102
00:03:34,080 --> 00:03:36,795
כאשר אתה ללכוד תמונה
עם שרזולוציה מקורית.

103
00:03:36,795 --> 00:03:39,120
>> ואכן, אתה יכול לראות נקודות אלה.

104
00:03:39,120 --> 00:03:41,900
ואלה הם מה הם
פיקסלים שנקראו, P-אני-X-E-L-S,

105
00:03:41,900 --> 00:03:45,740
וזה רק כיכר בדרך כלל
שהוא נקודה שמלחינה תמונה.

106
00:03:45,740 --> 00:03:49,200
ובחזרה ביום, ואפילו למעשה
היום עם כמה משל היום טלוויזיות LED

107
00:03:49,200 --> 00:03:51,950
או טלוויזיות LCD, אם יש לך
אחד בחדר שלך או בבית,

108
00:03:51,950 --> 00:03:55,100
אם אתה רוצה ללכת עד סופר קרוב לזה, ו
במיוחד אם זה טלוויזיה מבוגרת במקצת,

109
00:03:55,100 --> 00:03:58,760
כנראה שאתה יכול אפילו לראות נקודות אלה
וזה מה שמרכיב את תמונה.

110
00:03:58,760 --> 00:04:00,980
>> ואין עוד
מידע מזה.

111
00:04:00,980 --> 00:04:05,400
אנחנו יכולים "לשפר", במובן של
החלקה על דברים וסוג של

112
00:04:05,400 --> 00:04:09,040
הסיק סוג של, סוג של מה ש
צבע צריך להיות ליד העין של מרי

113
00:04:09,040 --> 00:04:10,910
כך שזה לא ממש כך pixelated.

114
00:04:10,910 --> 00:04:14,510
אבל אם אני ממשיך התקרבות, שם
הוא האיש הרע בעיניה.

115
00:04:14,510 --> 00:04:16,600
כמו שכולו
מידע שיש לנו.

116
00:04:16,600 --> 00:04:18,920
אתה לא יכול ליצור
מידע מאין.

117
00:04:18,920 --> 00:04:20,790
יש רק סופי
מספר הביטים שיש.

118
00:04:20,790 --> 00:04:22,873
>> אז בבעיה 4 סט, שבו
יש לך הזדמנות

119
00:04:22,873 --> 00:04:24,580
לשחק עם של עולם מסוג זה.

120
00:04:24,580 --> 00:04:27,610
בבעיה 4 סט, אתה לחקור את
עולם של גרפיקה, וזיהוי פלילי,

121
00:04:27,610 --> 00:04:30,870
ובעצם לכתוב קוד
שמשחזר תמונות איבדו.

122
00:04:30,870 --> 00:04:33,510
אתה כותב קוד ש
מתפעל תמונות קיימות

123
00:04:33,510 --> 00:04:36,120
וסופו של דבר להבין מה
קורה מתחת למכסת המנוע.

124
00:04:36,120 --> 00:04:38,540
>> ו, מתברר, זה בעצם
לא כל כך מסובך.

125
00:04:38,540 --> 00:04:41,320
לדוגמא, אם אנחנו רוצים
מייצג הסמיילי בי

126
00:04:41,320 --> 00:04:44,160
עם פיקסלים שחורים אלה,
או הנקודות השחורות הללו,

127
00:04:44,160 --> 00:04:47,230
טוב, אנחנו יכולים פשוט מייצגים
שלהם כבאמת מפת סיביות.

128
00:04:47,230 --> 00:04:50,040
ואם היית אי פעם שמעת ש
מפת סיביות ביטוי, אולי

129
00:04:50,040 --> 00:04:52,330
עכשיו זה מתחיל לעשות
תחושה קצת יותר היום.

130
00:04:52,330 --> 00:04:53,580
>> אנחנו כבר יודעים מה הוא קצת.

131
00:04:53,580 --> 00:04:54,160
זה 0 או 1.

132
00:04:54,160 --> 00:04:56,201
ומפה היא רק משהו
כמו פיסת נייר

133
00:04:56,201 --> 00:04:59,180
זה נותן לך כיוונים ויש לי
אולי רשת של X ו- Y-קואורדינטות.

134
00:04:59,180 --> 00:05:00,540
אז הנה היא מפת סיביות.

135
00:05:00,540 --> 00:05:03,680
זה מפה של ביטים
לפי 1 הוא כנראה

136
00:05:03,680 --> 00:05:07,857
הולך לייצג פיקסל לבן, ו
0 הולכים לייצג פיקסל שחור.

137
00:05:07,857 --> 00:05:09,440
אבל אנחנו בהחלט יכולים להעיף סביבו.

138
00:05:09,440 --> 00:05:11,648
זה לא ממש משנה כל כך
עוד אנחנו עולים בקנה אחד.

139
00:05:11,648 --> 00:05:15,570
וכאן הוא איך, בbinary-- בתוך
הזיכרון של מחשב, או אפילו בתוך

140
00:05:15,570 --> 00:05:18,160
של קובץ עליך קשה
drive-- אתה יכול לאחסן

141
00:05:18,160 --> 00:05:20,240
הפשוט של תמונות הסמיילי.

142
00:05:20,240 --> 00:05:23,990
אבל מה אנחנו, כמובן,
חסר בתמונה זו?

143
00:05:23,990 --> 00:05:24,610
צבע, נכון?

144
00:05:24,610 --> 00:05:28,220
זה השלב הבא ברור או
שיפור לשפר את זה עם הצבע.

145
00:05:28,220 --> 00:05:32,230
אז למרבה הצער רק עם אחד
קצת, 0 או 1, אנחנו יכולים לייצג צבע.

146
00:05:32,230 --> 00:05:36,100
זה יכול להיות אדום, או כחול, או
שחור, או לבן, או ירוק, או ורוד,

147
00:05:36,100 --> 00:05:37,420
או כל זוגות של צבעים.

148
00:05:37,420 --> 00:05:40,860
אבל למען הפשטות, אנחנו
פשוט מניח בשחור לבן.

149
00:05:40,860 --> 00:05:45,930
>> אז מה אנחנו צריכים באופן הגיוני אם
רוצה ליישם צבע בתמונה?

150
00:05:45,930 --> 00:05:49,080
מה יש לנו לעשות?

151
00:05:49,080 --> 00:05:51,900
כמו אם הגורם המגביל כאן
הוא שעם אחד קצת אתה יכול רק

152
00:05:51,900 --> 00:05:55,977
בשני מצבים, 0 או 1, לבן
או שחור, מה אתה רוצה לעשות?

153
00:05:55,977 --> 00:05:56,810
נתונים נוספים: קהל.

154
00:05:56,810 --> 00:05:58,813
דוד י מלאן: יותר ביטים,
כן נתונים נוספים, יותר ביטים.

155
00:05:58,813 --> 00:06:01,440
ואכן, זה בדיוק איך
תמונות צבע מיוצגות.

156
00:06:01,440 --> 00:06:05,120
במקום להשתמש קצת בודד,
0 או 1 לכל פיקסל, כל נקודה,

157
00:06:05,120 --> 00:06:06,170
אתה פשוט להשתמש מרובה.

158
00:06:06,170 --> 00:06:09,660
אולי להשתמש 8, אולי, יותר נפוץ
להשתמש 24, ואכן, בבעיה הגדר

159
00:06:09,660 --> 00:06:13,300
4, יהיה לך לשחק עם קובץ
פורמט שמשתמש 24 סיביות בדרך כלל.

160
00:06:13,300 --> 00:06:15,430
>> אבל רובכם כנראה
מכיר JPEG.

161
00:06:15,430 --> 00:06:17,460
אם אי פעם לקחו
תמונה בטלפון שלך,

162
00:06:17,460 --> 00:06:20,360
או נטען או ראה משהו ב
פייסבוק, או פליקר, כל מספר

163
00:06:20,360 --> 00:06:24,882
של אתרים מבוססי תמונה, יש לך
כנראה ראה תמונת JPEG לפני.

164
00:06:24,882 --> 00:06:27,840
ומתברר, זה הקובץ
פורמט שאנחנו הולכים להשתמש בPSet 4,

165
00:06:27,840 --> 00:06:30,340
לפי שאתה הולך
צריך לשחזר תמונות

166
00:06:30,340 --> 00:06:35,160
כי אני כבר שנמחק בטעות מ
כרטיס זיכרון פגום במצלמה,

167
00:06:35,160 --> 00:06:35,800
אם אתה.

168
00:06:35,800 --> 00:06:38,490
>> ומתברר שלמרות ש
JPEG הוא די sophisticated--

169
00:06:38,490 --> 00:06:40,906
זה הרבה יותר מתוחכם
מהנקודות השחורות והלבנות

170
00:06:40,906 --> 00:06:44,480
ראינו לפני רגע, כי יש
אלגוריתמים מפוארים למעשה ש

171
00:06:44,480 --> 00:06:47,410
הם משמשים לדחיסת JPEG, כך
שאתה יכול להיות ממש נחמד,

172
00:06:47,410 --> 00:06:49,832
תמונה באיכות אלא באמצעות
מעטים יחסית סיביות.

173
00:06:49,832 --> 00:06:51,790
ואנחנו נחזור ל
דחיסה לפני זמן רב.

174
00:06:51,790 --> 00:06:56,280
מתברר כי הראשון
שלושה בתים בimage-- JPEG

175
00:06:56,280 --> 00:07:02,750
לא משנה מה אתה כבר לקח תצלום
ל-- הם הערכים 255, 216, 255.

176
00:07:02,750 --> 00:07:05,990
>> במילים אחרות, אם אתה רק
לראות דפוס של ביטים,

177
00:07:05,990 --> 00:07:09,180
מיוצג כאן כשלוש
בתים, או 24 סיביות יסתכמו,

178
00:07:09,180 --> 00:07:13,810
בהסתברות גבוהה שאתה יכול להסיק ש
אתה מסתכל על זה שלוש הראשונים

179
00:07:13,810 --> 00:07:15,230
בתים של JPEG.

180
00:07:15,230 --> 00:07:18,040
וזה מה שנקרא
כחתימה של JPEG.

181
00:07:18,040 --> 00:07:20,540
הרבה פורמטים של קבצים
בחוץ נוטה להתחיל

182
00:07:20,540 --> 00:07:23,735
עם דפוסים מסוימים של 0s ו 1s,
כך ש- Windows ו- Mac OS, וiOS,

183
00:07:23,735 --> 00:07:28,272
ויודע אנדרואיד איזה סוג של קובץ שהם
הם, בנוסף לקובץ שנקרא

184
00:07:28,272 --> 00:07:29,730
סיומת שהרבה קבצים יש לי.

185
00:07:29,730 --> 00:07:32,590
אם יש לך .jpg, זה
עוד רמז למחשב.

186
00:07:32,590 --> 00:07:35,310
>> אז בואו עכשיו להסתכל על זה
קצת יותר מבחינה טכנית.

187
00:07:35,310 --> 00:07:37,390
אנחנו יודעים עשרוניים
מערכת היא 0 עד 9.

188
00:07:37,390 --> 00:07:38,740
אנחנו יודעים בינארי הוא 0 ו -1.

189
00:07:38,740 --> 00:07:41,842
ואם אתה חושב לחזור לPSet
0, היו לנו אותך להתמודד עם,

190
00:07:41,842 --> 00:07:43,800
עבור קצת, משהו
נקרא הקסדצימלי,

191
00:07:43,800 --> 00:07:47,320
שבו יש לך 16 ספרות,
במקום 10 או במקום 2.

192
00:07:47,320 --> 00:07:50,405
וספרות אלה, על ידי אמנה,
הם 0 עד 9 ולאחר מכן

193
00:07:50,405 --> 00:07:55,040
דרך F, כאשר F מייצג את מה ש
מספר עשרוני, בדיוק כמו שפיות מהירה

194
00:07:55,040 --> 00:07:56,640
לבדוק?

195
00:07:56,640 --> 00:07:57,610
אז, 15.

196
00:07:57,610 --> 00:08:01,390
וחייב לייצג 10, רק על ידי
הטבע של ההזמנה שנתתי לי.

197
00:08:01,390 --> 00:08:04,350
זה רק מוסכמה שרירותית,
אבל זה די סטנדרטי.

198
00:08:04,350 --> 00:08:06,870
>> אז אם אנחנו מסתכלים על דפוס זה
של שלוש bytes-- בואו

199
00:08:06,870 --> 00:08:09,620
פשוט להתחיל להסתכל על זה ב
אופן עקבי עם איך

200
00:08:09,620 --> 00:08:12,450
מדעני מחשב בדרך כלל
להסתכל ולחשוב על קבצים.

201
00:08:12,450 --> 00:08:15,580
אתה בהחלט יכול לחשוב על
קבצים ב0s, ו1s, ועשרוני,

202
00:08:15,580 --> 00:08:19,340
אבל במציאות, אנו נוטים להשתמש בינארי
או יותר בדרך כלל hexadecimal--

203
00:08:19,340 --> 00:08:20,760
חזרה מPSet 0.

204
00:08:20,760 --> 00:08:25,857
אז הרשה לי להציע כי 255, 216, 255 ו
רק דפוסים של 0s ו 1s אלה.

205
00:08:25,857 --> 00:08:28,440
ואתה יכול לבדוק את זה אם אתה
רוצה לעשות את המתמטיקה מהשבוע 0.

206
00:08:28,440 --> 00:08:30,810
אבל, לעת עתה, רק להניח
שזה אכן נכון.

207
00:08:30,810 --> 00:08:33,850
אני פשוט כבר שוכתב שלוש עשרוני
מספרים כשלושה ערכים בינאריים.

208
00:08:33,850 --> 00:08:36,100
עכשיו מה שאני הולך לעשות הוא
רק להוסיף קצת שטח לבן,

209
00:08:36,100 --> 00:08:37,266
רק למען הקריאות.

210
00:08:37,266 --> 00:08:39,940
והודעה, אני רק הולך
לנוע בין דברים.

211
00:08:39,940 --> 00:08:43,090
אז לפני, אחרי, לפני, אחרי.

212
00:08:43,090 --> 00:08:46,180
אני עושה שום דבר מעניין אחרים
לא רק מתפשט החוצה דברים כל כך

213
00:08:46,180 --> 00:08:50,380
הודעה שכל סט של שמונה
ביטים הוא עכשיו שני סטים של ארבעה ביטים.

214
00:08:50,380 --> 00:08:54,920
זה שימושי כי הקסדצימלי
במיוחד אופנתי

215
00:08:54,920 --> 00:09:00,930
כי כל ספרה הקסדצימלי 0 דרך
F, או לייתר דיוק 0 עד 15,

216
00:09:00,930 --> 00:09:03,430
יכול להיות מיוצג
עם בדיוק ארבעה חתיכות.

217
00:09:03,430 --> 00:09:07,960
במילים אחרות, בהקסדצימלי אם אתה
רוצה לייצג 0, זה רק 0000,

218
00:09:07,960 --> 00:09:08,780
ארבעה אפסים.

219
00:09:08,780 --> 00:09:13,997
ואם אתה רוצה לייצג 15,
זה 1111, אשר הוא ארבע חתיכות.

220
00:09:13,997 --> 00:09:16,080
ואם אתה עושה את המתמטיקה,
אם זה המקום אלה,

221
00:09:16,080 --> 00:09:18,210
זה מקום 16s,
זה הולך לתת אתם--

222
00:09:18,210 --> 00:09:19,960
ולא שקורה
צריכה-- מצטער, בינארי,

223
00:09:19,960 --> 00:09:23,660
זה הולך לתת לך 15, מקום אלה,
המקום, ארבע ושמיניות זוגות מקום.

224
00:09:23,660 --> 00:09:26,821
אז הרשה לי להציע ש
סט של ארבעה ביטים בצד השמאל

225
00:09:26,821 --> 00:09:28,070
זה מה שאנחנו הולכים לקרוא F.

226
00:09:28,070 --> 00:09:30,110
זה המספר הגדול ביותר שאתה
יכול לייצג עם ארבע חתיכות.

227
00:09:30,110 --> 00:09:33,300
ואנחנו כבר יודעים מהקסדצימלי,
F הוא הספרה הגדולה ביותר בהקסדצימלי.

228
00:09:33,300 --> 00:09:36,020
יש לנו F אחר שם,
עוד שני שם.

229
00:09:36,020 --> 00:09:38,980
ועכשיו, רק לקחת על אמונה
שאני עשיתי את זכות המתמטיקה

230
00:09:38,980 --> 00:09:41,890
ושהמחצית השמאלית
מאותם קטעים, 1101,

231
00:09:41,890 --> 00:09:43,980
הוא אותו הדבר כמו בד הקסדצימלי.

232
00:09:43,980 --> 00:09:46,490
ויד ימין, 1000, היא רק 8.

233
00:09:46,490 --> 00:09:48,140
>> וזה אחד קל לראות, נכון?

234
00:09:48,140 --> 00:09:51,670
Represents-- 8 נכון
מתחת כי מקום שמיניות.

235
00:09:51,670 --> 00:09:56,040
אז יש לנו אחד בעמודה שמיניות
ושום דבר בארבעה, בזוגות או אלה.

236
00:09:56,040 --> 00:09:59,830
אז עכשיו יותר קונבנציונלי, בני האדם נוטים
כדי לכתוב ספרות הקסדצימלי כמו זה,

237
00:09:59,830 --> 00:10:03,000
אתה פשוט תמחץ אותם יחד,
ואז אתה קידומתם עם 0x.

238
00:10:03,000 --> 00:10:05,920
זה לא אומר כלום מלבד
רמז חזותי לhuman--

239
00:10:05,920 --> 00:10:10,350
כאן מגיע value-- הקסדצימלי כי
זה יכול אחרת לא יהיה ברור.

240
00:10:10,350 --> 00:10:13,629
>> כלומר, בסופו, ש
הדפוס של אפסים ואחדים,

241
00:10:13,629 --> 00:10:16,170
או הדפוס של הקסדצימלי
ספרות שקול שאתה

242
00:10:16,170 --> 00:10:18,990
הולך להתחיל לחפש
בבעיה סט 4 הוא זה--

243
00:10:18,990 --> 00:10:22,120
ומפרט הבעיה סט 4 יצעד
אתה תעבור את זה יותר detail--

244
00:10:22,120 --> 00:10:25,344
אבל מבין כסוג של מסתורי כ
זה עשוי להיראות במבט ראשון,

245
00:10:25,344 --> 00:10:27,010
אתה הולך להתחיל לראות את זה הרבה.

246
00:10:27,010 --> 00:10:30,320
ואכן, גם בGDB,
הבאגים שהצגנו ביום שני

247
00:10:30,320 --> 00:10:35,440
ודן מציג בPSet 3, הולך
ללעתים קרובות להראות לך ערכים הקסדצימליים

248
00:10:35,440 --> 00:10:39,910
רק בגלל שהם נוטים להיות יותר
קונבנציונלי מאשר עשרוני או בינארי

249
00:10:39,910 --> 00:10:41,157
בעולם של מחשבים.

250
00:10:41,157 --> 00:10:42,490
עכשיו בואו לשים את זה בהקשר.

251
00:10:42,490 --> 00:10:48,040
רבים מייתכן שתזכרו את זה
תמונה כאן, שבאו ממה?

252
00:10:48,040 --> 00:10:51,240
Vista, כך שגם מוקדם יותר
ש, Windows XP עשתה את הופעת הבכורה של זה.

253
00:10:51,240 --> 00:10:52,620
אז זה נוף יפה.

254
00:10:52,620 --> 00:10:55,940
ולמעשה, אם אתה לחטט online--
אני חושב שזה מאמר בויקיפדיה,

255
00:10:55,940 --> 00:11:00,110
בי מישהו הלך מאוד להפליא את
מצא מיקום זה בעולם הקים

256
00:11:00,110 --> 00:11:02,240
שלו או את המצלמה שלה ב
בדיוק place-- תקין

257
00:11:02,240 --> 00:11:06,510
והיום זה נראה like-- אבל
זה בדיוק את אותה ההגדרה.

258
00:11:06,510 --> 00:11:10,060
תמונה זו, אם כי, היא בקובץ
מפת סיביות פורמט שנקראה, ב-מ-ע '.

259
00:11:10,060 --> 00:11:12,910
ואנחנו הולכים לקחת סופר
מבט מהיר על מה שזה אומר.

260
00:11:12,910 --> 00:11:17,770
>> אבל מפת סיביות היא רק דרך של שונה
תמונות מייצגות עדיין משתמשים בפיקסלים

261
00:11:17,770 --> 00:11:19,580
ב0s ו 1s, סופו של דבר.

262
00:11:19,580 --> 00:11:23,282
אבל במבט מהיר, יש לו
חתימה מעניינת יותר

263
00:11:23,282 --> 00:11:24,490
בתחילת הקובץ.

264
00:11:24,490 --> 00:11:26,670
זה לא רק שלוש
בתים, ולא שיש

265
00:11:26,670 --> 00:11:30,770
חבורה של דפוסים של בתים שלמה
שנקבע מראש משמעות.

266
00:11:30,770 --> 00:11:34,490
לדוגמא, אי שם ב
כמה בתים הראשונים של תמונת מפת סיביות

267
00:11:34,490 --> 00:11:37,440
הוא הולך להיות בגודל של
תמונה, הרוחב של התמונה,

268
00:11:37,440 --> 00:11:40,390
הגובה של התמונה, כך
מטה שימושי, אם תרצה.

269
00:11:40,390 --> 00:11:43,940
מידע שימושי שפוטושופ
או כל גרפיקה לתכנת אתה משתמש

270
00:11:43,940 --> 00:11:45,180
אולי באמת אכפת.

271
00:11:45,180 --> 00:11:47,170
>> אז עוד על כך ב
בעיה הוגדר 4, אבל זה

272
00:11:47,170 --> 00:11:49,220
רק לומר ש
בסופו של היום

273
00:11:49,220 --> 00:11:52,390
כל הפורמטים של הקבצים שאתה כבר משתמש
עבור קבצי Microsoft Word years--,

274
00:11:52,390 --> 00:11:55,820
קבצי מספרים, קבצי Excel,
כל מספר של פורמטים של קבצים

275
00:11:55,820 --> 00:11:57,770
שאולי יש לי כמה
סיומת קובץ ידועה

276
00:11:57,770 --> 00:12:00,130
רק 0s ו 1s מתחת למכסת המנוע.

277
00:12:00,130 --> 00:12:02,970
ובני האדם החליטו
מה הן האמנות,

278
00:12:02,970 --> 00:12:08,340
מה דפוסי 0s ו 1s מייצגים
קובץ Word לעומת קובץ Excel,

279
00:12:08,340 --> 00:12:10,322
לעומת כל מספר של פורמטים של קבצים אחרים.

280
00:12:10,322 --> 00:12:12,780
אז בPSet 4, יהיה לך
הזדמנות לשחק עם זה.

281
00:12:12,780 --> 00:12:14,405
>> אבל מה זה אומר שיש לי struct.

282
00:12:14,405 --> 00:12:18,012
זהו למעשה segue נחמד עכשיו
לC, שבו יש רק כמה

283
00:12:18,012 --> 00:12:20,220
תכונות של נוספות ש
אנחנו לא בחנו עדיין.

284
00:12:20,220 --> 00:12:24,230
זו שפה די קטנה ואחד
התכונות נחמדים על C היא struct.

285
00:12:24,230 --> 00:12:27,300
לדוגמא, אם אתה
רציתי represent-- בואו

286
00:12:27,300 --> 00:12:33,690
אמרתי שאתה רוצה יש לי משתנה ש
מייצג סטודנט בתכנית כלשהי.

287
00:12:33,690 --> 00:12:37,330
אולי אתה כותב כמובן
תכנית רישום, או קניות ליבה

288
00:12:37,330 --> 00:12:38,870
כלי, או משהו כזה.

289
00:12:38,870 --> 00:12:42,922
מה הן פיסות של נתונים הקשורים
לתלמיד שמגיע אל המוח?

290
00:12:42,922 --> 00:12:44,880
כמו תלמיד
מיוצג עם מה ערכים?

291
00:12:44,880 --> 00:12:45,732
כן?

292
00:12:45,732 --> 00:12:46,940
יש לך שם כסטודנט.

293
00:12:46,940 --> 00:12:48,900
מה עוד יש לי תלמיד טיפוסי?

294
00:12:48,900 --> 00:12:49,320
>> קהל: [לא ברור]

295
00:12:49,320 --> 00:12:50,200
>> דוד י מלאן: אז, מצטער.

296
00:12:50,200 --> 00:12:50,660
>> קהל: גיל.

297
00:12:50,660 --> 00:12:52,980
>> דוד י מלאן: גיל או
יום הולדת באופן שקול, כן.

298
00:12:52,980 --> 00:12:53,557
מה עוד?

299
00:12:53,557 --> 00:12:54,390
קהל: מספר תעודת זהות?

300
00:12:54,390 --> 00:12:57,460
דוד י מלאן: אז מספר תעודת זהות, אולי
מספר טלפון, אולי במעונות, או בית,

301
00:12:57,460 --> 00:12:58,670
או במכללה, או משהו כזה.

302
00:12:58,670 --> 00:13:01,820
כל מספר של פיסות מידע ש
אולי יש לך ברשימת אנשי הקשר שלך

303
00:13:01,820 --> 00:13:03,890
זה מה שעשוי להגדיר תלמיד.

304
00:13:03,890 --> 00:13:08,490
אז אם אנחנו רוצים לעשות את זה, בקוד,
אנחנו יכולים לעשות משהו פשוט כמו זה.

305
00:13:08,490 --> 00:13:15,670
אולי יש לנו תכנית, כך ש
יש נניח, int הראשי (void).

306
00:13:15,670 --> 00:13:18,920
ואם אני רוצה לייצג
סטודנט שאולי אני צריך, למשל,

307
00:13:18,920 --> 00:13:24,330
מחרוזת קראה בשם לתלמיד ש,
מחרוזת נקראת מעונות לסטודנטים ש,

308
00:13:24,330 --> 00:13:26,900
אולי int נקרא זיהוי לתלמיד ש.

309
00:13:26,900 --> 00:13:30,840
ומכיוון שאני משתמש בחוט, אני
צריך לחזור ולשים את CS50.h.

310
00:13:30,840 --> 00:13:33,300
אולי אני צריך ללכת stdio.h.

311
00:13:33,300 --> 00:13:38,190
אז תן לי לעשות מנעו אלה ואני
הולך לקרוא student.c זה לעת עתה

312
00:13:38,190 --> 00:13:40,080
ולשמור את זה.

313
00:13:40,080 --> 00:13:44,206
>> ועכשיו אני יכול לעשות משהו
עם המשתנים הללו.

314
00:13:44,206 --> 00:13:46,830
ואנחנו רק הולכים לכתוב
כי כתגובה בקוד פסאודו,

315
00:13:46,830 --> 00:13:48,829
כי זה לא מעניין
מה שאנחנו עושים עכשיו.

316
00:13:48,829 --> 00:13:51,242
אוקיי, אז זה הוא תכנית ש
איכשהו מאחסן תלמיד.

317
00:13:51,242 --> 00:13:53,450
מה אני רוצה לעשות אם אני
רוצה לאחסן שני תלמידים?

318
00:13:53,450 --> 00:13:55,991
אז האינסטינקט הראשון שלי הולך
יהיה בסדר, חכה רגע,

319
00:13:55,991 --> 00:14:01,920
אם יש לי תלמיד אחר למה לא אני
פשוט לעשות מחרוזת 2 שם, מחרוזת במעונות 2,

320
00:14:01,920 --> 00:14:04,190
ID2 int.

321
00:14:04,190 --> 00:14:06,540
ושעשינו נעלם
בדרך הזאת לפני

322
00:14:06,540 --> 00:14:10,890
ומה היה הפתרון שלנו למה שנראה
להיות סוג של העתק דבק hackish

323
00:14:10,890 --> 00:14:11,555
עבודה כאן?

324
00:14:11,555 --> 00:14:12,346
קהל: מערך.

325
00:14:12,346 --> 00:14:13,830
דוד י מלאן: כן,
אנחנו יכולים להשתמש במערך.

326
00:14:13,830 --> 00:14:15,620
זכות זו מהר מאוד
הופך מסורבל.

327
00:14:15,620 --> 00:14:18,453
אתה צריך למיין של שרירותי
להתחיל שמות כל אחד מהמשתנים הללו.

328
00:14:18,453 --> 00:14:22,190
ואתה, האדם, צריך לשמור
לעקוב המתאים NAME2 אישור

329
00:14:22,190 --> 00:14:25,060
עם dorm2 מתכתב עם ID2.

330
00:14:25,060 --> 00:14:26,200
זה פשוט הופך להיות בלגן.

331
00:14:26,200 --> 00:14:29,350
אז זה הרבה יותר קל,
זוכר מלפני כמה שבועות,

332
00:14:29,350 --> 00:14:34,300
רק שיש לשמות מחרוזת נקראים
ואולי לתת לנו שלושה מאלה.

333
00:14:34,300 --> 00:14:36,940
ואז אולי יש לנו
מעונות מחרוזת ויש לי

334
00:14:36,940 --> 00:14:41,900
שלושה מאלה, או עם קבוע,
int תעודות זהות ויש לי שלושה מאלה.

335
00:14:41,900 --> 00:14:45,250
אבל גם עכשיו זה מרגיש
מרושל, נכון קטן.

336
00:14:45,250 --> 00:14:49,440
על תלמידים, ובכל זאת אנחנו מדברים
אני באמת מגורים ברמה הנמוכה

337
00:14:49,440 --> 00:14:50,470
פרטי יישום.

338
00:14:50,470 --> 00:14:52,790
התלמיד הוא שם ומעונות וזיהוי.

339
00:14:52,790 --> 00:14:59,814
>> למה אני לא יכול פשוט להצהיר על משתנה
בשם תלמיד וקוראים לזה זה.

340
00:14:59,814 --> 00:15:02,230
ואם אני רוצה תלמיד אחר,
למה אני לא רק קורא לזה לא.

341
00:15:02,230 --> 00:15:05,260
או אם אני רוצה כל חבורה
של תלמידים, למה לא אני רק

342
00:15:05,260 --> 00:15:09,740
אומר שיש לי בכיתה של כל
תלמידים, וזה שלושה מהם.

343
00:15:09,740 --> 00:15:12,470
במילים אחרות, למה אני לא יכול לבוא
עם הסוג שלי נתונים, הנקרא

344
00:15:12,470 --> 00:15:15,641
סטודנטים, בתוכה הוא
שם, הוא זהות, היא במעונות,

345
00:15:15,641 --> 00:15:16,890
הוא מספר כלשהו של תחומים אחרים.

346
00:15:16,890 --> 00:15:19,030
ומתברר לך
יכול לעשות בדיוק את זה.

347
00:15:19,030 --> 00:15:21,850
>> אז יש C תכונה זו נקראת struct.

348
00:15:21,850 --> 00:15:24,700
זה תכונת שפה ש
מאפשר לנו לעשות בדיוק את זה.

349
00:15:24,700 --> 00:15:28,370
אני הולך קדימה
ולפתוח structs.h

350
00:15:28,370 --> 00:15:32,299
לאן אנחנו הולכים לראות
הבא הגדרה של תלמיד.

351
00:15:32,299 --> 00:15:35,215
מתברר - וזה אחד אפילו
פשוטה יותר מזו כרוכה בזיהוי

352
00:15:35,215 --> 00:15:36,080
רגע לפני.

353
00:15:36,080 --> 00:15:39,120
אם אתה רוצה לבוא עם
סוג נתוני תוצרת בית שלך,

354
00:15:39,120 --> 00:15:42,750
ובנוסף לint, char ו
לצוף וכל האחרים אלה שקיימים,

355
00:15:42,750 --> 00:15:45,810
אתה יכול לעשות זאת על ידי פשוטו כמשמעו
כתיבת struct typedef,

356
00:15:45,810 --> 00:15:47,880
אז כמה סוגריים מסולסלים,
בתוך שבו אתה

357
00:15:47,880 --> 00:15:51,460
רשימת המשתנים שאתה רוצה
לקשר עם נתונים מותאמים אישית חדשים

358
00:15:51,460 --> 00:15:55,670
הקלד כמו שם ומעונות,
ואז אחרי הסוגריים המסולסלים

359
00:15:55,670 --> 00:15:57,860
אתה נותן שם לסוג הנתונים החדש.

360
00:15:57,860 --> 00:15:59,220
כך, למשל, תלמיד.

361
00:15:59,220 --> 00:16:03,247
>> ומה שיפה זה שעכשיו הוא
אם אנחנו מסתכל על הקוד המקביל,

362
00:16:03,247 --> 00:16:05,080
הכנס, ראשון
מכל, הוא לשים את זה

363
00:16:05,080 --> 00:16:08,230
בע"ה נקודת משהו קובץ בשם,
קובץ כותרת, שיש לנו לא

364
00:16:08,230 --> 00:16:09,780
התחיל להשתמש בעצמנו יותר מדי.

365
00:16:09,780 --> 00:16:12,120
אבל אנחנו הולכים להתחיל
באמצעות לא מעט עכשיו.

366
00:16:12,120 --> 00:16:18,650
ומה אנחנו יכולים לעשות עם זה,
סופו של דבר, בכמה שורות הקוד האלה

367
00:16:18,650 --> 00:16:22,130
הוא מצהיר בדיוק ש
סוג הנתונים, תלמיד.

368
00:16:22,130 --> 00:16:23,230
ועכשיו בואו להשתמש בו.

369
00:16:23,230 --> 00:16:27,274
>> אני הולך עכשיו ל
קובץ בשם structs1.c.

370
00:16:27,274 --> 00:16:29,440
ובואו נסתכל
כמה מאפיינים כאן.

371
00:16:29,440 --> 00:16:32,250
אז הדברים עד כאן הוא
בעיקר מוכר, ואנו

372
00:16:32,250 --> 00:16:35,040
אחזור למה שהוא לא
מוכר ברגע.

373
00:16:35,040 --> 00:16:39,880
זה כמובן כולל
קובץ כותרת, שהיא חדשה, כמו גם,

374
00:16:39,880 --> 00:16:42,580
פרט לPSet 3 שבו,
כזכור, יש לנו helpers.h.

375
00:16:42,580 --> 00:16:45,150
אז אתה יכול להיזכר helpers.h #include.

376
00:16:45,150 --> 00:16:49,381
>> למה למרות שאני משתמש ציטוטים
במקום סוגריים זווית?

377
00:16:49,381 --> 00:16:50,630
כאשר אני בוחר ביניהם?

378
00:16:50,630 --> 00:16:52,310
כמעט תמיד אני נראה
להשתמש בסוגריים בזווית.

379
00:16:52,310 --> 00:16:55,040
ואז, פתאום ב
קו שש אני משתמש במרכאות כפולות.

380
00:16:55,040 --> 00:16:55,860
למה זה יכול להיות?

381
00:16:55,860 --> 00:16:56,700
כן?

382
00:16:56,700 --> 00:16:57,725
>> קהל: [לא ברור]

383
00:16:57,725 --> 00:16:59,350
דוד י מלאן: זה בפועל, מה?

384
00:16:59,350 --> 00:17:00,559
קהל: זה בIDE שלך.

385
00:17:00,559 --> 00:17:02,475
דוד י מלאן: כן,
זה בIDE בפועל.

386
00:17:02,475 --> 00:17:05,690
ובואו לא להתעכב על IDE, כי
זה רק כלי שאני משתמש.

387
00:17:05,690 --> 00:17:08,119
זה בנוכחי שלי
ספרייה, באופן ספציפי.

388
00:17:08,119 --> 00:17:11,647
אז structs.h הוא הקובץ שלי
אינו מותקן בIDE,

389
00:17:11,647 --> 00:17:14,480
במערכת ההפעלה עצמה,
ולא זה בספרייה הנוכחית שלי.

390
00:17:14,480 --> 00:17:16,910
אז הכנס הוא אם אתה רוצה
לכלול קובץ הכותרת שלך,

391
00:17:16,910 --> 00:17:18,200
אתה פשוט להשתמש במרכאות כפולות.

392
00:17:18,200 --> 00:17:23,290
>> מה שאנחנו קוראים את הדבר הזה ב
קו 8, באופן כללי?

393
00:17:23,290 --> 00:17:25,200
זה מה?

394
00:17:25,200 --> 00:17:28,220
משהו define #.

395
00:17:28,220 --> 00:17:31,040
זה מייצג קבוע, נכון?

396
00:17:31,040 --> 00:17:33,140
אם אתה רוצה יש לי
ערך בתכנית שלך

397
00:17:33,140 --> 00:17:35,110
שאתה משתמש בכל
חבורה של פעמים, זה

398
00:17:35,110 --> 00:17:39,330
כנס טוב גורם אותו,
להכריז עליו, עם סמל החשיש

399
00:17:39,330 --> 00:17:43,340
להגדיר, אז, על ידי אמנה, בכל
אותיות רישיות word-- למרות שזה לא

400
00:17:43,340 --> 00:17:45,320
בהחלט הכרחי, אבל
זה כנס אנושי

401
00:17:45,320 --> 00:17:47,210
לנצל קבועים
כך שהם קופצים החוצה

402
00:17:47,210 --> 00:17:50,380
בך visually-- חלל ו
לאחר מכן הערך שאתה רוצה להיות

403
00:17:50,380 --> 00:17:52,250
שווה ערך לשמו של קבוע ש.

404
00:17:52,250 --> 00:17:56,110
לא פסיק, אבל אתה פשוט
על פי תבנית שיש.

405
00:17:56,110 --> 00:17:57,770
>> אז מה אני עושה בקוד בפועל זה.

406
00:17:57,770 --> 00:18:00,660
אז בואו נסתכל
התכנית העיקרית כאן.

407
00:18:00,660 --> 00:18:04,080
בקו 12 כי אני
כללתי structs.h,

408
00:18:04,080 --> 00:18:06,492
עכשיו יש לי באורח פלא בי
רשות סוג נתונים חדש.

409
00:18:06,492 --> 00:18:09,200
אין לי רק גישה לint,
וchar, ולצוף, ומחרוזת,

410
00:18:09,200 --> 00:18:10,060
וכחול ועוד.

411
00:18:10,060 --> 00:18:12,470
עכשיו יש לי גישה ל
סוג נתוני תלמידים.

412
00:18:12,470 --> 00:18:17,740
אז בקו 12, אני שילוב של שני
ideas-- אחד סוג נתונים מותאם אישית ושני,

413
00:18:17,740 --> 00:18:18,940
באמצעות מערך.

414
00:18:18,940 --> 00:18:21,700
וכך בתכנית זו אם
אני רוצה לתמוך למעשה

415
00:18:21,700 --> 00:18:24,320
שלושה תלמידים שונים
בתכנית שלי, אני

416
00:18:24,320 --> 00:18:30,480
פשוט יכול לומר לי משתנה
סטודנטים שנקראו, כל אחד מהם

417
00:18:30,480 --> 00:18:32,970
הוא סוג של תלמידים, ש
הוא סוג נתונים מותאמים אישית שלי.

418
00:18:32,970 --> 00:18:35,890
ו, במיוחד, תן לי
שלושה מאלה במערך שלי.

419
00:18:35,890 --> 00:18:37,750
>> אז עכשיו מה שאנחנו עושים בתכנית זו?

420
00:18:37,750 --> 00:18:40,670
הנה רק לiterating לולאה
0-3, כי זה

421
00:18:40,670 --> 00:18:42,110
מהו הערך של תלמידים.

422
00:18:42,110 --> 00:18:44,420
אני רק להציג הודעה למשתמש
תן לי את שמו של התלמיד.

423
00:18:44,420 --> 00:18:48,090
ולאחר מכן בקו 17, ש
יש קו בעיקר מוכר.

424
00:18:48,090 --> 00:18:50,370
יש לנו ידידנו הוותיק
GetString בצד הימין.

425
00:18:50,370 --> 00:18:52,345
ומה קטע של תחביר
חדש כנראה,

426
00:18:52,345 --> 00:18:55,130
אם מעולם לא מתוכנת ב- C לפני,
ומעולם לא השתמש structs?

427
00:18:55,130 --> 00:18:55,510
כן?

428
00:18:55,510 --> 00:18:56,417
>> קהל: .name.

429
00:18:56,417 --> 00:18:57,500
דוד י מלאן: .name.

430
00:18:57,500 --> 00:19:01,220
אבל זה לא יותר מדי של קפיצה,
כי עכשיו אני סוגרים תלמידים

431
00:19:01,220 --> 00:19:02,590
נותן לך את תלמיד i-ה.

432
00:19:02,590 --> 00:19:04,730
ואם אתה רוצה לצלול
בתוך המבנה ש,

433
00:19:04,730 --> 00:19:09,490
אתה פשוט להשתמש תקופה אחת ו
לאחר מכן את השם של המשתנה בתוך,

434
00:19:09,490 --> 00:19:11,900
או הרכוש בתוך ש
אתה רוצה לקבל גישה ל.

435
00:19:11,900 --> 00:19:14,816
כמו כן, אם אני מכן תנחה
משתמש, נותן לי במעונות של הסטודנטים,

436
00:19:14,816 --> 00:19:18,390
באופן דומה ניתן לאחסן ש
מחרוזת במשתנה המעונות בתוך

437
00:19:18,390 --> 00:19:19,940
של מבנה שהתלמיד.

438
00:19:19,940 --> 00:19:21,410
>> ועכשיו דברים לקבל קצת מפואר.

439
00:19:21,410 --> 00:19:24,420
וזה הולך להיראות
באולי הרבה די בקרוב.

440
00:19:24,420 --> 00:19:27,970
אבל אתה רואה את זה הרבה יותר בPSet
4, אז בואו רק מבט חטוף על זה עכשיו.

441
00:19:27,970 --> 00:19:33,364
מתברר כי בקו 23 ב
38, מה אתה חושב שאני אולי אני עושה?

442
00:19:33,364 --> 00:19:35,530
אני כבר הסרתי את ההערות
להיום, אבל את הגרסה

443
00:19:35,530 --> 00:19:38,660
של הקוד באינטרנט ל
יש התייחסות כל ההערות.

444
00:19:38,660 --> 00:19:40,171
מה אני נראה עושה?

445
00:19:40,171 --> 00:19:42,530
>> קהל: שמירת הקובץ עם כל
המידע שהמשתמש נכנס.

446
00:19:42,530 --> 00:19:44,530
>> דוד י מלאן: כן,
בדיוק, זה הוא דרך חדשה

447
00:19:44,530 --> 00:19:46,370
כי אנחנו רואים שני,
תכונה נוספת של C,

448
00:19:46,370 --> 00:19:48,700
לפי שאני יכול ליצור קבצים שלי.

449
00:19:48,700 --> 00:19:51,580
עד כה, כמעט בכל תכנית
שכתבת הוא חסר אזרחות.

450
00:19:51,580 --> 00:19:53,334
ברגע שזה נעשה בריצה, וזהו.

451
00:19:53,334 --> 00:19:55,000
אין זיכרון או זיכרון שלו.

452
00:19:55,000 --> 00:19:56,110
אין קובץ שנשמר.

453
00:19:56,110 --> 00:19:58,120
אבל אם אתה רוצה
להציל את הקלט שיש

454
00:19:58,120 --> 00:20:02,100
קרה, כמו במשחק או תכנית
כמו זה, מתברר שאנחנו יכולים לעשות זאת.

455
00:20:02,100 --> 00:20:04,360
ואתה רואה את זה יותר
ב 4 PSet ובסעיף.

456
00:20:04,360 --> 00:20:08,661
אבל הקו הזה 23 במהות
יוצר קובץ בשם students.csv.

457
00:20:08,661 --> 00:20:10,160
וייתכן שלא ראה לפני זה.

458
00:20:10,160 --> 00:20:14,250
גם אם אף פעם לא למדו מדעי המחשב לפני,
CSV הוא משתנים מופרדים בפסיקים.

459
00:20:14,250 --> 00:20:19,000
זה כמו גבר של עניים מאוד
גרסה של קובץ Excel,

460
00:20:19,000 --> 00:20:22,270
מה שאומר שזה יכול להיות נפתח
ב- Excel ובמספרי אפל,

461
00:20:22,270 --> 00:20:23,830
ויש לו שורות ועמודות.

462
00:20:23,830 --> 00:20:26,485
אבל זה לא קניינית
פורמט כמו מיקרוסופט או אפל של.

463
00:20:26,485 --> 00:20:29,840
זה רק פסיקים מפרידים
ערכים שאנו רואים ברגע.

464
00:20:29,840 --> 00:20:31,010
>> ופשוט לקחת את ניחוש.

465
00:20:31,010 --> 00:20:33,480
בקו 23, במאוד
הסוף, הטיעון השני שלי

466
00:20:33,480 --> 00:20:37,700
לפונקציה החדשה הזה שנקרא
ו פתוח לפתוח קובץ הוא w.

467
00:20:37,700 --> 00:20:39,430
מה יכול w לציין?

468
00:20:39,430 --> 00:20:40,022
כן?

469
00:20:40,022 --> 00:20:41,260
>> קהל: הוא מאפשר לך לכתוב לקובץ?

470
00:20:41,260 --> 00:20:42,630
>> דוד י מלאן: הוא מאפשר לי
אתה כותב לקובץ.

471
00:20:42,630 --> 00:20:44,810
אז יש כמה גרסאות
שאנחנו יכולים לחבר כאן.

472
00:20:44,810 --> 00:20:47,184
אבל אם אתה רק רוצה לקרוא
הקובץ, שהוא מסתכל על זה

473
00:20:47,184 --> 00:20:50,010
ולקרוא אותו בזיכרון, אתה
פשוט להשתמש סוף ציטוט ציטוט "R".

474
00:20:50,010 --> 00:20:53,110
אם אתה רוצה לכתוב ל
קובץ, אתה משתמש בציטוט סוף ציטוט "W".

475
00:20:53,110 --> 00:20:55,190
גם יש לצרף ו
כמה דברים אחרים

476
00:20:55,190 --> 00:20:57,356
אם אתה רוצה לשנות את הקבצים קיימים.

477
00:20:57,356 --> 00:21:00,480
עכשיו אנחנו הולכים לשמור רואים את זה
דבר, אז אנחנו נחזור לקו 24.

478
00:21:00,480 --> 00:21:02,640
NULL, מתברר, הוא
ערך מיוחד ש

479
00:21:02,640 --> 00:21:06,070
ניתן להחזיר ידי פונקציות מסוימות
אם משהו הלך wrong--

480
00:21:06,070 --> 00:21:08,490
אם הקובץ לא קיים,
אם אתה כבר נגמר זיכרון,

481
00:21:08,490 --> 00:21:09,620
או חבורה של טעויות אחרות.

482
00:21:09,620 --> 00:21:13,470
אבל לעת עתה, בואו פשוט להניח שזה
היא בדיקת שגיאות פשוט קונבנציונלית.

483
00:21:13,470 --> 00:21:17,090
כאן בקו 26, אני iterating
0-3 על כל התלמידים שלי.

484
00:21:17,090 --> 00:21:20,470
וזה סוג של סוג
של פונקציה חדשה, fprintf,

485
00:21:20,470 --> 00:21:21,460
אבל רק לקחת ניחוש.

486
00:21:21,460 --> 00:21:24,370
אם printf הוא רק הדפסה
מחרוזת מעוצבת,

487
00:21:24,370 --> 00:21:26,507
מה fprintf כנראה מתכוונת?

488
00:21:26,507 --> 00:21:27,590
קהל: הדפסה לקובץ.

489
00:21:27,590 --> 00:21:29,290
דוד י מלאן: הדפסה
מחרוזת מעוצבת לקובץ.

490
00:21:29,290 --> 00:21:31,180
זה מה נוסף
אמצעי F הוא קובץ.

491
00:21:31,180 --> 00:21:36,420
והטיעון הראשון החדש צריך להיות
משתנה המייצג את הקובץ שלך.

492
00:21:36,420 --> 00:21:38,866
אז פשוט יש לנו פורמט
מחרוזת בדיוק כמו printf.

493
00:21:38,866 --> 00:21:40,740
ולמרות שזה
תחביר הוא חדש, זה פשוט

494
00:21:40,740 --> 00:21:44,610
הפירוש לחבר את שמו של הסטודנט,
התוספת מעונות סטודנטים, ולאחר מכן

495
00:21:44,610 --> 00:21:47,160
עם fclose, לסגור את התיק.

496
00:21:47,160 --> 00:21:49,730
ולאחר מכן lastly-- זה חדש
ואנחנו נחזור לזה

497
00:21:49,730 --> 00:21:53,240
לפני long-- אני משחרר
סטודנט מסיבות

498
00:21:53,240 --> 00:21:54,860
שקרה למעלה שם.

499
00:21:54,860 --> 00:21:56,820
אבל אנחנו נחזור
שללפני long--

500
00:21:56,820 --> 00:21:59,820
זה בגלל איך GetString הוא
למעשה עובד מתחת למכסת המנוע.

501
00:21:59,820 --> 00:22:01,280
>> אז בואו ניקח מבט מהיר כאן.

502
00:22:01,280 --> 00:22:04,380
אם אני מקליד LS בספרייה שלי,
שם לב שאני לא

503
00:22:04,380 --> 00:22:09,360
יש קובץ שנקרא students.csv,
פשוט לא שם, לא קיימות.

504
00:22:09,360 --> 00:22:14,965
אז אם אני עכשיו ללקט תכנית זו,
להפוך structs-1,. / Structs-1,

505
00:22:14,965 --> 00:22:20,570
ואני הולך קדימה ולהקליד
אנדי, שחי בברקלי באוניברסיטת ייל.

506
00:22:20,570 --> 00:22:26,350
אנחנו הולכים יש רוב ש
גר ביאיירו בימים אלה.

507
00:22:26,350 --> 00:22:33,760
ובואו לבוא עם שם
הוא, אני חושב, מריה היא במאת'ר,

508
00:22:33,760 --> 00:22:35,100
אם אני זוכר נכון.

509
00:22:35,100 --> 00:22:36,460
>> אז שום דבר לא נראה לקרות.

510
00:22:36,460 --> 00:22:40,680
אבל אם אני מקליד ls עכשיו,
יש students.csv.

511
00:22:40,680 --> 00:22:43,080
בואו נלך קדימה וstudents.csv הפתוח.

512
00:22:43,080 --> 00:22:46,050
זה שוב מאוד
קובץ בפורמט קל.

513
00:22:46,050 --> 00:22:49,570
אבל אני כבר פשוט אימצתי ועידה
כי יש לי שתי שורות ועמודות כאן.

514
00:22:49,570 --> 00:22:52,020
העמודה הראשונה היא
כל השמות של אנשים.

515
00:22:52,020 --> 00:22:55,740
העמודה השנייה היא של התלמיד
מעונות, או במכללה, או בית, או מה שלא.

516
00:22:55,740 --> 00:22:57,900
ועכשיו אני כבר הצלתי זה
באופן קבוע בקובץ.

517
00:22:57,900 --> 00:22:59,280
>> אז זה לא כל כך מעניין.

518
00:22:59,280 --> 00:23:02,980
אבל זה רק קרש קפיצה עכשיו
כדי להיות מסוגל להתמיד מידע

519
00:23:02,980 --> 00:23:04,040
באופן קבוע.

520
00:23:04,040 --> 00:23:08,340
אז בואו לראות עכשיו מה שאנחנו יכולים יותר
לעשות עם תכונות אלו ואחרות.

521
00:23:08,340 --> 00:23:10,729
אבל קודם, כל שאלות?

522
00:23:10,729 --> 00:23:12,145
זה היה הרבה, וזה היה מהיר.

523
00:23:12,145 --> 00:23:16,131
אבל אתה תראה הרבה
יותר בPSet 4, כמו גם.

524
00:23:16,131 --> 00:23:16,630
כן?

525
00:23:16,630 --> 00:23:19,360
>> קהל: האם יש דרך ל
להמשיך ולהוסיף שמות לקובץ זה?

526
00:23:19,360 --> 00:23:19,880
>> דוד י מלאן: שאלה טובה.

527
00:23:19,880 --> 00:23:21,800
האם יש דרך להמשיך
הוספת שמות לקובץ זה?

528
00:23:21,800 --> 00:23:22,340
כן.

529
00:23:22,340 --> 00:23:24,630
ואכן, אם בסופו
עד מחדש לפתוח את הקובץ,

530
00:23:24,630 --> 00:23:26,780
היית משתמש ציטוט
סוף ציטוט "" לצרף,

531
00:23:26,780 --> 00:23:31,090
אשר תוסיף רק בשורה חדשה,
קו חדש שוב ושוב, בדיוק.

532
00:23:31,090 --> 00:23:32,010
שאלה טובה.

533
00:23:32,010 --> 00:23:32,950
שאלות אחרות?

534
00:23:32,950 --> 00:23:33,450
כן?

535
00:23:33,450 --> 00:23:35,580
קהל: אם אתה רץ
תכנית שוב עכשיו,

536
00:23:35,580 --> 00:23:38,000
היה זה לשמור על הוספת שמות ל
להגיש או שזה לפתוח את קובץ חדש?

537
00:23:38,000 --> 00:23:38,740
>> דוד י מלאן: אה, שאלה טובה.

538
00:23:38,740 --> 00:23:41,448
אם אתה רץ שוב את התכנית נכונה
עכשיו, אולי הקליד בשמות חדשים,

539
00:23:41,448 --> 00:23:44,820
היה זה כדי להוסיף את הקובץ
או להחליף את הקובץ?

540
00:23:44,820 --> 00:23:47,420
האחרון, כי אני
לא משתמש במצב צרף.

541
00:23:47,420 --> 00:23:49,930
ובגלל שאני רק באופן עיוור
פתיחת הקובץ לכתיבה,

542
00:23:49,930 --> 00:23:51,310
זה פשוט הולך להחליף את הקובץ.

543
00:23:51,310 --> 00:23:54,570
אז אכן הייתי צריך לעשות הוא להוסיף,
אם אני רוצה להיות למעשה לטווח ארוך

544
00:23:54,570 --> 00:23:55,350
מאגר מידע.

545
00:23:55,350 --> 00:23:58,220
>> עכשיו CSV שימושי, בכנות, אפילו
עבור כמו אם אתה writing--

546
00:23:58,220 --> 00:24:00,100
וסופו של דבר יראו את זה
מאוחר יותר בסמסטר שבו

547
00:24:00,100 --> 00:24:01,455
אנו משתמשים בקובצי CSV למטרות אחרות.

548
00:24:01,455 --> 00:24:04,920
אם אתה רוצה לאחסן את כל האנשים
שנרשמו לאירוע כלשהו,

549
00:24:04,920 --> 00:24:07,420
או נרשם לתלמיד שלך
קבוצה, או משהו כזה,

550
00:24:07,420 --> 00:24:10,330
אחסון הנתונים בסוג זה
פורמט של סופר נוח.

551
00:24:10,330 --> 00:24:12,580
בגלל פשוטו כמשמעו, אם אני
היו להוריד קובץ זה.

552
00:24:12,580 --> 00:24:14,540
אני יכול double-- ו
בואו ננסה בעצם זה

553
00:24:14,540 --> 00:24:16,720
אם יש לי Excel או מספרים כאן.

554
00:24:16,720 --> 00:24:19,130
>> אני הולך לחיצה ימנית
או לחץ שליטת הקובץ שלי.

555
00:24:19,130 --> 00:24:20,020
אופס.

556
00:24:20,020 --> 00:24:21,830
לחץ לחיצה ימנית או קש Control הקובץ שלי.

557
00:24:21,830 --> 00:24:24,960
יאללה, העכבר שלי לא משתף פעולה.

558
00:24:24,960 --> 00:24:32,694
Download-- אני הולך
להוריד את כל הקבצים כאן כל כך

559
00:24:32,694 --> 00:24:33,860
רק אז אני יכול לתפוס את זה.

560
00:24:33,860 --> 00:24:37,850
ובואו נראה אם ​​זה עובד
פעם הראשונה students.csv--

561
00:24:37,850 --> 00:24:39,310
אני כבר הופעל.

562
00:24:39,310 --> 00:24:41,360
עכשיו הם רוצים לראות את אנשי הקשר שלי.

563
00:24:41,360 --> 00:24:44,310
עכשיו, אני צריך להירשם.

564
00:24:44,310 --> 00:24:47,620
ראה כמה זה קל לשימוש קובצי CSV?

565
00:24:47,620 --> 00:24:50,840
כן, לשמור אותו מעודכן.

566
00:24:50,840 --> 00:24:52,375
אוקיי, עכשיו אנחנו מוכנים לכיתה.

567
00:24:52,375 --> 00:24:58,750

568
00:24:58,750 --> 00:25:00,370
אישור, הו, מה חדש?

569
00:25:00,370 --> 00:25:02,920
אישור, קרוב.

570
00:25:02,920 --> 00:25:04,750
זה היה קסום.

571
00:25:04,750 --> 00:25:07,280
אוקיי, עכשיו אנחנו צריכים לעדכן.

572
00:25:07,280 --> 00:25:10,890
ועכשיו, זה מה ששכח
להגיש פתחתי במקור,

573
00:25:10,890 --> 00:25:13,090
אבל מה זה-- שם אנחנו הולכים.

574
00:25:13,090 --> 00:25:16,341
אוקיי, אז עכשיו יש לנו קובץ Excel.

575
00:25:16,341 --> 00:25:18,290
תודה.

576
00:25:18,290 --> 00:25:20,764
>> אוקיי, אז מה שעשיתי היה החלק קל.

577
00:25:20,764 --> 00:25:23,930
כמובן שאני יכול היה מותקן מראש
Excel, או מספרים, או מה תכנית.

578
00:25:23,930 --> 00:25:25,846
אבל זה נחמד, כי
עכשיו אני יכול לתפעל

579
00:25:25,846 --> 00:25:28,090
הנתונים בפורמט סטנדרטי.

580
00:25:28,090 --> 00:25:30,294
>> הקשר אז עכשיו בואו
לעבור למקום שבו הפסקנו

581
00:25:30,294 --> 00:25:32,710
הפעם האחרונה, שהייתה להתחיל
להמריא גלגלי עזר.

582
00:25:32,710 --> 00:25:34,543
אבל קודם, אתה לא
לראות צהריים מוקדם יותר

583
00:25:34,543 --> 00:25:38,150
קורה כאן שוב באש ו
קרח בקיימברידג ', סיטאר בניו הייבן.

584
00:25:38,150 --> 00:25:43,150
הרשמה באתר האינטרנט של CS50s בהקדם האפשרי
להצטרף תלמידי CS50 וצוות.

585
00:25:43,150 --> 00:25:46,090
>> אז לקחנו גלגלים עזר
את ביום שני כfollows--

586
00:25:46,090 --> 00:25:49,120
מחרוזת הוכרזה ב
ספריית CS50s לכמה זמן.

587
00:25:49,120 --> 00:25:52,650
וזה נחמד, כי זה מאפשר לי
שלנו לדבר על משתנים כ

588
00:25:52,650 --> 00:25:54,660
מילות ומשפטים שלמים ועוד.

589
00:25:54,660 --> 00:25:56,710
אבל מתברר מחרוזת לא קיימת.

590
00:25:56,710 --> 00:26:00,200
זה פשוט מילה נרדפת, או כינוי,
שיצרנו משהו ש

591
00:26:00,200 --> 00:26:03,780
למעשה הוא קצת יותר
טכני נקרא char *.

592
00:26:03,780 --> 00:26:07,900
>> ואכן, ראינו דוגמא
של תכנית ביום שני

593
00:26:07,900 --> 00:26:11,200
שלא התנהג ממש כמו שציפינו.

594
00:26:11,200 --> 00:26:13,630
זה היה הקובץ, להשוות-0.

595
00:26:13,630 --> 00:26:17,910
ולזכור כי להשוות-0, אם
אני הידור מחדש התכנית של יום שני

596
00:26:17,910 --> 00:26:22,670
ולהפעיל להשוות-0 והקלד באמא ב
אותיות קטנות, ואמא באותיות קטנה שוב.

597
00:26:22,670 --> 00:26:25,320
התכנית התעקשה ש
הקלד דברים שונים,

598
00:26:25,320 --> 00:26:29,210
למרות שאמא, את כל ב
אותיות קטנות, זהה מבחינה ויזואלית.

599
00:26:29,210 --> 00:26:31,990
אז מה הייתה התשובה הקצרה
למה המחשב חושב

600
00:26:31,990 --> 00:26:34,500
שני המיתרים הללו הם שונים?

601
00:26:34,500 --> 00:26:35,250
כן?

602
00:26:35,250 --> 00:26:36,534
>> קהל: [לא ברור]

603
00:26:36,534 --> 00:26:37,450
דוד י מלאן: ימין.

604
00:26:37,450 --> 00:26:39,600
אז, אמא, בפעם הראשונה
אני מקליד את זה ב, הוא להיות

605
00:26:39,600 --> 00:26:42,710
מאוחסן במקום כלשהו במחשב שלי
זיכרון אך במיקום שונה

606
00:26:42,710 --> 00:26:44,690
מהפעם השנייה שאני מקליד באמא.

607
00:26:44,690 --> 00:26:46,580
עכשיו זה בהחלט יכול להיות מותאם.

608
00:26:46,580 --> 00:26:49,205
המחשב יכול להיות חכם ו
מבין שתי מחרוזות אלה, היי,

609
00:26:49,205 --> 00:26:49,954
הם זהים.

610
00:26:49,954 --> 00:26:51,520
תן לי לא מיותר לאחסן אותו.

611
00:26:51,520 --> 00:26:54,229
אבל מחשבים לא עושים את זה
אופטימיזציה אלא אם כן אתה אומר להם.

612
00:26:54,229 --> 00:26:56,061
אז, כברירת מחדל, הם
רק הולך בסופו של

613
00:26:56,061 --> 00:26:57,670
בשני מקומות שונים בזיכרון.

614
00:26:57,670 --> 00:27:01,570
וכך להיות יותר ברור, כאשר
השווינו שתי מחרוזות,

615
00:27:01,570 --> 00:27:03,950
ים הראשון נקרא,
השני נקרא

616
00:27:03,950 --> 00:27:08,530
לא, מה שדווקא היה לי
השוואה כאן על קו 13?

617
00:27:08,530 --> 00:27:09,494
כן.

618
00:27:09,494 --> 00:27:12,390
>> קהל: זה המקום בזיכרון
שהמשתנה יצביע.

619
00:27:12,390 --> 00:27:14,900
>> דוד י מלאן: בדיוק, אני היה
השוואת המקום בזיכרון

620
00:27:14,900 --> 00:27:16,300
שהמשתנים אלה הצביעו על.

621
00:27:16,300 --> 00:27:20,560
אז במיוחד, אם אמא הייתה ב
מספר הבתים 1 ו -2, ו -3,

622
00:27:20,560 --> 00:27:24,020
ו4-- כי זוכרים את הקו הנטוי
0 צריך להיות כל הדרך בסוף.

623
00:27:24,020 --> 00:27:29,420
והדוגמא אחרת של אמא, M-o-מ ',
היה בכתובת 10, 11, 12, ו -13.

624
00:27:29,420 --> 00:27:33,100
אני משווה 1, כתובת ש,
מיקום שבזיכרון,

625
00:27:33,100 --> 00:27:35,160
נגד 10, שהוא
ברור שלא אותו הדבר.

626
00:27:35,160 --> 00:27:36,260
1 הוא לא 10.

627
00:27:36,260 --> 00:27:39,620
>> אז זה נחמד שב
זה די פשוט.

628
00:27:39,620 --> 00:27:42,870
אבל זה בעייתי ככל ש
אנו לא מצליחים להשוות מחרוזות.

629
00:27:42,870 --> 00:27:44,930
אז fundamentally--
וברמה נמוכה זו,

630
00:27:44,930 --> 00:27:47,300
אם אתה רוצה ליישם
תכנית כדי להשוות

631
00:27:47,300 --> 00:27:50,270
שתי מילות נפרדות ש
משתמש שהוקלד לאיכות,

632
00:27:50,270 --> 00:27:53,944
האם הם בשורה char ל
char, רק באופן כללי,

633
00:27:53,944 --> 00:27:55,360
מה שאנחנו צריכים לעשות, כנראה?

634
00:27:55,360 --> 00:27:57,940
זה לא מספיק רק ל
תסתכל על שתי כתובות אלה.

635
00:27:57,940 --> 00:27:58,860
מה אנחנו צריכים לעשות?

636
00:27:58,860 --> 00:27:59,360
כן?

637
00:27:59,360 --> 00:28:01,120
>> קהל: לחזר דרך
המחרוזת [לא ברור].

638
00:28:01,120 --> 00:28:02,600
>> דוד י מלאן: כן, בואו
איטרציות במחרוזת.

639
00:28:02,600 --> 00:28:05,808
בואו להשתמש ללולאה, לולאה בזמן, או
כל מה שאתה הכי נוח עם.

640
00:28:05,808 --> 00:28:08,840
ואם יש לנו שתי מחרוזות איפשהו
בזיכרון, בואו נסתכל על כל

641
00:28:08,840 --> 00:28:11,770
תו ראשון, ולאחר מכן כל זה שני
אופי, אז שלישי, והרביעי,

642
00:28:11,770 --> 00:28:15,206
וחמישי, עד שפגענו
מה ערך זקיף מיוחד?

643
00:28:15,206 --> 00:28:16,080
קהל: [לא ברור]

644
00:28:16,080 --> 00:28:18,800
דוד י מלאן: כן, הקו הנטוי
אפס, ובשלב זה באו מחרוזת

645
00:28:18,800 --> 00:28:20,100
אנחנו יכולים להחליט שזה זה.

646
00:28:20,100 --> 00:28:21,970
יש לנו התאמה בכל דמות?

647
00:28:21,970 --> 00:28:22,990
אם לא, תחזיר שקר.

648
00:28:22,990 --> 00:28:24,770
אם כן, תחזרו אמיתי.

649
00:28:24,770 --> 00:28:28,800
וכך זה בדיוק מה שגרסה זו
התכנית להשוות-1.c עושה.

650
00:28:28,800 --> 00:28:31,677
זה זהה למה שאנו
הסתכל בתאריך Monday פרט לכך שיש לי

651
00:28:31,677 --> 00:28:34,760
למרות שנפטר ממילת string--
שאין לי impact-- פונקציונלי כל

652
00:28:34,760 --> 00:28:37,450
אני עושה עכשיו הסרת
כמה גלגלים עזר חזותיים,

653
00:28:37,450 --> 00:28:40,880
אבל לראות בבירור ש
ים ולא הם כתובות.

654
00:28:40,880 --> 00:28:43,020
וזה מה שהכוכב,
הכוכבית, מייצגת

655
00:28:43,020 --> 00:28:46,690
היא כתובת, הידוע
יותר מבחינה טכנית כמצביע.

656
00:28:46,690 --> 00:28:49,880
>> לכן, כאשר אני מצהיר ים ב
קו 9 ואומרים char * s,

657
00:28:49,880 --> 00:28:52,160
זה לא אומר שנותן לי מחרוזת.

658
00:28:52,160 --> 00:28:56,360
כלומר, לתת לי משתנה ש
מטרה בחיים היא לאחסן את כתובת.

659
00:28:56,360 --> 00:29:00,400
מכיוון שאני עומד לשים את
כתובת של מחרוזת לתוכו.

660
00:29:00,400 --> 00:29:03,500
ואכן, GetString, להיות
ברור, לא מחזיר מחרוזת.

661
00:29:03,500 --> 00:29:06,110
זה לא יחזור אמא
קו נטוי אפס, כשלעצמה.

662
00:29:06,110 --> 00:29:10,005
מה GetString במיוחד
ולחזור בדיוק?

663
00:29:10,005 --> 00:29:10,880
קהל: [לא ברור]

664
00:29:10,880 --> 00:29:14,080
דוד י מלאן: כתובת,
כתובת של התו הראשון

665
00:29:14,080 --> 00:29:16,070
בחלק המחרוזת זה קיבל.

666
00:29:16,070 --> 00:29:19,250
אז עכשיו אנחנו רואים
מילות מפתח מיוחדת שוב.

667
00:29:19,250 --> 00:29:20,640
ו, רמזתי לזה מוקדם יותר.

668
00:29:20,640 --> 00:29:23,620
זה הולך להיות כנס טוב
שנראה שוב ושוב עכשיו.

669
00:29:23,620 --> 00:29:27,540
אני בודק כדי לוודא ש
ים הוא לא בטל ולא הוא לא null.

670
00:29:27,540 --> 00:29:30,100
בגלל המבוסס עליי באמת
אזכור מהיר קודם לכן,

671
00:29:30,100 --> 00:29:35,510
מה שאולי אומר אם GetString חוזר לא
כתובת אבל N-U-L-L, אשר שוב,

672
00:29:35,510 --> 00:29:36,990
כמה ערך מיוחד?

673
00:29:36,990 --> 00:29:37,890
>> קהל: שגיאה.

674
00:29:37,890 --> 00:29:38,600
>> דוד י מלאן: זה טעות.

675
00:29:38,600 --> 00:29:39,550
משהו השתבש.

676
00:29:39,550 --> 00:29:41,341
ומה בדרך כלל
עלול לקרות, במיוחד

677
00:29:41,341 --> 00:29:45,162
עם מייתרים: אשר עשוי להיות
אורך לא ידוע בadvance--

678
00:29:45,162 --> 00:29:46,870
אולי המחשבים '
מתוך זיכרון, אולי

679
00:29:46,870 --> 00:29:49,280
הקלדת בכזה
מילה או משפט ארוך

680
00:29:49,280 --> 00:29:51,880
או להדביק מאמר כזה ענק
יש פשוט לא מספיק זיכרון.

681
00:29:51,880 --> 00:29:55,340
וכך GetString לא יכול לחזור
הכתובת של כל הדבר,

682
00:29:55,340 --> 00:29:56,620
אז זה פשוט מחזיר שום דבר.

683
00:29:56,620 --> 00:30:00,580
וזה אומר שגיאה קרה
על ידי החזרת ערך NULL המיוחד.

684
00:30:00,580 --> 00:30:02,890
זה כתובת אפס, אם אפשר לומר כך.

685
00:30:02,890 --> 00:30:06,157
>> עכשיו מתברר C מגיע עם
פונקציה שעושה איטרציה ש.

686
00:30:06,157 --> 00:30:09,240
אנחנו לא צריכים ליישם את זה עם
ללולאה או תוך לולאה על עצמנו.

687
00:30:09,240 --> 00:30:11,150
אנחנו יכולים להשתמש בפונקציה,
נקרא באופן תמציתי,

688
00:30:11,150 --> 00:30:15,400
מערבבים comp, או מחרוזת להשוות, ש
מטרה בחיים היא לעשות בדיוק את זה.

689
00:30:15,400 --> 00:30:19,990
אתה נותן לו שני מצביעים, שתי כתובות,
וזה ילך לכתובות אלה

690
00:30:19,990 --> 00:30:23,130
ולאחר מכן להשוות מכתב ל
מכתב למכתב לאיכות,

691
00:30:23,130 --> 00:30:26,610
עוצר רק כאשר מה נכון?

692
00:30:26,610 --> 00:30:31,540
כאשר באופן אינטואיטיבי צריך לעורר comp
מפסיק חוזרת ונשנה, רק כדי להיות ברור?

693
00:30:31,540 --> 00:30:35,400
כאשר הוא יגיע קו נטוי 0 בשני
מחרוזת, ובשלב זה יכול להחליט

694
00:30:35,400 --> 00:30:38,910
יש כל מה שתאם, או
לא הייתה שם אי התאמה?

695
00:30:38,910 --> 00:30:42,740
>> לכן, אם אנחנו רצים עכשיו זה ולנסות
משחק היוון הקטן שלנו,

696
00:30:42,740 --> 00:30:49,260
כך להפוך להשוות-1, ./compare-1, ו
הקלד אמא באותיות קטנה בשתי פעמים.

697
00:30:49,260 --> 00:30:50,560
עכשיו זה אותו הדבר.

698
00:30:50,560 --> 00:30:54,080
ואם אני עושה את זה שוב עם
אותיות קטנות ואותיות גדולות אז אולי.

699
00:30:54,080 --> 00:30:56,720
עכשיו זה אכן מבדיל
בין גדול והקטן.

700
00:30:56,720 --> 00:31:00,440
אז לא כל כך קשה או
קסום, אבל זה עכשיו להסביר

701
00:31:00,440 --> 00:31:03,140
מה קורה מתחת למכסת המנוע.

702
00:31:03,140 --> 00:31:07,640
>> אז מה יותר אנחנו יכולים לחלץ
משל שיעור מסוג זה?

703
00:31:07,640 --> 00:31:08,980
אז בואו נסתכל על זה.

704
00:31:08,980 --> 00:31:15,380
אני הולך קדימה ולכתוב
תכנית מהירה כאן בשם עותק-0.

705
00:31:15,380 --> 00:31:21,594
ועכשיו בואו נלך קדימה ולמעשה
בואו נעשה את זה-- עם עותק-0,

706
00:31:21,594 --> 00:31:23,010
תסתכל על מה שיש לי כאן.

707
00:31:23,010 --> 00:31:24,712
אני אומר לי המשתמש ראשון, לומר משהו.

708
00:31:24,712 --> 00:31:26,420
ואז אני מקבל מחרוזת
ואני מאוחסן אותו בים.

709
00:31:26,420 --> 00:31:29,810
אז אני בודק אם ים שווה
שווה NULL, רק לחזור 1.

710
00:31:29,810 --> 00:31:31,590
אז זה רק בדיקת שגיאות סטנדרטית.

711
00:31:31,590 --> 00:31:33,112
שום דבר מעניין לא קרה.

712
00:31:33,112 --> 00:31:36,320
ולמעשה, אם אנחנו להיפטר השגיאה
בדיקה, זה נראה כמו קוד השבוע 1

713
00:31:36,320 --> 00:31:36,985
ברגע זה.

714
00:31:36,985 --> 00:31:39,110
אבל אני כבר התחלתי לקבל
קצת יותר טוב על זה.

715
00:31:39,110 --> 00:31:43,340
>> עכשיו בקו 16, לפני כשבוע, אולי
אפילו לפני כמה ימים או דקות,

716
00:31:43,340 --> 00:31:46,720
אפשר לומר קו 16 הוא
יצירת לא משתנה בשם

717
00:31:46,720 --> 00:31:48,219
והעתקה זה לזה.

718
00:31:48,219 --> 00:31:50,010
וזה בצורה מושלמת
ממסעדה סבירה.

719
00:31:50,010 --> 00:31:51,560
אבל להיות מדויק יותר עכשיו.

720
00:31:51,560 --> 00:31:54,190
מה שקורה בקו 16?

721
00:31:54,190 --> 00:31:56,170
מה הוא מקבל העתיק
מימין לשמאל?

722
00:31:56,170 --> 00:31:56,669
כן?

723
00:31:56,669 --> 00:31:58,490
קהל: האם לא מקבל כתובת של ים?

724
00:31:58,490 --> 00:32:01,220
>> דוד י מלאן: בדיוק, לא
הוא מקבל את הכתובת של ים.

725
00:32:01,220 --> 00:32:05,170
אז כדי להיות ברור עכשיו, אם אני הולך
בחזרה שלדוגמה הקודמת

726
00:32:05,170 --> 00:32:08,520
ואני מצייר את הדבר שהקלדתי ב.

727
00:32:08,520 --> 00:32:11,640
ומה שהקלדתי
in-- הנה ים, וכאן

728
00:32:11,640 --> 00:32:15,830
הוא מה שהקלדתי במקום כלשהו ב
זיכרון, אמא ואז קו נטוי

729
00:32:15,830 --> 00:32:17,840
0 זה הוסיף לי.

730
00:32:17,840 --> 00:32:23,060
מה אני מאוחסן בכאן, זוכר,
זה במיקום 1, 2, 3, 4,

731
00:32:23,060 --> 00:32:24,655
זה מה שכרגע בים.

732
00:32:24,655 --> 00:32:29,220
אז אם בקו 16, אני אומר תן לי
לא משתנה בשם אחר וחנות

733
00:32:29,220 --> 00:32:33,590
בשווי של ים, מה ש
מקבל מאוחסן כאן לא יהיה אמא

734
00:32:33,590 --> 00:32:35,480
אלא רק את המספר 1.

735
00:32:35,480 --> 00:32:38,520
>> אז אם אנחנו מסתכלים קדימה בתכנית זו
עכשיו, מה יקרה?

736
00:32:38,520 --> 00:32:40,690
אז שם לב שיש
פונקציה זו אולי אתה

737
00:32:40,690 --> 00:32:44,410
השתמשתי זה לפני כמה זמן לקיסר,
או Vigenere, או אולי בכלל לא.

738
00:32:44,410 --> 00:32:48,170
אני טוען עם printf שלי, אני
הולך לנצל את העותק לא.

739
00:32:48,170 --> 00:32:51,616
הראשונה בקו 19, שפיות מהירה
לבדוק, בדיקות strlen האורך של t.

740
00:32:51,616 --> 00:32:53,740
כי אני לא רוצה
אנסה לנצל משהו

741
00:32:53,740 --> 00:32:55,104
אם אין מחרוזת שם.

742
00:32:55,104 --> 00:32:57,520
אם המשתמש פשוט לחץ על Enter,
אין מה לנצל.

743
00:32:57,520 --> 00:33:01,100
אז אני לא רוצה לעשות את הקו 21.

744
00:33:01,100 --> 00:33:05,758
אז קו 21 הוא ניצול
שמכתב, ככל הנראה, בt?

745
00:33:05,758 --> 00:33:06,514
>> קהל: מ '?

746
00:33:06,514 --> 00:33:08,722
דוד י מלאן: זה נראה
כמו זה שהעתקה אחד?

747
00:33:08,722 --> 00:33:09,486
קהל: מ '.

748
00:33:09,486 --> 00:33:10,450
דוד י מלאן: אה, מ '.

749
00:33:10,450 --> 00:33:12,685
אוקיי, אז מ 'הראשון,
בגלל הודעה שאני

750
00:33:12,685 --> 00:33:14,935
עובר לtoupper, ש
אם אתה אף פעם לא ראית אותו זה

751
00:33:14,935 --> 00:33:16,980
רק פונקציה ל
לנצל כקלט שלה.

752
00:33:16,980 --> 00:33:20,240
הסוגר T אפס הפירוש לתת
שלי האופי של אפס לא.

753
00:33:20,240 --> 00:33:22,550
ואז איך עושה את זה
שינוי תמונה, שיהיה ברור?

754
00:33:22,550 --> 00:33:25,490

755
00:33:25,490 --> 00:33:29,160
מה צריך לעשות כדי לקבל מחדש או כתוב השתנו
ביחס לים ולא ואמא

756
00:33:29,160 --> 00:33:30,097
אפס קו נטוי.

757
00:33:30,097 --> 00:33:31,470
>> קהל: [לא ברור]

758
00:33:31,470 --> 00:33:34,030
>> דוד י מלאן: כן,
אז זה אחד כאן פשוט

759
00:33:34,030 --> 00:33:40,860
צריך לקבל השתנה צריכה-- לתקן זה--
צריך לקבל שונה למ 'הון.

760
00:33:40,860 --> 00:33:44,330
אבל עכשיו, נראה בהמשך
תכנית, אם אני להדפיס

761
00:33:44,330 --> 00:33:49,800
T S וכמו שאני מנקה כאן, לצפות מה
הולך לקרות להדפיס את ים ולא.

762
00:33:49,800 --> 00:33:54,310
אז להפוך את העותק-0, ./copy-0.

763
00:33:54,310 --> 00:33:57,140
תן לי ללכת קדימה והקלידו
באמא בכל האותיות הקטנות.

764
00:33:57,140 --> 00:34:00,140
שים לב שני ומקורי
העותק מהוון.

765
00:34:00,140 --> 00:34:00,850
למה?

766
00:34:00,850 --> 00:34:04,431
ובכן, זה לא ושניהם מצביעים ל,
אם תרצה, את אותו הנתח של זיכרון.

767
00:34:04,431 --> 00:34:06,930
ולמען אמת, זה הוא מקבל
באמת uninteresting-- העובדה

768
00:34:06,930 --> 00:34:09,150
שבו אנו משתמשים אפס כתובת כאן.

769
00:34:09,150 --> 00:34:11,719
אני מתכוון, לא ממש אכפת לי
שבו דברים הוא בזיכרון.

770
00:34:11,719 --> 00:34:13,550
מצטער שאני מוחק קצת יותר מדי.

771
00:34:13,550 --> 00:34:15,674
אבל לא ממש אכפת לי
שבו דברים נמצאים בזיכרון.

772
00:34:15,674 --> 00:34:18,510
וכך, אכן מה ש
מתכנתים נוטים לחשוב על

773
00:34:18,510 --> 00:34:21,080
הוא שכאשר אתה מדבר על
כתובת, או מצביע,

774
00:34:21,080 --> 00:34:22,679
למי אכפת שבו הוא נמצא בזיכרון.

775
00:34:22,679 --> 00:34:24,989
לא אכפת לי אם זה ב
בית אחד או מליארד.

776
00:34:24,989 --> 00:34:27,920
אני פשוט אכפת שזה
משתנה הוא ביעילות

777
00:34:27,920 --> 00:34:29,620
מצביע על נתח זה של זיכרון.

778
00:34:29,620 --> 00:34:33,350
וכך, מעתה ואילך, ולא להתפלפל
על כתובות זיכרון שרירותיות, בואו

779
00:34:33,350 --> 00:34:36,710
פשוט להתחיל לצייר מצביעים
כמצביעים, כחצים.

780
00:34:36,710 --> 00:34:39,340
אז מה זה ולא באמת,
על פי תכנית זו,

781
00:34:39,340 --> 00:34:42,130
בגלל איך אני יצרתי לא,
זה רק שני משתנים נפרדים

782
00:34:42,130 --> 00:34:43,840
מצביע באותו הנתח של זיכרון.

783
00:34:43,840 --> 00:34:45,215
ולא אכפת לנו היכן הם נמצאים.

784
00:34:45,215 --> 00:34:47,130
כדי שנוכל מופשט משם את הפרט הזה.

785
00:34:47,130 --> 00:34:48,780
>> אז איך אני יכול לתקן את זה?

786
00:34:48,780 --> 00:34:54,120
אם אני רוצה לכתוב גרסה של העותק
תכנית שבעצם מעתיקה את המחרוזת

787
00:34:54,120 --> 00:34:56,840
ומנצל רק
עותק, רק באופן אינטואיטיבי,

788
00:34:56,840 --> 00:34:59,766
מה צריך להיות
מרכיב לפתרון שלנו?

789
00:34:59,766 --> 00:35:00,640
קהל: [לא ברור]

790
00:35:00,640 --> 00:35:01,420
דוד י מלאן: אנחנו צריכים מה?

791
00:35:01,420 --> 00:35:01,820
קהל: נתח של זיכרון.

792
00:35:01,820 --> 00:35:03,280
דוד י מלאן: אנחנו צריכים
עוד נתח של זיכרון, נכון?

793
00:35:03,280 --> 00:35:05,360
אנחנו לא יודעים איך
לעשות את זה עדיין, בהכרח.

794
00:35:05,360 --> 00:35:11,330
אבל אני צריך סוג של שזה יקרה כל כך
שאמא המקורית באותיות קטנות

795
00:35:11,330 --> 00:35:14,170
בסופו של שנתח נוסף של זיכרון.

796
00:35:14,170 --> 00:35:19,770
ואז כשאני משנה את העותק, אני
לא רוצה לשנות את העותק הזה כאן.

797
00:35:19,770 --> 00:35:26,020
אני במקום רוצה לשנות רק את זה
עותק כך שמקורי יישאר ללא שינוי.

798
00:35:26,020 --> 00:35:27,980
>> אז, בואו לראות איך אנחנו יכולים לעשות את זה.

799
00:35:27,980 --> 00:35:31,800
בעותק-1, שבו יש כבר
הופשט מתגובה,

800
00:35:31,800 --> 00:35:33,250
אבל הוא הגיב באינטרנט.

801
00:35:33,250 --> 00:35:36,710
אנחנו במקום לעשות following-- אלה
קווים זהים, תקבל אותי מחרוזת

802
00:35:36,710 --> 00:35:38,340
וקורא לזה זה.

803
00:35:38,340 --> 00:35:43,500
אבל עכשיו בואו נסתכל על אחד של רובנו
מורכב אך האחרון של המורכבות

804
00:35:43,500 --> 00:35:47,340
לזמן מה, קו 16 עושה בדיוק את זה.

805
00:35:47,340 --> 00:35:49,400
אז אם נוח עם
תמונה אנחנו רק drew--

806
00:35:49,400 --> 00:35:51,790
תן לי נתח חדש של זיכרון,
להעתיק את הכל לתוך זה,

807
00:35:51,790 --> 00:35:53,730
בואו לראות איך אנחנו מתרגמים את זה לקוד.

808
00:35:53,730 --> 00:35:59,400
>> אז קו 16, בצד שמאל,
char * t נותן לי תיבה זו כאן.

809
00:35:59,400 --> 00:36:00,230
זה כל מה שהיא עושה.

810
00:36:00,230 --> 00:36:03,240
בצד ימין,
alloc מ ', או malloc,

811
00:36:03,240 --> 00:36:06,480
היא הקצאת זיכרון, סופר מפואר,
דרך מסתורית של רק אומר

812
00:36:06,480 --> 00:36:07,640
תן לי נתח של זיכרון.

813
00:36:07,640 --> 00:36:09,290
כמה זיכרון אנחנו צריכים?

814
00:36:09,290 --> 00:36:10,910
ובכן, הוא סוג של ביטוי גדול.

815
00:36:10,910 --> 00:36:12,570
אבל בואו יראו את מה שכתוב כאן.

816
00:36:12,570 --> 00:36:15,940
אז זה, כמובן, הוא לתת לי
שלי אורך המחרוזת של ים.

817
00:36:15,940 --> 00:36:19,094
אז, אמא שלו צריכה להיות מה?

818
00:36:19,094 --> 00:36:21,010
אז רק שלוש, נכון?
אמא היא שלוש דמויות.

819
00:36:21,010 --> 00:36:22,830
אתה לא סופר
קו נטוי אפס כאשר אתה

820
00:36:22,830 --> 00:36:25,960
מדבר על האורך של מחרוזת זה
למעשה מכתבים גלויים האנושיים.

821
00:36:25,960 --> 00:36:28,020
אז אמא, אז זה נותן לי 3.

822
00:36:28,020 --> 00:36:31,170
אבל חכה רגע, אני עכשיו מוסיף 1.

823
00:36:31,170 --> 00:36:34,861
למה אני באמת רוצה
להקצות 4 בתים ולא רק 3?

824
00:36:34,861 --> 00:36:35,360
כן?

825
00:36:35,360 --> 00:36:36,910
>> קהל: לערך הזקיף?

826
00:36:36,910 --> 00:36:38,951
>> דוד י מלאן: בדיוק,
לכי ערך זקיף.

827
00:36:38,951 --> 00:36:40,840
ללוכסן אפס,
אני צריך כולל 4 בתים.

828
00:36:40,840 --> 00:36:42,870
אז אני צריך את האורך
של המחרוזת בתוספת 1.

829
00:36:42,870 --> 00:36:45,400
ואז פשוט לmeasure-- טוב
למרות שעל מערכת זו,

830
00:36:45,400 --> 00:36:49,390
זה תמיד הולך להיות 1-- אני אומר
להכפיל את זה על ידי הגודל של char.

831
00:36:49,390 --> 00:36:51,552
מתברר sizeof הוא
מפעיל בC ש

832
00:36:51,552 --> 00:36:53,260
רק אומר לך
מספר הבתים זה

833
00:36:53,260 --> 00:36:54,700
הנדרש לסוג נתונים מסוים.

834
00:36:54,700 --> 00:36:57,740
זה לא עובד עבור מערכים,
בדרך כלל, לפעמים היא עושה.

835
00:36:57,740 --> 00:36:59,210
אבל במקרה הכללי, לא.

836
00:36:59,210 --> 00:37:02,330
אבל זה אומר לי כמה ביטים
char הוא, שמתברר הוא תמיד 1.

837
00:37:02,330 --> 00:37:04,080
אז זה כמו הכפלה ב 1.

838
00:37:04,080 --> 00:37:05,900
>> קו מחפש אז סופר מסתורי של קוד.

839
00:37:05,900 --> 00:37:09,320
אבל כל שהיא עושה הוא נותנת
שלי נתח של זיכרון.

840
00:37:09,320 --> 00:37:13,590
אבל האם זה נראה העתקה
שום דבר לזיכרון ש?

841
00:37:13,590 --> 00:37:14,560
עדיין לא.

842
00:37:14,560 --> 00:37:22,040
ואז מה לעשות אני על קו 22, ו
23, 24, 25, טוב, אני פשוט עושה את זה.

843
00:37:22,040 --> 00:37:23,760
וזה סוג של
דברים בית ספר ישנים עכשיו.

844
00:37:23,760 --> 00:37:26,010
זה כמו PSet 2, שבו
אתה רק להזיז דברים

845
00:37:26,010 --> 00:37:28,620
סביב בזיכרון, או לייתר דיוק במחרוזות.

846
00:37:28,620 --> 00:37:31,920
>> אז אני iterating בין 0 ל
אורכו של מחרוזת s.

847
00:37:31,920 --> 00:37:37,820
ואני מעתיק את אופי i-ה
בים לאופי i-ה בt.

848
00:37:37,820 --> 00:37:41,820
ומכיוון שאני, מתכנת, עשה
הקפד להקצות בתים בדיוק כמו רבים

849
00:37:41,820 --> 00:37:44,600
כמו שאני צריך, זה מושלם
אחד-על-אחד יחסים.

850
00:37:44,600 --> 00:37:47,060
ואני מעתיק את אמא ב
אותיות קטנות לאחד החדש.

851
00:37:47,060 --> 00:37:50,170
ואז לבסוף, אני עושה את הקו הזה.

852
00:37:50,170 --> 00:37:54,637
ולכן ההשפעה היא רק
לנצל t זה כאן.

853
00:37:54,637 --> 00:37:56,470
כל כך הרבה לקלוט, אבל
אם אתה רק רואה

854
00:37:56,470 --> 00:37:58,220
מה באמת קורה
במתחת למכסת המנוע

855
00:37:58,220 --> 00:38:00,880
הוא פשוט זז אלה
ביטים מסביב, כל מה ש

856
00:38:00,880 --> 00:38:06,617
יש צורך לפתור את הבעיה הזו היא
רק כדי לתת לנו נתח זה של זיכרון.

857
00:38:06,617 --> 00:38:08,450
עכשיו בסיכון
מכריע, תן לי להראות

858
00:38:08,450 --> 00:38:13,200
דוגמא אחרת שכמעט
זהה, למעט זה אחד

859
00:38:13,200 --> 00:38:14,350
שורת קוד.

860
00:38:14,350 --> 00:38:18,870
אז זה גרסת ההאקר
של תכנית זו, אם תרצה.

861
00:38:18,870 --> 00:38:21,050
אבל בואו רק לזקק
אותו למה שקורה.

862
00:38:21,050 --> 00:38:28,920
קו 24 היה אמור להיות לא זה
הסוגר אני מקבל של הסוגר אני.

863
00:38:28,920 --> 00:38:33,370
עכשיו, אני משנה את זה ל
לא כוכב הרבה יותר מסתורי

864
00:38:33,370 --> 00:38:36,280
בתוספת שווה כוכב של תוספת 1 1.

865
00:38:36,280 --> 00:38:38,702
>> אז מה קורה ולמה
יש לנו אופי כוכב?

866
00:38:38,702 --> 00:38:41,410
ראינו את כוכב העבר, ו
הוא נמצא בשימוש בצורה שונה כאן.

867
00:38:41,410 --> 00:38:45,490
ראינו בעבר * char, עכשיו אני רואה
כוכב בתחילת, וזה בסדר.

868
00:38:45,490 --> 00:38:48,190
כי מתברר ש
סוג יכול להסיק מרק

869
00:38:48,190 --> 00:38:50,280
מאלו הראשונים
עקרונות מה קורה.

870
00:38:50,280 --> 00:38:53,860
אז רק שיהיה ברור, מה הוא? של

871
00:38:53,860 --> 00:38:55,052
בשבוע שעבר, זה היה מחרוזת.

872
00:38:55,052 --> 00:38:56,260
זה לא יספיק יותר.

873
00:38:56,260 --> 00:38:57,690
מה הוא S, במיוחד?

874
00:38:57,690 --> 00:38:58,590
>> קהל: [לא ברור]

875
00:38:58,590 --> 00:38:59,881
>> דוד י מלאן: זה מצביע.

876
00:38:59,881 --> 00:39:02,610
זה הכתובת של
הדמות הראשונה שהקלדנו ב.

877
00:39:02,610 --> 00:39:04,780
אישור, מה הוא לא?

878
00:39:04,780 --> 00:39:05,660
>> קהל: [לא ברור]

879
00:39:05,660 --> 00:39:07,950
>> דוד י מלאן:
כתובת של הבית הראשון

880
00:39:07,950 --> 00:39:10,490
בt, נתח זה של זיכרון מוקם מחדש.

881
00:39:10,490 --> 00:39:14,720
אז מתברר שכאשר אנו
לחזר בין 0 ועד למחרוזת

882
00:39:14,720 --> 00:39:17,424
length-- קודם כל, אני
מתחיל ב 0, משום ש

883
00:39:17,424 --> 00:39:18,840
של בית ספר ישן זה דבר לולאה.

884
00:39:18,840 --> 00:39:22,400
אז רק לפשטות, בואו
תניח שהשורה הראשונה של קוד

885
00:39:22,400 --> 00:39:23,760
הוא באמת רק זה, נכון.

886
00:39:23,760 --> 00:39:26,080
אם הוא אפס, אפס הוספה
למשהו יש להניח

887
00:39:26,080 --> 00:39:27,540
הוא לא הולך להיות להם השפעה.

888
00:39:27,540 --> 00:39:28,560
>> אז מה זה אומר?

889
00:39:28,560 --> 00:39:31,600
מתברר שהכוכב
מפעיל בהקשר זה

890
00:39:31,600 --> 00:39:33,700
הוא dereference
מפעיל, שהוא רק

891
00:39:33,700 --> 00:39:37,530
דרך מפוארת של אומר ללכת
לכתובת הבאה.

892
00:39:37,530 --> 00:39:42,080
אז אם זה הוא הכתובת של הראשון
דמות בנתח זה של זיכרון,

893
00:39:42,080 --> 00:39:43,630
* s אמצעים ללכת לשם.

894
00:39:43,630 --> 00:39:45,630
ומפני שנמשכים
התמונה בדרך זו,

895
00:39:45,630 --> 00:39:47,430
אתה יכול לאמץ
הבא מודל המנטלי.

896
00:39:47,430 --> 00:39:51,030
אם זה של, ואתה אומר של *, * S
כמו סוג של מצנחים וסולמות,

897
00:39:51,030 --> 00:39:54,540
אם אתה זוכר את המשחק מהילדות,
זה כמו לעקוב אחרי החץ וללכת

898
00:39:54,540 --> 00:39:55,570
לכתובת.

899
00:39:55,570 --> 00:39:57,080
>> * לא הוא אותו הדבר.

900
00:39:57,080 --> 00:39:59,855
אז להתחיל כאן, ללכת לנתח שלה.

901
00:39:59,855 --> 00:40:03,350
אני לא יכול פשוט לצייר על
מסך זה ככה.

902
00:40:03,350 --> 00:40:05,560
* לא אומר ללכת כאן.

903
00:40:05,560 --> 00:40:08,830
ולאחר מכן, ללולאה הוא פשוט
אומר להזיז את הדמות של זה כאן,

904
00:40:08,830 --> 00:40:11,330
להזיז את הדמות של זה כאן,
להזיז את הדמות של זה כאן.

905
00:40:11,330 --> 00:40:12,890
אבל איך אני עושה את incrementation ש?

906
00:40:12,890 --> 00:40:15,430
אני צריך לבטל את מה שאני פשוט נמחק.

907
00:40:15,430 --> 00:40:18,140
זה מה שנקרא בדרך כלל
חשבון מצביע, ש

908
00:40:18,140 --> 00:40:20,040
פירוש מתמטיקה עם כתובות.

909
00:40:20,040 --> 00:40:22,460
>> אם, בזה ללולאה,
אני כל הזמן הגדלה אני,

910
00:40:22,460 --> 00:40:26,880
והים הוא כתובת ולא הוא
כתובת, אם אני רק לשמור על הוספת 1,

911
00:40:26,880 --> 00:40:31,406
זה רק אומר להמשיך לנוע קדימה,
וקדימה, וקדימה בזיכרון.

912
00:40:31,406 --> 00:40:34,030
זה כמו רחוב אוקספורד,
רחוב שבניין מדעי המחשב הוא על.

913
00:40:34,030 --> 00:40:36,490
בנייני CS הוא ברחוב אוקספורד 33.

914
00:40:36,490 --> 00:40:39,870
אז אם היו לך לעשות 33
רחוב אוקספורד בתוספת 1,

915
00:40:39,870 --> 00:40:42,870
שמביא אותך לאוקספורד 34
רחוב, רחוב אוקספורד 35 אז,

916
00:40:42,870 --> 00:40:46,380
אז רחוב אוקספורד 36, מה אלה
בניינים הם למעשה - אם הם קיימים.

917
00:40:46,380 --> 00:40:50,540
וכך, זה כל מה שאנחנו עושים
כאן עם חשבון מצביע.

918
00:40:50,540 --> 00:40:53,820
>> אז זה דרך סופר מסתורי
לבטא את עצמנו.

919
00:40:53,820 --> 00:40:56,160
אבל כל מה שקורה
מתחת למכסת המנוע

920
00:40:56,160 --> 00:40:59,330
רק לאחר כתובות אלה,
כמו הבא מפה, אם תרצה,

921
00:40:59,330 --> 00:41:02,692
או הבא חצים כמו
אנחנו נמשכים על המסך.

922
00:41:02,692 --> 00:41:04,910
אישור, הרבה לעכל.

923
00:41:04,910 --> 00:41:10,410
כל שאלה בתחביר, מושגים,
מצביעים, malloc, או משהו דומה.

924
00:41:10,410 --> 00:41:11,480
כן, כאן ראשון.

925
00:41:11,480 --> 00:41:13,755
>> קהל: אז איפה ש
אומר * לא * שווה toupper t,

926
00:41:13,755 --> 00:41:15,575
הוא שהולך לנצל
כל האותיות או פשוט--

927
00:41:15,575 --> 00:41:17,283
>> דוד י מלאן: אה,
שאלה ממש טובה.

928
00:41:17,283 --> 00:41:19,805
אז בקו הזה כאן, 31,
זה הולך לנצל

929
00:41:19,805 --> 00:41:21,430
המכתב הראשון או כל האותיות.

930
00:41:21,430 --> 00:41:23,460
אז בואו לענות על זה על ידי הולך
בחזרה לעקרונות הראשונים.

931
00:41:23,460 --> 00:41:26,168
והעקרונות הראשונים כאן אני מתכוון
פשוט ללכת להגדרות הבסיסיות

932
00:41:26,168 --> 00:41:27,000
של מה שכרוך בכך.

933
00:41:27,000 --> 00:41:29,770
אז toupper זה פונקציה
שמנצל char.

934
00:41:29,770 --> 00:41:30,530
זה הכל.

935
00:41:30,530 --> 00:41:36,740
* לא אומר ללכת לfirst--
גש לכתובת בt.

936
00:41:36,740 --> 00:41:40,350
אז, בתמונה, אם זה הנתח
זיכרון שהוקצינו עם malloc,

937
00:41:40,350 --> 00:41:43,310
וזה לא, * לא אומר ללכת כאן.

938
00:41:43,310 --> 00:41:46,710
>> בינתיים, אתה עובר
כי הערך, מ 'אותיות קטנות

939
00:41:46,710 --> 00:41:50,040
לtoupper, אתה מקבל בחזרה
ההון M, שבו אתה מכניס אותו?

940
00:41:50,040 --> 00:41:52,410
אתה שם את זה באותו מיקום.

941
00:41:52,410 --> 00:41:55,540
וזאת על ידי היגיון זה של אלה
הגדרות בסיסיות זה רק

942
00:41:55,540 --> 00:41:58,792
ניצול המכתב הראשון
אלא אם כן אתה לחזר עם אני או

943
00:41:58,792 --> 00:42:02,000
ללולאה או לולאה בזמן, זה לא הולך
לעשות משהו יותר ממה שאתה שואל את זה.

944
00:42:02,000 --> 00:42:02,583
שאלה טובה.

945
00:42:02,583 --> 00:42:03,237
כן?

946
00:42:03,237 --> 00:42:05,369
>> קהל: מדוע אתה משתמש ב
dereference שיטה ולא

947
00:42:05,369 --> 00:42:05,979
המערך?

948
00:42:05,979 --> 00:42:07,395
>> דוד י מלאן: אה, שאלה טובה.

949
00:42:07,395 --> 00:42:10,672
למה אתה משתמש dereference
שיטה במקום שיטת המערך?

950
00:42:10,672 --> 00:42:12,130
אין סיבה מיוחדת, אם להיות כנה.

951
00:42:12,130 --> 00:42:15,290
ואכן, לזה
סוג של דוגמא, תקין,

952
00:42:15,290 --> 00:42:17,556
אני רק טוען שהופך את
תכנית מורכבת יותר,

953
00:42:17,556 --> 00:42:19,680
יותר עיניים מזוגגות,
אנשים בודקים את

954
00:42:19,680 --> 00:42:22,830
כי זה נראה סופר מסתורי, אבל
למרות שזה עושה את אותו הדבר.

955
00:42:22,830 --> 00:42:26,695
וכך, בכנות, זה
פתרון שלא לצורך חזותי מורכב

956
00:42:26,695 --> 00:42:27,320
לבעיה.

957
00:42:27,320 --> 00:42:29,580
>> זה עדיין עיצוב טוב,
חמש מתוך חמישה לעיצוב,

958
00:42:29,580 --> 00:42:33,140
בין אם זה במסגרת
סימון או סימון המצביע.

959
00:42:33,140 --> 00:42:36,299
But-- במיוחד כאשר אנו מקבלים
מאוחר יותר בקורס בPSet 5

960
00:42:36,299 --> 00:42:39,340
כאשר אנו מיישמים מילון ש
אני כבר ציינו כמה times--

961
00:42:39,340 --> 00:42:42,300
אנחנו בעצם אכפת
כתובות זיכרון ברמה נמוכה

962
00:42:42,300 --> 00:42:44,140
כי אנחנו באמת מבינים
מה הולך.

963
00:42:44,140 --> 00:42:48,300
>> אבל, לעת עתה, מתברר שזה
קו של סוגריים מרובעים כאן קוד

964
00:42:48,300 --> 00:42:49,900
לא קיימים באמת.

965
00:42:49,900 --> 00:42:52,230
הם מה שנקראו
סוכר תחבירי, ש

966
00:42:52,230 --> 00:42:58,390
הוא רק דרך מוזרה מגניב לומר
מהדר ממיר סוגריים מרובעים להיות

967
00:42:58,390 --> 00:43:00,420
שביטוי מתמטי.

968
00:43:00,420 --> 00:43:02,660
אז זה כנס אנושי
כדי להיות מסוגל רק כדי לכתוב

969
00:43:02,660 --> 00:43:04,220
סוגריים אלה מאוד ידידותי למשתמש.

970
00:43:04,220 --> 00:43:06,850
אבל מה מהדר, צלצול,
הוא באמת עושה כל זמן

971
00:43:06,850 --> 00:43:10,970
אתה כותב מה שמודגש בקו
24, מתחת למכסת המנוע זה באמת

972
00:43:10,970 --> 00:43:12,330
המיר אותו לזה.

973
00:43:12,330 --> 00:43:16,200
זה פשוט יותר מהנה כאדם
לקרוא ולכתוב קוד כמו קו 24.

974
00:43:16,200 --> 00:43:18,530
אבל סופו של דבר אלה
גלגלי עזר גם יורדים

975
00:43:18,530 --> 00:43:21,780
כאשר הנוחות של האדם עצמו מתחזקת.

976
00:43:21,780 --> 00:43:27,240
>> בסדר, אז זוכרים אז שזה
היה הסוג של הבעיה הגדולה ביותר

977
00:43:27,240 --> 00:43:27,807
נתקלנו ב.

978
00:43:27,807 --> 00:43:30,640
וזה מה שעורר את כל זה
שיחה אכפת מצביעים,

979
00:43:30,640 --> 00:43:32,340
וכתובות, ודברים העתקה.

980
00:43:32,340 --> 00:43:35,410
זה היה בגלל שאנחנו מעד
הנושא הטיפש, הטיפש הזה, לפי

981
00:43:35,410 --> 00:43:38,830
אני מיושם logically-- עם לורן
עד כאן על ההדגמה ומיץ התפוזים

982
00:43:38,830 --> 00:43:43,770
בmilk-- מושלם
פונקציה נכונה אלגוריתמי

983
00:43:43,770 --> 00:43:47,010
להעברת שני משתנים "
ערכים, אבל הדבר הארור

984
00:43:47,010 --> 00:43:50,550
לא היה לי שום מתמשך, או
קבועה, השפעה על הקוד שלי.

985
00:43:50,550 --> 00:43:51,820
>> ולמה זה היה?

986
00:43:51,820 --> 00:43:54,650
בקליפת אגוז, למה זה
יישום של החלפה

987
00:43:54,650 --> 00:43:58,740
מבחינה לוגית נכון, אבל אין לו השפעה
על המשתנים שמועברים אליו,

988
00:43:58,740 --> 00:44:01,119
כמו x ו- y לעיקרי?

989
00:44:01,119 --> 00:44:02,410
מה היה עיקר הבעיה?

990
00:44:02,410 --> 00:44:02,909
כן?

991
00:44:02,909 --> 00:44:05,532
קהל: כי משתנה עשה
עותקים של משתנה במעבר

992
00:44:05,532 --> 00:44:06,240
באמצעות פונקציה.

993
00:44:06,240 --> 00:44:09,060
>> דוד י מלאן: בדיוק, כאשר אתה עובר
משתנים לפונקציה, או טיעונים

994
00:44:09,060 --> 00:44:11,030
לפונקציה, הם
עבר על ידי העתקה, ש

995
00:44:11,030 --> 00:44:14,770
אומר שאתה מקבל זהה מחפש
דפוס של ביטים לשני x ו- y,

996
00:44:14,770 --> 00:44:15,955
נקרא כאן וב.

997
00:44:15,955 --> 00:44:18,080
ואתה יכול לעשות כל דבר
אתה רוצה עם עותקים אלה,

998
00:44:18,080 --> 00:44:20,657
אבל הם הולכים אין לי
השפעה על תפקוד הקורא.

999
00:44:20,657 --> 00:44:22,990
ואכן, אנו ציירנו ש
תמונה על המסך, כזכור

1000
00:44:22,990 --> 00:44:25,520
הפעם האחרונה, לפיה אם
באמת חושבים על מה

1001
00:44:25,520 --> 00:44:28,570
קורה מתחת hood-- אם
זה הזיכרון של המחשב שלך,

1002
00:44:28,570 --> 00:44:31,650
וכאן למטה הוא הנתח של
זיכרון בשימוש עבור עיקרי,

1003
00:44:31,650 --> 00:44:34,020
זה הנתח של
זיכרון בשימוש להחלפה,

1004
00:44:34,020 --> 00:44:37,090
ויש לו כל כך, גם אם עיקרי
שני משתנים, x ו- y,

1005
00:44:37,090 --> 00:44:41,840
החלפה שאולי יש לי מחפש זהה
ערכים, אשר שניהם 1 ו- 2,

1006
00:44:41,840 --> 00:44:44,520
אבל הם לגמרי
נתחים שונים של זיכרון.

1007
00:44:44,520 --> 00:44:46,130
>> אז אנחנו צריכים פתרון לזה.

1008
00:44:46,130 --> 00:44:51,580
ולמען אמת, זה היה נראה שאנחנו עכשיו
יש פתרון לבעיה זו, נכון.

1009
00:44:51,580 --> 00:44:55,760
אם עכשיו יש לנו את היכולת
לתפעל דברים בדרך של כתובות

1010
00:44:55,760 --> 00:44:59,310
ו, סוג של מצנחים וסולמות
סגנון, בצע את החצים אלה

1011
00:44:59,310 --> 00:45:02,820
וללכת לכל מקום שאנחנו רוצים
בזיכרון, לא יכולתי ש

1012
00:45:02,820 --> 00:45:06,220
לפתור בעיה זו על ידי
עובר מראשי להחליף

1013
00:45:06,220 --> 00:45:09,650
לא הערכים שאנחנו רוצים
החלפה, אבל רק באופן אינטואיטיבי

1014
00:45:09,650 --> 00:45:11,630
מה שאנחנו יכולים לעבור להחליף במקום?

1015
00:45:11,630 --> 00:45:12,620
>> [חציצת קולות]

1016
00:45:12,620 --> 00:45:15,244
>> דוד י מלאן: למה אנחנו לא פשוט
להעביר אותו הכתובות, נכון?

1017
00:45:15,244 --> 00:45:17,470
למה אנחנו לא נותנים החלפה
מפת אוצר, אם תרצה,

1018
00:45:17,470 --> 00:45:20,950
שמוביל אותו ל
x בפועל ערכים ו- y.

1019
00:45:20,950 --> 00:45:24,340
ההחלפה בואו, למעשה לשנות
ביטים מקוריים אלה, ולא

1020
00:45:24,340 --> 00:45:26,797
רק עובר עותקים של הביטים.

1021
00:45:26,797 --> 00:45:29,130
וכך, למעשה, זה מה ש
הולך להיות הפתרון.

1022
00:45:29,130 --> 00:45:31,899
גרסה זו היא כאן
ברור רע ופגום.

1023
00:45:31,899 --> 00:45:35,190
ועכשיו, במבט ראשון, זה פשוט נראה
כמו שהוספנו חבורה של כוכבים באופן אקראי

1024
00:45:35,190 --> 00:45:37,106
וחצה את האצבעות שלנו
שזה יהיה לקמפל.

1025
00:45:37,106 --> 00:45:38,460
אבל, זה היה עכשיו לקמפל.

1026
00:45:38,460 --> 00:45:40,090
>> אבל בואו נראה מה הדברים האלה אומר.

1027
00:45:40,090 --> 00:45:43,990
ולמרבה הצער, מחברי
C יכל לבחור סמל אחר

1028
00:45:43,990 --> 00:45:46,380
כדי להפוך את זה קצת
, אבל מפעיל הכוכב ברור יותר

1029
00:45:46,380 --> 00:45:48,610
יש משמעות שונה ב
שני הקשרים שונים.

1030
00:45:48,610 --> 00:45:50,890
ושראינו את שניהם,
אבל בואו להבחין.

1031
00:45:50,890 --> 00:45:55,310
>> אז למעלה בחלק העליון יש,
כשהשתניתי וב

1032
00:45:55,310 --> 00:46:00,470
מלהיות int של ברע
גרסה לint כוכבים, A ו- B,

1033
00:46:00,470 --> 00:46:01,740
בעבר, היו שלמים.

1034
00:46:01,740 --> 00:46:05,752
מה הם A ו- B עכשיו ב
הגרסה טובה, ירוקה?

1035
00:46:05,752 --> 00:46:06,900
הם כתובות.

1036
00:46:06,900 --> 00:46:09,610
כתובות של מה, שתהיינה ברורות?

1037
00:46:09,610 --> 00:46:10,770
כתובות של מספרים שלמים.

1038
00:46:10,770 --> 00:46:12,520
אז העובדה שאני
אומר אמצעי כוכב int

1039
00:46:12,520 --> 00:46:15,440
זו הכתובת של
שלם, באופן ספציפי.

1040
00:46:15,440 --> 00:46:19,120
>> אז עכשיו שמו לב בשורות קוד,
משהו אחר השתנה מדי.

1041
00:46:19,120 --> 00:46:22,770
tmp נשאר זהה, משום ש
זה רק המספר השלם הזמני,

1042
00:46:22,770 --> 00:46:24,110
אין קסם זיכרון יש.

1043
00:46:24,110 --> 00:46:26,370
אבל עכשיו צריך כוכב.

1044
00:46:26,370 --> 00:46:28,560
ואכן, בכל
אזכור נוסף של A ו- B,

1045
00:46:28,560 --> 00:46:31,780
שם לב שכל זה
שינוי מאדום לירוק

1046
00:46:31,780 --> 00:46:34,209
הוא שאני קידומת
אלה משתנים עם כוכבים.

1047
00:46:34,209 --> 00:46:35,750
כי אני לא רוצה להעתיק וב.

1048
00:46:35,750 --> 00:46:40,350
כי אם אני פשוט להעתיק וב והחלפה
A ו- B, מה אני למעשה להחליף?

1049
00:46:40,350 --> 00:46:43,760
רק כתובות, אני רוצה להחליף
מה בכתובות אלה.

1050
00:46:43,760 --> 00:46:44,860
אני רוצה ללכת לשם.

1051
00:46:44,860 --> 00:46:48,000
וכך מפעיל הכוכב
בתוך הפונקציה שלי,

1052
00:46:48,000 --> 00:46:51,700
לא בתוך רשימת הפרמטרים,
משמעו שאתה הולך לכתובות אלה

1053
00:46:51,700 --> 00:46:54,490
ולמעשה לשנות ערכים אלה.

1054
00:46:54,490 --> 00:46:56,500
>> אז מה עושה את התמונה
עכשיו נראה כמו במקום.

1055
00:46:56,500 --> 00:47:03,250
ובכן, אם במקום שאני עובר
לA ו- B לא ו2-- 1

1056
00:47:03,250 --> 00:47:05,790
אני באמת צריך להוסיף
הגדרה אחרת כאן.

1057
00:47:05,790 --> 00:47:09,030
אז נניח שנתח זה
זיכרון הוא במיקום 10.

1058
00:47:09,030 --> 00:47:12,960
>> זה במיקום 11, אבל זה
זה קצת פישוט,

1059
00:47:12,960 --> 00:47:18,900
עכשיו יש לי שתי אפשרויות לעשות אני עובר x
ו- y או שאני עובר את הכתובות שלהם?

1060
00:47:18,900 --> 00:47:22,500
אם אני עובר את הכתובות שלהם
כמו זה, אני רק

1061
00:47:22,500 --> 00:47:25,390
עכשיו צריך ליישם
החלפה לקוד הירוק

1062
00:47:25,390 --> 00:47:29,080
כך שכאשר הוא רואה וכש
רואה ב, זה לא פשוט להעתיק וב

1063
00:47:29,080 --> 00:47:30,540
ולהעביר את חלב ומיץ תפוזים.

1064
00:47:30,540 --> 00:47:32,664
מיץ חלב ותפוז
מטפורה עכשיו נשברת,

1065
00:47:32,664 --> 00:47:35,060
כי אלה הן כוסות
מפות נוזליים ולא.

1066
00:47:35,060 --> 00:47:37,750
אנחנו במקום צריכים ללכת
כדי לטפל 10 ואנחנו

1067
00:47:37,750 --> 00:47:42,420
צריך ללכת לכתובת 11, ו
לאחר מכן לבצע שהיגיון ההחלפה.

1068
00:47:42,420 --> 00:47:45,580
>> אז ההיגיון הוא אותו, אבל
אנו זקוקים לדרך מעט שונה

1069
00:47:45,580 --> 00:47:47,160
לגישה למשתנים אלו.

1070
00:47:47,160 --> 00:47:52,400
וכך בסופו של הדבר, מה ש
תכנית צריכה להיראות כמו זה.

1071
00:47:52,400 --> 00:47:56,610
בswap.c להעתיק, פשוטו כמשמעו,
ולהדביק את הגרסה הירוקה.

1072
00:47:56,610 --> 00:47:58,450
אבל אני צריך לעשות שינוי אחד.

1073
00:47:58,450 --> 00:48:00,180
זה לא מספיק רק כדי לשנות את ההחלפה.

1074
00:48:00,180 --> 00:48:03,830
מה קו אחר של קוד
אני צריך לעשות כדי לשנות?

1075
00:48:03,830 --> 00:48:04,330
כן?

1076
00:48:04,330 --> 00:48:05,770
>> קהל: איפה זה לוקח את הטענות.

1077
00:48:05,770 --> 00:48:07,603
>> דוד י מלאן: איפה
זה לוקח הטיעון שלה.

1078
00:48:07,603 --> 00:48:09,985
אז אם אני לגלול עד עיקרי, אני
לא יכול פשוט לעבור בx ו- y,

1079
00:48:09,985 --> 00:48:12,820
ו, אני מבטיח, שעבר
חתיכת התחביר החדש היום.

1080
00:48:12,820 --> 00:48:17,200
אני צריך לעבור בלא x ו
y אבל הכתובת של x ו- y.

1081
00:48:17,200 --> 00:48:20,400
ומתברר, סמל
כי מחברי C בחרו

1082
00:48:20,400 --> 00:48:23,860
הוא אם אתה משתמש באמפרסנד כאן, לא ל
להתבלבל עם האמפרסנד הסיבי האופרטור,

1083
00:48:23,860 --> 00:48:27,130
אם אתה משתמש באמפרסנד
כאן וכאן אמפרסנד,

1084
00:48:27,130 --> 00:48:29,570
זה דמויות בשבילך,
מה הכתובת של x,

1085
00:48:29,570 --> 00:48:31,740
אולי זה 10, מה
כתובת של y, אולי זה

1086
00:48:31,740 --> 00:48:35,400
11, ועובר אותם במקום.

1087
00:48:35,400 --> 00:48:37,210
>> כל כך הרבה לקלוט בבת אחת.

1088
00:48:37,210 --> 00:48:40,190
אבל בואו נראה עכשיו במהירות ב
ארבע דקות שנותרו לנו

1089
00:48:40,190 --> 00:48:42,150
שבו דברים יכולים להשתבש.

1090
00:48:42,150 --> 00:48:45,120
וכמו בצד, למעשה
לקחתי את התמונה הזאת,

1091
00:48:45,120 --> 00:48:46,920
TF צלם את זה לפני שנה או שנים.

1092
00:48:46,920 --> 00:48:49,190
אז זה הפינה האחורית
של חדר אוכל אליוט.

1093
00:48:49,190 --> 00:48:52,310
מצביעים הם אולי הכי הקשים
נושא שאנו מכסים בCS50.

1094
00:48:52,310 --> 00:48:54,810
אז אם אתה דואג מהסוג
מדרון הוא כמו אולי זה

1095
00:48:54,810 --> 00:48:56,770
יותר של מקל הוקי
כמו זה, מבין

1096
00:48:56,770 --> 00:49:00,160
אנחנו סוג של מתקרבים לשיאו ב
מבחינת המורכבות הרעיונית.

1097
00:49:00,160 --> 00:49:02,300
>> ואני מביא את זה
תמונה, כי אני נשבע

1098
00:49:02,300 --> 00:49:05,920
לאלוהים, בסתיו 1996, כאשר לקחתי
CS50 עם בחור ההוראה שלי,

1099
00:49:05,920 --> 00:49:09,620
Nishat מהטה, הוא הושיב אותי ב
פינה של ד הול אליוט בארוחת צהריים,

1100
00:49:09,620 --> 00:49:12,330
או ארוחת ערב, או משהו כדי לנסות
כדי לעזור לי להבין מצביעים.

1101
00:49:12,330 --> 00:49:16,520
וזה המקום שבו אני היה שבועות אחרי
זה הוצג בהרצאה כש

1102
00:49:16,520 --> 00:49:18,170
אני סוף סוף הבנתי מצביעים.

1103
00:49:18,170 --> 00:49:20,590
ואני מקווה שזה
יהיה לחץ כה מוקדם בשבילך.

1104
00:49:20,590 --> 00:49:23,540
אבל מבין את זה לחלוטין בין
הנושאים מתוחכמים יותר

1105
00:49:23,540 --> 00:49:24,420
בדקנו.

1106
00:49:24,420 --> 00:49:25,819
אבל זה בין החזק ביותר.

1107
00:49:25,819 --> 00:49:28,860
וכאשר אתה מקבל את זה, זה באמת כל
רק הולך סוף סוף הגיע יחד.

1108
00:49:28,860 --> 00:49:31,460
אז היה סמוך ובטוח שזה לא
צריך את כל הכיור בהיום.

1109
00:49:31,460 --> 00:49:32,980
>> אז הנה התכנית האחרונה
אנחנו הולכים להסתכל.

1110
00:49:32,980 --> 00:49:35,605
ואנחנו הולכים לסיים עם
שלוש דקות מהירות של אולפן

1111
00:49:35,605 --> 00:49:37,030
שנעשה על ידי ידידנו, ניק Parlante.

1112
00:49:37,030 --> 00:49:41,440
הנה תכנית, שעל שני העליונים
קווים מצהיר x ו- y משתנה.

1113
00:49:41,440 --> 00:49:44,780
שניהם כתובות
של מספרים שלמים, מצביעי AKA.

1114
00:49:44,780 --> 00:49:48,125
לאחר מכן, אנו להקצות מספיק
זיכרון לאחסון int

1115
00:49:48,125 --> 00:49:51,344
ולאחסן את כתובת
זיכרון שבx.

1116
00:49:51,344 --> 00:49:53,260
אז, זה אפילו פשוט יותר
מהדוגמא קודמת.

1117
00:49:53,260 --> 00:49:56,100
תן לי ארבעה בתים של זיכרון,
זה הגודל של int,

1118
00:49:56,100 --> 00:49:58,000
ולשים את כתובת שבx.

1119
00:49:58,000 --> 00:50:01,070
קו זה כאן אומר
גש לכתובת בx

1120
00:50:01,070 --> 00:50:05,270
ולשים את המשמעות של
חיים, המספר 42 שם.

1121
00:50:05,270 --> 00:50:07,710
אבל הקו הזה מדאיג אותי.

1122
00:50:07,710 --> 00:50:12,620
כוכב y אומר ללכת לכתובת בy,
ולשים את מספר מזל 13 שם.

1123
00:50:12,620 --> 00:50:15,780
למה זה מסוכן, בשלב זה
בstory-- אם כי אמר לי מהירות

1124
00:50:15,780 --> 00:50:17,980
בדקות האחרונות שלנו
כאן-- למה זה רע

1125
00:50:17,980 --> 00:50:19,660
לי לומר, ללכת לכתובת בy?

1126
00:50:19,660 --> 00:50:21,077
>> קהל: יש לך לא [לא ברור].

1127
00:50:21,077 --> 00:50:22,910
דוד י מלאן: יש לי לא
לשים שום דבר בy.

1128
00:50:22,910 --> 00:50:25,520
אז מה הוא הערך של y,
בנקודה זו בסיפור הזה?

1129
00:50:25,520 --> 00:50:26,570
אין לנו מושג.

1130
00:50:26,570 --> 00:50:29,190
זה קצת ערך זבל
וגם לא יודע בינקי.

1131
00:50:29,190 --> 00:50:32,532
אם אנחנו יכולים בסופו על הפתק הזה.

1132
00:50:32,532 --> 00:50:34,832
>> [וידאו השמעה]

1133
00:50:34,832 --> 00:50:36,500
>> היי, בינקי, להתעורר.

1134
00:50:36,500 --> 00:50:39,140
זה זמן בשביל כיף מצביע.

1135
00:50:39,140 --> 00:50:40,210
>> -מה זה?

1136
00:50:40,210 --> 00:50:41,690
למד על מצביעים?

1137
00:50:41,690 --> 00:50:43,570
אה, סוכריה.

1138
00:50:43,570 --> 00:50:46,600
>> "טוב, כדי להתחיל, אני מניח שאנחנו
הולך צריך כמה עצות.

1139
00:50:46,600 --> 00:50:47,380
>> -אוקיי.

1140
00:50:47,380 --> 00:50:51,120
קוד זה מקצה שני מצביעים
אשר יכול להצביע על מספרים שלמים.

1141
00:50:51,120 --> 00:50:53,557
>> או קיי, גם אני רואה
שני מצביעים, אבל הם

1142
00:50:53,557 --> 00:50:55,140
לא נראה שלא יהיה הצבעה לכל דבר.

1143
00:50:55,140 --> 00:50:55,970
>> -זה נכון.

1144
00:50:55,970 --> 00:50:58,100
בתחילה pointers
אינו מצביע על שום דבר.

1145
00:50:58,100 --> 00:51:00,950
הדברים שהם מצביעים עליהם
נקרא pointees והקמתם

1146
00:51:00,950 --> 00:51:02,330
הוא צעד נפרד.

1147
00:51:02,330 --> 00:51:03,210
>> אה, נכון, נכון.

1148
00:51:03,210 --> 00:51:03,940
ידעתי את זה.

1149
00:51:03,940 --> 00:51:05,730
Pointees הם נפרדים.

1150
00:51:05,730 --> 00:51:08,310
אז איך אתה להקצות pointee?

1151
00:51:08,310 --> 00:51:11,960
>> או קיי, גם מקצה את הקוד הזה
pointee השלם חדש,

1152
00:51:11,960 --> 00:51:15,050
וx סטי חלק זה כדי להצביע על זה.

1153
00:51:15,050 --> 00:51:16,240
>> היי, זה נראה טוב יותר.

1154
00:51:16,240 --> 00:51:17,743
אז לעשות את זה לעשות משהו.

1155
00:51:17,743 --> 00:51:23,580
>> או קיי, אני dereference x המצביע ל
לאחסן את המספר 42 לpointee.

1156
00:51:23,580 --> 00:51:27,130
על הטריק הזה, אני צריך
שרביט קסם של ביטול הפניה.

1157
00:51:27,130 --> 00:51:30,200
>> שרביט קסם -Your של ביטול הפניה?

1158
00:51:30,200 --> 00:51:32,310
אה, זה, זה נהדר.

1159
00:51:32,310 --> 00:51:34,270
>> 'זה מה הקוד נראה.

1160
00:51:34,270 --> 00:51:35,970
אני רק להגדיר את המספר and--

1161
00:51:35,970 --> 00:51:37,070
>> [POP SOUND]

1162
00:51:37,070 --> 00:51:39,140
>> היי, נראה שם זה הולך.

1163
00:51:39,140 --> 00:51:43,980
אז, עושה dereference על x כדלקמן
החצים כדי לגשת pointee.

1164
00:51:43,980 --> 00:51:46,150
במקרה זה, לאחסון 42 שם.

1165
00:51:46,150 --> 00:51:50,700
היי, נסה להשתמש בו כדי לאחסן המספר
13 דרך המצביע האחר, y.

1166
00:51:50,700 --> 00:51:51,840
>> -אוקיי.

1167
00:51:51,840 --> 00:51:56,270
אני פשוט אלך לכאן כדי y,
ולקבל להגדיר מספר 13.

1168
00:51:56,270 --> 00:52:00,380
ואז לקחת את השרביט של
ביטול הפניה ופשוט--

1169
00:52:00,380 --> 00:52:01,646
>> [הזמזם SOUND]

1170
00:52:01,646 --> 00:52:04,080
>> אה, היי זה לא עבד.

1171
00:52:04,080 --> 00:52:06,470
אומר, אה, בינקי, אני לא
חושב ביטול הפניה

1172
00:52:06,470 --> 00:52:10,850
y הוא רעיון טוב, כי הגדרה
עד pointee הוא צעד נפרד.

1173
00:52:10,850 --> 00:52:12,480
ואני לא חושב שאי פעם עשינו את זה.

1174
00:52:12,480 --> 00:52:14,620
>> -Hmm, נקודה טובה.

1175
00:52:14,620 --> 00:52:19,810
>> 'כן, אנחנו הוקצו המצביע, y, אבל
אנחנו אף פעם לא להגדיר אותו כדי להצביע על pointee.

1176
00:52:19,810 --> 00:52:21,590
>> -Hmm, מאוד דתי.

1177
00:52:21,590 --> 00:52:23,215
היי, אתה נראה טוב שם, בינקי.

1178
00:52:23,215 --> 00:52:26,390
האם אתה יכול לתקן את זה, כך שנקודות y
לאותו pointee כx.

1179
00:52:26,390 --> 00:52:29,290
>> -Sure, אני משתמש בשרביט הקסם שלי
של משימת מצביע.

1180
00:52:29,290 --> 00:52:31,970
>> -זה גם הולך להיות
בעיה, כמו לפני?

1181
00:52:31,970 --> 00:52:33,790
>> -לא, זה לא נוגע pointees.

1182
00:52:33,790 --> 00:52:35,840
זה רק משנה מצביע אחד
כדי להצביע על אותו thing--

1183
00:52:35,840 --> 00:52:36,465
>> [קולות נפץ]

1184
00:52:36,465 --> 00:52:37,450
--as אחר.

1185
00:52:37,450 --> 00:52:38,440
>> -אני מבין.

1186
00:52:38,440 --> 00:52:41,200
עכשיו נקודות y לאותו המקום כמו x.

1187
00:52:41,200 --> 00:52:42,950
אז, לחכות, עכשיו y הוא קבוע.

1188
00:52:42,950 --> 00:52:44,110
יש לו pointee.

1189
00:52:44,110 --> 00:52:47,779
אז אתה יכול לנסות את השרביט של
ביטול הפניה שוב לשלוח מעל 13.

1190
00:52:47,779 --> 00:52:51,110
>> אה, אוקיי, הנה זה בא.

1191
00:52:51,110 --> 00:52:52,330
>> היי, תראה את זה.

1192
00:52:52,330 --> 00:52:53,570
עכשיו ביטול הפנית עבודות על y.

1193
00:52:53,570 --> 00:52:57,900
ומכיוון שהמצביעים משתפים
שpointee אחד, שניהם לראות את 13.

1194
00:52:57,900 --> 00:52:59,952
>> 'כן, שיתוף, אה, לא משנה מה.

1195
00:52:59,952 --> 00:53:01,535
אז, אנחנו הולכים לעבור מקומות עכשיו?

1196
00:53:01,535 --> 00:53:03,730
>> אה, נראה שאנחנו מחוץ לזמן.

1197
00:53:03,730 --> 00:53:04,660
>> -But--

1198
00:53:04,660 --> 00:53:06,520
>> פשוס לזכור שלושה כללי מצביע.

1199
00:53:06,520 --> 00:53:09,550
מספר 1, את המבנה הבסיסי
הוא שיש לך מצביע,

1200
00:53:09,550 --> 00:53:11,630
והוא מצביע אל pointee.

1201
00:53:11,630 --> 00:53:13,740
אבל והמצביע
pointee הם נפרדים.

1202
00:53:13,740 --> 00:53:15,620
והטעות הנפוצה
הוא להגדיר מצביע

1203
00:53:15,620 --> 00:53:18,000
אבל לשכוח לתת לו pointee.

1204
00:53:18,000 --> 00:53:21,170
>> מספר 2, ביטול הפנית מצביע
מתחיל במצביע

1205
00:53:21,170 --> 00:53:24,020
ולהלן חיצו מעל
כדי לגשת לpointee.

1206
00:53:24,020 --> 00:53:27,815
כפי שכולנו יודעים, זה עובד רק אם יש
הוא pointee, איזה סוג של מקבל בחזרה

1207
00:53:27,815 --> 00:53:29,260
לפסוק מספר 1.

1208
00:53:29,260 --> 00:53:31,990
>> מספר 3, מצביע
משימה לוקחת מצביע אחד

1209
00:53:31,990 --> 00:53:35,330
ומשנה אותו כדי להצביע על
אותו pointee כמצביע אחר.

1210
00:53:35,330 --> 00:53:37,150
אז אחרי המשימה,
שני מצביעים

1211
00:53:37,150 --> 00:53:40,927
יצביע לאותו pointee,
לפעמים זה נקרא שיתוף.

1212
00:53:40,927 --> 00:53:42,510
וזה כל מה שיש בו, באמת.

1213
00:53:42,510 --> 00:53:43,130
ביי ביי עכשיו.

1214
00:53:43,130 --> 00:53:43,475
>> [סוף ההשמעה]

1215
00:53:43,475 --> 00:53:44,830
>> דוד י מלאן: זהו זה לCS50.

1216
00:53:44,830 --> 00:53:46,246
תודה לפרופסור ניק Parlante.

1217
00:53:46,246 --> 00:53:47,730
נתראה בשבוע הבא.

1218
00:53:47,730 --> 00:53:51,706

1219
00:53:51,706 --> 00:53:56,435
>> [השמעת מוסיקה אלקטרונית]

1220
00:53:56,435 --> 00:57:22,775