1
00:00:00,000 --> 00:00:02,670
>> [מוסיקה נושא]

2
00:00:02,670 --> 00:00:11,834

3
00:00:11,834 --> 00:00:13,365
>> 1 SPEAKER: היי, כולם.

4
00:00:13,365 --> 00:00:14,365
ברוכים השבים לסעיף.

5
00:00:14,365 --> 00:00:15,700

6
00:00:15,700 --> 00:00:18,700
יום מקסים out-- ולכן, אני
בטוח, יש רק ארבעה מכם כאן

7
00:00:18,700 --> 00:00:21,180
ולא חבילה הרגילה שלנו.

8
00:00:21,180 --> 00:00:22,670
אני הייתי חולה בסוף השבוע הזה.

9
00:00:22,670 --> 00:00:24,294
אז אין לי Starburst בשבילכם.

10
00:00:24,294 --> 00:00:26,400
ואני יכול להתחיל שיעול
נורא לאורך כל זה.

11
00:00:26,400 --> 00:00:27,790
אז פשוט תהיה סבלני איתי.

12
00:00:27,790 --> 00:00:30,624
אני הולך באמת לנסות
ולעבור את זה ראשון,

13
00:00:30,624 --> 00:00:32,290
אם כי, לפני שאקבל התקף שיעול.

14
00:00:32,290 --> 00:00:33,410

15
00:00:33,410 --> 00:00:37,390
אבל רק להיות קל עליי
קצת bit-- זה כל מה שאני מבקש.

16
00:00:37,390 --> 00:00:39,370

17
00:00:39,370 --> 00:00:44,289
>> אז סדר היום שלנו לtoday-- רק
reminder-- החידון שלך הוא בשבוע הבא.

18
00:00:44,289 --> 00:00:46,830
אמרתי לך בשבוע שעבר זה כל כך זה
לא יתפוס אותך לא מוכן.

19
00:00:46,830 --> 00:00:47,954
אז אני מזכיר לך שוב.

20
00:00:47,954 --> 00:00:49,180
החידון שלך בשבוע הבא.

21
00:00:49,180 --> 00:00:52,730
לשם כך, בשבוע הבא של
סעיף יהיה הרבה יותר

22
00:00:52,730 --> 00:00:55,180
ל-- אני אנסה ועבודה בחלק הסקירה.

23
00:00:55,180 --> 00:00:58,130
אז אם אתם יכולים
לעזור לי ושלחת אותי

24
00:00:58,130 --> 00:01:00,990
דברים שאתה מרגיש בנוח
עם, שאתה מודאג,

25
00:01:00,990 --> 00:01:03,530
נושאים שאתה רוצה ל
לי לכסות, זה יהיה נהדר.

26
00:01:03,530 --> 00:01:05,740
אז אני יכול לנסות ולעבוד אותם
לסעיף שלנו בשבוע הבא

27
00:01:05,740 --> 00:01:11,540
או לשלוח לך חומר או הכנה נוספים
שאתה לא יכול לקבל במקום אחר.

28
00:01:11,540 --> 00:01:12,150
>> כן!

29
00:01:12,150 --> 00:01:13,520
יותר אנשים באים!

30
00:01:13,520 --> 00:01:17,320
חשבתי, עשיתי את זה קשה שעבר
שבוע, כי אף אחד לא רוצה לחזור?

31
00:01:17,320 --> 00:01:18,065
אני מפחד.

32
00:01:18,065 --> 00:01:18,892

33
00:01:18,892 --> 00:01:21,100
אז שלושה דברים האחרים
שאנחנו הולכים לעבור על

34
00:01:21,100 --> 00:01:24,850
הם ניתוב מחדש, אני קובץ / O, ו
אז מצביעים וזיכרון דינמי.

35
00:01:24,850 --> 00:01:29,160
אני בטוח שכולכם נרגש סופר על
pointers-- הנושא האהוב על כולם,

36
00:01:29,160 --> 00:01:31,310
כל כך פשוט להבנה.

37
00:01:31,310 --> 00:01:33,130
אני בטוח שאתם כל יש את זה, נכון?

38
00:01:33,130 --> 00:01:39,510
>> דברים אז קודם ראשון, redirection--
זה בעצם רק דרך

39
00:01:39,510 --> 00:01:42,920
כדי לשלוט באופן שאתה קלט
דברים בתכנית שלך,

40
00:01:42,920 --> 00:01:44,606
איך אתה דברים פלט מהתכנית שלך.

41
00:01:44,606 --> 00:01:46,980
הדרכים העיקריות שאתם
כבר אינטראקציה עם זה

42
00:01:46,980 --> 00:01:51,650
רק דרך החוצה סטנדרטיים
עם מסך ההדפסה שלך כאן.

43
00:01:51,650 --> 00:01:55,940
אבל יש דרכים ל
pipe-- כפי שאנו רואים כאן

44
00:01:55,940 --> 00:01:58,980
הוא אחד מסוג words--
צינור שהמידע

45
00:01:58,980 --> 00:02:02,850
הנתונים לקובץ מקובץ או.

46
00:02:02,850 --> 00:02:05,820
זה דרכים שונות רק
מקבל דברים בתכנית שלך

47
00:02:05,820 --> 00:02:10,681
ואת התכנית שלך, במקום
רק להדפיס אותם למסך הזה

48
00:02:10,681 --> 00:02:12,430
או המזינים דברים
משורת הפקודה.

49
00:02:12,430 --> 00:02:13,760

50
00:02:13,760 --> 00:02:18,030
>> אז ראשון הוא קטן
גדול מתו.

51
00:02:18,030 --> 00:02:22,085
אז output-- זה פשוט מדפיס את הפלט
לקובץ במקום המסך שלך.

52
00:02:22,085 --> 00:02:23,620

53
00:02:23,620 --> 00:02:29,500
אז אם היה לך משהו שמודפס
"שלום, עולם!" למסך,

54
00:02:29,500 --> 00:02:32,400
אם תשים אותו במקום
לoutput.text, ש

55
00:02:32,400 --> 00:02:35,220
יוצר הקובץ הזה שנקרא output.text.

56
00:02:35,220 --> 00:02:38,550
וכאשר אתה פותח אותו, זה יהיה
להגיד "שלום, עולם!" שם.

57
00:02:38,550 --> 00:02:41,410
זה יכול להיות סופר שימושי
אם יש לך טונה של שגיאות

58
00:02:41,410 --> 00:02:43,430
למעשה, כפי שאנו רואים בזה.

59
00:02:43,430 --> 00:02:46,810
אם אתה עושה את שני תו, זה יהיה
להדפיס הודעות השגיאה.

60
00:02:46,810 --> 00:02:52,090
>> אז אם אתה נתקלת בבעיה עם
קומפילציה, יש לו הרבה שגיאות

61
00:02:52,090 --> 00:02:56,770
ואתה מסתבך בניסיון
כדי לגלול בשורת הפקודה שלך

62
00:02:56,770 --> 00:02:59,110
דרך כולם, שאתה יכול
פשוט להדפיס אותם לקובץ,

63
00:02:59,110 --> 00:03:02,130
לפתוח את הקובץ ש, כך שאתה
יכול לגלול אותם קלים יותר.

64
00:03:02,130 --> 00:03:05,160
אני ממש בשימוש ש
הרבה כשבאגים

65
00:03:05,160 --> 00:03:07,970
181 psets שלי ללמידת מכונה.

66
00:03:07,970 --> 00:03:10,000
אז זה יכול להיות סופר שימושי בהמשך.

67
00:03:10,000 --> 00:03:18,370
זה גם שימושי אם יש לך תכנית
שאולי הוא יצירת ספרייה

68
00:03:18,370 --> 00:03:20,430
או לייצר כמה סט
של מחרוזות, ואתה

69
00:03:20,430 --> 00:03:22,846
צריך להיות מסוגל לראות את זה
שהיא מייצרת אותם כראוי.

70
00:03:22,846 --> 00:03:23,860

71
00:03:23,860 --> 00:03:25,160
זו הדרך לעשות את זה.

72
00:03:25,160 --> 00:03:28,280
>> אז אם אתה מדפיס אותם לקובץ, אתה
בקלות רבה יותר יכול לבחון אותם, נכון?

73
00:03:28,280 --> 00:03:30,930
לעומת מנסה לגלול
דרך שורת הפקודה שלך.

74
00:03:30,930 --> 00:03:32,740

75
00:03:32,740 --> 00:03:35,820
ואז דבר אחד לציין
הוא שרק עם יותר

76
00:03:35,820 --> 00:03:40,090
מ תו, אם אתה כותב
לקובץ שכבר exists--

77
00:03:40,090 --> 00:03:44,990
כך כמו אם רצנו זה ראשון
זמן, אנחנו שמים את זה לoutput.text,

78
00:03:44,990 --> 00:03:49,970
ולאחר מכן הייתה לנו תכנית שנייה
שהודפס זה כתכנית שתי

79
00:03:49,970 --> 00:03:54,250
ועשה יותר מאשר לoutput.text,
זה יחליף that-- כך

80
00:03:54,250 --> 00:03:56,715
להחליף את מה שהיה אי פעם ב
קובץ שמלכתחילה.

81
00:03:56,715 --> 00:03:57,720

82
00:03:57,720 --> 00:04:00,750
>> אז אם ברצונך לצרף
לקובץ, כפי שאנו רואים כאן,

83
00:04:00,750 --> 00:04:04,779
אתה פשוט עושה את שני גדול יותר מסימנים.

84
00:04:04,779 --> 00:04:05,820
וזה יוסיף לזה.

85
00:04:05,820 --> 00:04:06,750
זה לא להחליף אותו.

86
00:04:06,750 --> 00:04:09,770
אז אם אתה צריך להפעיל מספר רב של
תוכניות וסוג של לשמור

87
00:04:09,770 --> 00:04:13,170
אחר מה כולם
חוזר אליך בקובץ,

88
00:04:13,170 --> 00:04:14,190
זו דרך לעשות את זה.

89
00:04:14,190 --> 00:04:17,231
אם לא אכפת לך מה נמצא בתיק שלך
וזה מותר להיות מוחלף,

90
00:04:17,231 --> 00:04:19,204
אתה יכול פשוט להשתמש יותר בודד מאשר.

91
00:04:19,204 --> 00:04:20,600
האם זה הגיוני לכולם?

92
00:04:20,600 --> 00:04:23,205

93
00:04:23,205 --> 00:04:31,140
>> קהל: כמו נקודה לקצץ שלום גדול יותר
יותר מאשר טקסט נקודת תפוקה, כמו פעמיים,

94
00:04:31,140 --> 00:04:34,030
זה פשוט יראו רק על פלט
על מודעה נקודת time-- שנייה

95
00:04:34,030 --> 00:04:34,810
>> 1 SPEAKER: נכון.

96
00:04:34,810 --> 00:04:40,450
אז זה בעצם היית רק לחלוטין
להחליף את מה שהיה שם מלכתחילה.

97
00:04:40,450 --> 00:04:44,260
אם קובץ זה כאן,
output.text כבר

98
00:04:44,260 --> 00:04:48,230
קיים, בעצם כל מה שאתה קורא
זה שוב עם יותר בודד

99
00:04:48,230 --> 00:04:51,920
ממה שאתה יכול רק לחשוב על זה
כמו כמו שהוא החליף את הקובץ.

100
00:04:51,920 --> 00:04:54,824
כמו כשאתה שומר Word
מסמך ואתה לשמור כ,

101
00:04:54,824 --> 00:04:57,365
ואתה שומר אותו שם, ו
היא מחליפה it-- לחלוטין

102
00:04:57,365 --> 00:04:58,680
זה אותו הסוג של דבר.

103
00:04:58,680 --> 00:05:00,380

104
00:05:00,380 --> 00:05:03,550
למישהו יש שאלות על
רק פלט לקובץ?

105
00:05:03,550 --> 00:05:05,051

106
00:05:05,051 --> 00:05:05,550
מדהים.

107
00:05:05,550 --> 00:05:11,440
>> אז ברור, אם אתה להפוך את
חץ כיוון, הוא יכול לעשות קלט.

108
00:05:11,440 --> 00:05:13,090

109
00:05:13,090 --> 00:05:19,960
לכן, כאשר יש לך חבר '
כמו קיסר או VISIONEER

110
00:05:19,960 --> 00:05:23,195
והיה לך לקלט משהו,
הייתה לך טענת שורת פקודה

111
00:05:23,195 --> 00:05:24,960
כי בעצם קלט אותו.

112
00:05:24,960 --> 00:05:27,410
זוהי דרך נוספת לעשות את זה.

113
00:05:27,410 --> 00:05:30,520
אז במקום לחכות
לפקודה,

114
00:05:30,520 --> 00:05:33,800
כמו בעת שבקשת
הודעה בקיסר או VISIONEER,

115
00:05:33,800 --> 00:05:36,490
אם היה לך קובץ טקסט
שההודעה שלך,

116
00:05:36,490 --> 00:05:38,280
אתה יכול פשוט להקליד את זה לתוך זה.

117
00:05:38,280 --> 00:05:44,930
>> אז אם זה היה כמו נקודה לקצץ קיסר
3 פחות מטקסט קלט חץ, ש

118
00:05:44,930 --> 00:05:47,240
המסר שלך, ש
היה רץ בסדר גמור.

119
00:05:47,240 --> 00:05:51,310

120
00:05:51,310 --> 00:05:54,020
כאשר תכנית הקיסר שלך למעשה
ביקש קלט מהמשתמש,

121
00:05:54,020 --> 00:05:57,360
זה כבר יש את זה, כי
שהקלדת בקובץ זה.

122
00:05:57,360 --> 00:05:58,830
זה רק בדרך אחרת.

123
00:05:58,830 --> 00:06:02,445
רק הפוך של output--
רק קלט עבור הנתונים שלך.

124
00:06:02,445 --> 00:06:04,570

125
00:06:04,570 --> 00:06:06,680
>> ואז האחרון הוא צינור.

126
00:06:06,680 --> 00:06:07,780
אז די מגניב של זה.

127
00:06:07,780 --> 00:06:09,890
כי זה מאפשר לך
לקחת את הפלט של אחד

128
00:06:09,890 --> 00:06:13,695
תכנית והכניסה אותו כ
קלט לתכנית אחרת.

129
00:06:13,695 --> 00:06:15,250

130
00:06:15,250 --> 00:06:18,630
אני לא יודע אם מישהו מכם
שיחקתי עם אותן לפענוח

131
00:06:18,630 --> 00:06:20,590
CS50 שאולי יש לי
נתתי לך, אבל זה יהיה

132
00:06:20,590 --> 00:06:27,380
מאפשר לך לקחת חלק מדגם
קובץ, הקלד אותו להצפנה שלך,

133
00:06:27,380 --> 00:06:30,350
ואז משם להקליד
כי לפענוח שלך

134
00:06:30,350 --> 00:06:32,470
כדי לוודא שכיבה את אותו הדבר.

135
00:06:32,470 --> 00:06:34,050
אז זה כמו סוג של שלוש דרך לולאה.

136
00:06:34,050 --> 00:06:38,400

137
00:06:38,400 --> 00:06:39,423
לכו על זה.

138
00:06:39,423 --> 00:06:41,785
>> קהל: אם תכנית
יש כניסות מרובות,

139
00:06:41,785 --> 00:06:47,646
האם יש דרך להגיד את זה שקלט
כדי להשתמש בקובץ הטקסט או הפלט עבור?

140
00:06:47,646 --> 00:06:49,325
>> 1 SPEAKER: יש לו כניסות מרובות.

141
00:06:49,325 --> 00:06:52,190

142
00:06:52,190 --> 00:07:00,430
לא משנה מה להגיש input-- שלך כאשר זה
מבקש קלט שהפעם הראשונה, זה

143
00:07:00,430 --> 00:07:03,240
הולך להניח, אני חושב, שזה
הולך צינור בכל הקובץ.

144
00:07:03,240 --> 00:07:03,979

145
00:07:03,979 --> 00:07:07,145
אז אם יש לך כניסות מרובות, אתה
הולך להיות צנרת במספר קבצים.

146
00:07:07,145 --> 00:07:08,190

147
00:07:08,190 --> 00:07:12,390
אז אם אתה שואל להודעות
שלוש פעמים בקוד שלך,

148
00:07:12,390 --> 00:07:15,230
אתה הולך לשים
בשלושה קבצים שונים.

149
00:07:15,230 --> 00:07:15,980
וזה הופך להיות משוגע.

150
00:07:15,980 --> 00:07:18,188
ואתה לא צריך
לדאוג שעכשיו.

151
00:07:18,188 --> 00:07:19,150
אבל זה הרעיון.

152
00:07:19,150 --> 00:07:20,680

153
00:07:20,680 --> 00:07:26,822
>> אז כן, צינור הוא רק פלט של אחד
תכנית משתמשת בקלט לתוך השני.

154
00:07:26,822 --> 00:07:27,665
כולם טוב שם?

155
00:07:27,665 --> 00:07:28,565

156
00:07:28,565 --> 00:07:29,065
מגניב.

157
00:07:29,065 --> 00:07:30,170

158
00:07:30,170 --> 00:07:30,932
אישור.

159
00:07:30,932 --> 00:07:32,890
אתה כנראה לא תהיה לי
לעשות יותר מדי עם זה.

160
00:07:32,890 --> 00:07:35,670
אבל אתה צריך להבין
דרכים אתה יכול להשתמש בזה.

161
00:07:35,670 --> 00:07:38,910
ויש מקרים מסוימים ש
אולי כדאי לך להשתמש בו.

162
00:07:38,910 --> 00:07:44,590
>> אז להגיש I / O-- אני יודע מה אתה
saying-- אנחנו רגילים לקרוא מ

163
00:07:44,590 --> 00:07:50,500
וכתב למסך שלנו יש,
אשר הוא סטנדרטי ובפלט סטנדרטי.

164
00:07:50,500 --> 00:07:54,370
וזה מה שאתם היו
עושה מאז תחילת הכיתה כאן.

165
00:07:54,370 --> 00:07:58,220
אבל אתה יכול גם לקרוא ולכתוב קבצים,
וזה כל הקובץ אני / O-- כך קובץ קלט,

166
00:07:58,220 --> 00:07:59,850
פלט הוא כל מה שהוא מייצג.

167
00:07:59,850 --> 00:08:00,930

168
00:08:00,930 --> 00:08:04,360
אז זה בעצם אומר ש
אתה יכול לאחסן את הנתונים שלך עכשיו.

169
00:08:04,360 --> 00:08:08,460
>> כאשר אתה פשוט להדפיס אותו ל
מסך, שזה בעצם נעלם, נכון?

170
00:08:08,460 --> 00:08:12,507
ברגע שאתה עושה "שלום
עולם "וברח" שלום העולם "

171
00:08:12,507 --> 00:08:14,090
הוא מדפיס "שלום עולם" על המסך.

172
00:08:14,090 --> 00:08:16,370
אבל אתה לא באמת יכול לעשות
כל דבר עם אותו משם.

173
00:08:16,370 --> 00:08:18,950
אם תאחסן בטקסט
קובץ, ואז פתאום

174
00:08:18,950 --> 00:08:22,789
יש לך את הנתונים שאתה רשאי
להשפיע או להכניס אותו לתוך קובץ,

175
00:08:22,789 --> 00:08:24,080
או לשים אותו לתכנית מאוחר יותר.

176
00:08:24,080 --> 00:08:26,370

177
00:08:26,370 --> 00:08:29,290
אחת הסיבות
למה אנחנו עושים את זה רק

178
00:08:29,290 --> 00:08:31,560
כדרך לאחסון נתונים לשימוש מאוחר יותר.

179
00:08:31,560 --> 00:08:34,790

180
00:08:34,790 --> 00:08:37,279
>> יש לי כמה צעדים כאן
רק הליכה בתקן

181
00:08:37,279 --> 00:08:39,450
I / O. בשלב אחד, אתה
צריך ליצור הפניה

182
00:08:39,450 --> 00:08:43,480
לקובץ עם כל
כובעי קובץ כוכב.

183
00:08:43,480 --> 00:08:45,740
לכן נוצר מצביע לקובץ.

184
00:08:45,740 --> 00:08:48,080

185
00:08:48,080 --> 00:08:49,650
אז אתה רוצה לפתוח אותו.

186
00:08:49,650 --> 00:08:52,940
ואתה אומר, פשוטו כמשמעו,
רק קובץ שווה fopen.

187
00:08:52,940 --> 00:08:57,400
וזה הולך לחזור
מצביע לקובץ שרק נפתח.

188
00:08:57,400 --> 00:08:59,610

189
00:08:59,610 --> 00:09:01,460
ראיתי כמה מכם
החבר 'ה בשעתי עבודה.

190
00:09:01,460 --> 00:09:07,400
>> אבל אחד הדברים
הוא מצביעי remember--

191
00:09:07,400 --> 00:09:10,409
יכול להיות כמה כתובות או null, נכון?

192
00:09:10,409 --> 00:09:12,700
אם אי פעם יש לנו מקרה שבו
משהו יכול להחזיר null,

193
00:09:12,700 --> 00:09:14,990
מה שאנחנו צריכים לעשות
לפני שאנחנו משתמשים בו?

194
00:09:14,990 --> 00:09:16,220

195
00:09:16,220 --> 00:09:19,000
אנחנו צריכים לבדוק אם
זה null או לא, נכון?

196
00:09:19,000 --> 00:09:23,600
מפני שחלק מכם אולי יש לי
הבעיה שבה כל מה שאובייקט

197
00:09:23,600 --> 00:09:26,110
היה מוחזר בפריצה היה ריק.

198
00:09:26,110 --> 00:09:28,170
ניסית לבצע
כמה פונקציה עליו.

199
00:09:28,170 --> 00:09:29,770
ואתר המחשב פגם.

200
00:09:29,770 --> 00:09:30,725
נכון?

201
00:09:30,725 --> 00:09:33,640
אני בטוח שכמה מכם
ייתכן שיהיה לה בעיה.

202
00:09:33,640 --> 00:09:38,890
>> אז עם fopen, fopen לא יאמין
מחזירות מצביע לקובץ,

203
00:09:38,890 --> 00:09:41,200
או אם משהו משתבש,
זה הולך יחזיר null.

204
00:09:41,200 --> 00:09:45,980
אז אתה תמיד צריך לבדוק
שלא חזר null

205
00:09:45,980 --> 00:09:47,880
לפני שתנסה לעשות שום דבר אחר.

206
00:09:47,880 --> 00:09:49,110

207
00:09:49,110 --> 00:09:51,974
זה כמו הפרדיגמה סטנדרטית
שאתה הולך צריך כאן.

208
00:09:51,974 --> 00:09:54,390
אם יש אי פעם סיכוי ש
משהו יכול לחזור null,

209
00:09:54,390 --> 00:09:56,590
לבדוק כדי לוודא שהוא
לא לפני שתמשיך.

210
00:09:56,590 --> 00:09:58,911
אחרת, אתה הולך
כדי לקבל תקלות אתר יפות.

211
00:09:58,911 --> 00:10:00,410
ואף אחד לא אוהב להתמודד עם אלה.

212
00:10:00,410 --> 00:10:03,180

213
00:10:03,180 --> 00:10:06,410
>> אז כפי שאנו רואים כאן, את הטענה הראשונה
רק הנתיב לקובץ.

214
00:10:06,410 --> 00:10:09,380
אם קובץ שאינו קיים,
זה הולך ליצירת קובץ זה.

215
00:10:09,380 --> 00:10:10,713
וזה רק הולך להיות ריק.

216
00:10:10,713 --> 00:10:10,789

217
00:10:10,789 --> 00:10:13,080
ולאחר מכן את הטענה השנייה
הוא המצב שאתה רוצה.

218
00:10:13,080 --> 00:10:14,610
האם אנחנו רוצים לקרוא מקובץ זה?

219
00:10:14,610 --> 00:10:15,560
האם אתה רוצה לכתוב מזה?

220
00:10:15,560 --> 00:10:16,476
האם אתה רוצה לצרף?

221
00:10:16,476 --> 00:10:17,600

222
00:10:17,600 --> 00:10:20,670
אז בעצם מה שאני רק said--
אם הקובץ לא קיימת

223
00:10:20,670 --> 00:10:23,400
ואתה מנסה לקרוא מ
זה, זה הולך לזרוק שגיאה.

224
00:10:23,400 --> 00:10:26,890
אם הקובץ name-- אוהב אם
file.text עדיין אינו קיים

225
00:10:26,890 --> 00:10:29,250
ואתה רוצה לכתוב
לזה, זה יהיה ליצור

226
00:10:29,250 --> 00:10:33,110
קובץ ריק בשם file.text בשבילך.

227
00:10:33,110 --> 00:10:36,612
ואם אתה רוצה לצרף,
אתה צריך לעשות את אותו דבר.

228
00:10:36,612 --> 00:10:38,081
האם זה הגיוני?

229
00:10:38,081 --> 00:10:40,580
אם אתה מנסה לקרוא מ
קובץ שאינו קיימים עדיין,

230
00:10:40,580 --> 00:10:41,590
זה יהיה לזרוק את השגיאה.

231
00:10:41,590 --> 00:10:44,340
אחרת, היא תיצור את הקובץ
לך לעשות מה שאתה רוצה זה.

232
00:10:44,340 --> 00:10:45,970

233
00:10:45,970 --> 00:10:46,470
מגניב.

234
00:10:46,470 --> 00:10:47,510

235
00:10:47,510 --> 00:10:48,880
עכשיו אנחנו יכולים לקרוא מהקובץ.

236
00:10:48,880 --> 00:10:52,570
וזה פשוט סוג של הולך
באמצעות הפונקציות השונות

237
00:10:52,570 --> 00:10:58,980
שיש לנו שלקובץ קלט / פלט. רצון זה
יהיה צורך בpset השבוע,

238
00:10:58,980 --> 00:11:00,505
אם אני זוכר נכון.

239
00:11:00,505 --> 00:11:02,880
כן, זה בהחלט יהיה
צורך בpset השבוע.

240
00:11:02,880 --> 00:11:04,260

241
00:11:04,260 --> 00:11:07,010
אז fgetc מחזיר את התו הבא.

242
00:11:07,010 --> 00:11:08,350

243
00:11:08,350 --> 00:11:10,300
fgets רק מחזיר שורת טקסט.

244
00:11:10,300 --> 00:11:11,790

245
00:11:11,790 --> 00:11:14,610
הוא יחזור כל דבר עד
קו חדש, וזה יהיה לשבור.

246
00:11:14,610 --> 00:11:15,950

247
00:11:15,950 --> 00:11:18,700
אז fread קורא מסוים
מספר הבתים ובמקומותיהם

248
00:11:18,700 --> 00:11:20,700
למערך, ש
הוא משהו שאתה יכול

249
00:11:20,700 --> 00:11:25,485
רוצה לעשות עם מחדש size--
עשוי להיות שימושי.

250
00:11:25,485 --> 00:11:26,550

251
00:11:26,550 --> 00:11:29,290
>> כמה אנשים קראו
מפרט pset, דרך אגב?

252
00:11:29,290 --> 00:11:30,980

253
00:11:30,980 --> 00:11:32,261
אישור.

254
00:11:32,261 --> 00:11:32,760
[לא ברור]

255
00:11:32,760 --> 00:11:35,380

256
00:11:35,380 --> 00:11:36,580
>> 1 SPEAKER: אישור.

257
00:11:36,580 --> 00:11:37,530
בְּסֵדֶר.

258
00:11:37,530 --> 00:11:41,940
בהחלט לקרוא that-- זה pset כיף.

259
00:11:41,940 --> 00:11:51,320
אתה מקבל כדי לשחזר זיכרון שנמחק
card-- באמת מרגש כאשר זה עובד.

260
00:11:51,320 --> 00:11:54,100
אבל בהחלט, להתחיל לקרוא את זה.

261
00:11:54,100 --> 00:11:56,280
בואו לדבר איתי אם אתה
יש לך שאלות על זה.

262
00:11:56,280 --> 00:11:59,290
>> אוקיי, אז כפי שאמרתי, fread
קורא מספר מסוים של בתים.

263
00:11:59,290 --> 00:12:01,340

264
00:12:01,340 --> 00:12:03,590
זה חלק מספר שרירותי
שאתה הולך להקים.

265
00:12:03,590 --> 00:12:05,990

266
00:12:05,990 --> 00:12:08,260
ולאחר מכן fseek רק מהלכים
לתפקיד מסוים.

267
00:12:08,260 --> 00:12:11,150
אז אולי לא אכפת לך
על הבאים 10 הבתים.

268
00:12:11,150 --> 00:12:12,880
אתה רק רוצה לדלג קדימה.

269
00:12:12,880 --> 00:12:14,030
לא אכפת לך על אלה.

270
00:12:14,030 --> 00:12:16,280
אתה רוצה לקרוא החל בייט 11.

271
00:12:16,280 --> 00:12:18,252
fseek מאפשר לך לעשות את זה.

272
00:12:18,252 --> 00:12:20,710
אז זה מאפשר לך להיות בררן
על מה שאתה קורא.

273
00:12:20,710 --> 00:12:25,880
בגלל fgetc, fgets, וקריאה fread
ממקום מסוים בקובץ.

274
00:12:25,880 --> 00:12:27,260

275
00:12:27,260 --> 00:12:35,090
>> דרך לחשוב על זה היא אם זה
הוא הקובץ שלנו, כאשר אתה פותח אותו לראשונה,

276
00:12:35,090 --> 00:12:41,140
יש לך עמדה זו בקובץ
שמתחיל בתחילת.

277
00:12:41,140 --> 00:12:45,040
בכל פעם שאתה קורא
fgetc, fgetf, או fread,

278
00:12:45,040 --> 00:12:48,875
זה הולך להתחיל מ
סמן עמדה זו.

279
00:12:48,875 --> 00:12:51,340

280
00:12:51,340 --> 00:12:55,245
בואו נגיד שאתה רק רוצה לקרוא
נתח זה של זיכרון לכאן.

281
00:12:55,245 --> 00:12:56,300

282
00:12:56,300 --> 00:12:57,960
אתה לא יכול פשוט להתקשר.

283
00:12:57,960 --> 00:13:02,430
אתה צריך לחפש כאן
ולאחר מכן קרא משם

284
00:13:02,430 --> 00:13:06,540
או לקרוא, מקבל, או getc,
תלוי מה אתה רוצה.

285
00:13:06,540 --> 00:13:09,310
אז לחפש רק מאפשר לך
דלג על חלקים מזיכרון.

286
00:13:09,310 --> 00:13:11,590
וזה רק
דרך בה אתה יכול לדלג על דברים

287
00:13:11,590 --> 00:13:14,012
מבלי לקרוא אותם למאגר שלך.

288
00:13:14,012 --> 00:13:15,470
האם זה הגיוני לכולם?

289
00:13:15,470 --> 00:13:21,110

290
00:13:21,110 --> 00:13:24,780
>> ברור, שיש
הרבה here-- המקביל

291
00:13:24,780 --> 00:13:27,780
הניתוב מחדש של פלט, או הקלט שלנו,
יש לך לקרוא ולכתוב.

292
00:13:27,780 --> 00:13:31,800
רק אז fputc כותב
אופי לקובץ.

293
00:13:31,800 --> 00:13:33,655
fputs כותב קו.

294
00:13:33,655 --> 00:13:35,030

295
00:13:35,030 --> 00:13:37,420
Fprintf מדפיסה פלט בפורמט.

296
00:13:37,420 --> 00:13:41,190
אז אם יש לך כרטיסיות,
או שטח, או מה שלא.

297
00:13:41,190 --> 00:13:44,180
ולאחר מכן fwrite כותב כמה
מערך של בתים לקובץ.

298
00:13:44,180 --> 00:13:48,860
אז זה באותה הדרך
fwrite וfread הם מקבילים

299
00:13:48,860 --> 00:13:57,550
fgets opposites--, fputs, ו
אז המון fputc וfgetc--

300
00:13:57,550 --> 00:14:00,710
מטורף, דברים מהירים.

301
00:14:00,710 --> 00:14:05,300
>> רק סוג של לשמור handy-- זה
יהיה לך זמנים שונים

302
00:14:05,300 --> 00:14:08,680
שבו אולי אתה פשוט רוצה
תו אחד בכל פעם.

303
00:14:08,680 --> 00:14:09,890
אולי אתה רוצה כל קו.

304
00:14:09,890 --> 00:14:14,320
עם pset-- המילון שלך
וזה בשתי psets,

305
00:14:14,320 --> 00:14:19,690
אני מאמין, אנחנו נותנים לכם את כל
מילון בפורמט טקסט

306
00:14:19,690 --> 00:14:22,252
בה לכל מילה
מופרד על ידי קו.

307
00:14:22,252 --> 00:14:24,210
אז אם אתם רוצים לקרוא
במילה אחת בכל פעם,

308
00:14:24,210 --> 00:14:31,769
מה שאתה יכול להשתמש אם אתה קורא
והם כולם מופרדים על קווים חדשים,

309
00:14:31,769 --> 00:14:33,310
ואתה רק רוצה מילה אחת בכל פעם?

310
00:14:33,310 --> 00:14:35,320

311
00:14:35,320 --> 00:14:36,040
>> קהל: fgets

312
00:14:36,040 --> 00:14:36,748
>> 1 SPEAKER: נכון.

313
00:14:36,748 --> 00:14:39,960
Fgets-- כי חוזר
כל מה שעל קו אחד.

314
00:14:39,960 --> 00:14:42,750
ואם כל מילה היא
קו עצמו, אנחנו יכולים להשתמש בfgets.

315
00:14:42,750 --> 00:14:44,511

316
00:14:44,511 --> 00:14:45,010
מגניב.

317
00:14:45,010 --> 00:14:47,290
האם זה הגיוני, כולם?

318
00:14:47,290 --> 00:14:48,020
מגניב?

319
00:14:48,020 --> 00:14:50,020
כן, אנחנו הולכים להגיע ל
החלק המהנה עם מצביעים

320
00:14:50,020 --> 00:14:51,728
בקרוב מאוד, שבו אתה
לקבל לעשות קצת מתמטיקה.

321
00:14:51,728 --> 00:14:52,776
וזה יהיה נהדר.

322
00:14:52,776 --> 00:14:55,690

323
00:14:55,690 --> 00:14:57,740
>> אחרון step-- לסגור את הקובץ שלך.

324
00:14:57,740 --> 00:15:01,090
עם כל כך הרבה דברים כאן,
אחד מפרדיגמות שלנו

325
00:15:01,090 --> 00:15:03,550
הוא אם הוא יכול לחזור
null, לבדוק null.

326
00:15:03,550 --> 00:15:06,160
אם אתה פותח משהו,
כדאי שתסגור אותו.

327
00:15:06,160 --> 00:15:10,419
אוקיי, אז אתה לא עשית עד שאתה
נעשה אלא אם כן סגר אותו.

328
00:15:10,419 --> 00:15:12,585
כמו סוג של זה לא נגמר
עד שגברת השמנת שרה.

329
00:15:12,585 --> 00:15:14,130
זה כמו לסגור את הקובץ שלך.

330
00:15:14,130 --> 00:15:16,860

331
00:15:16,860 --> 00:15:19,190
כפי שהוא אומר כאן, רק
לחזור ולהדגיש, תמיד

332
00:15:19,190 --> 00:15:21,750
לפתוח הקובץ שלך לפני שאתה
קריאה או כתיבה אליו.

333
00:15:21,750 --> 00:15:24,450
ותמיד לסגור אותו אם אתה שפתחת אותו.

334
00:15:24,450 --> 00:15:25,460
בסדר?

335
00:15:25,460 --> 00:15:25,960
מגניב.

336
00:15:25,960 --> 00:15:26,835
>> אז הנה דוגמא.

337
00:15:26,835 --> 00:15:29,250

338
00:15:29,250 --> 00:15:34,330
אז tiny-- אני לא יודע אם אתה
אתם יכולים לראות את זה טוב מאוד.

339
00:15:34,330 --> 00:15:36,805
אם רק היינו יכולים להגדיל
הבהירות איכשהו.

340
00:15:36,805 --> 00:15:40,430

341
00:15:40,430 --> 00:15:45,030
תן לי באמת לעשות את זה, אם אני יכול.

342
00:15:45,030 --> 00:15:48,020

343
00:15:48,020 --> 00:15:51,470
אישור, אתם לא באמת יכולים
רואה שבכלל, אתה יכול?

344
00:15:51,470 --> 00:15:52,905
בסדר, אנחנו הולכים לעשות את זה, אז.

345
00:15:52,905 --> 00:16:35,094

346
00:16:35,094 --> 00:16:35,594
[לא ברור]

347
00:16:35,594 --> 00:16:56,670

348
00:16:56,670 --> 00:16:58,605
>> אני מניח שזה הרבה יותר טוב לראות.

349
00:16:58,605 --> 00:17:17,330

350
00:17:17,330 --> 00:17:19,455
כל אחד יכול לראות בי
העכבר הלך היא השאלה?

351
00:17:19,455 --> 00:17:22,837
אה, הנה זה is-- מה נאבק!

352
00:17:22,837 --> 00:17:48,910

353
00:17:48,910 --> 00:17:49,520
>> אישור.

354
00:17:49,520 --> 00:17:53,845
בעיקרון, אתם צריכים להיות סוג
של מושג מה זה עושה.

355
00:17:53,845 --> 00:17:56,740

356
00:17:56,740 --> 00:17:57,600
זה לא מושלם.

357
00:17:57,600 --> 00:17:58,851

358
00:17:58,851 --> 00:18:02,425
אבל אני מעדיף להסביר את זה יותר מאשר לבלות
יותר זמן בניסיון לעצב אותו כמו שצריך.

359
00:18:02,425 --> 00:18:03,610

360
00:18:03,610 --> 00:18:07,280
בעיקרון, כפי שאתה רואה כאן,
אנחנו מתחילים עם פתיחת קובץ.

361
00:18:07,280 --> 00:18:09,620
ויש לנו כמה
קובץ מסד נתונים שאנחנו

362
00:18:09,620 --> 00:18:12,300
פתיחה שאומרת שזה לתלמידים שלנו.

363
00:18:12,300 --> 00:18:14,020
ואנחנו הולכים לכתוב את זה.

364
00:18:14,020 --> 00:18:15,060

365
00:18:15,060 --> 00:18:17,720
אז כמובן, תחזיר null.

366
00:18:17,720 --> 00:18:19,650
אז אנחנו צריכים לבדוק null.

367
00:18:19,650 --> 00:18:22,930
ואז אם זה לא
null, שאנחנו עוברים.

368
00:18:22,930 --> 00:18:25,660
וכמו שאתה רואה, אנחנו
לולאה דרך כאן.

369
00:18:25,660 --> 00:18:26,960
יש תלמידים.

370
00:18:26,960 --> 00:18:30,520
סטודנטים הוא החשיש המוגדר כשלוש.

371
00:18:30,520 --> 00:18:34,060
ומה שאנחנו עושים הם שאנחנו
הדפסה לקובץ, נכון?

372
00:18:34,060 --> 00:18:36,975
אז מה אנחנו מדפיסים לקובץ שלנו?

373
00:18:36,975 --> 00:18:47,040

374
00:18:47,040 --> 00:18:48,906
>> קהל: הציונים
שנמצאים במערך?

375
00:18:48,906 --> 00:18:49,680
>> 1 SPEAKER: כן.

376
00:18:49,680 --> 00:18:50,980
הציונים שנמצאים ב
array-- בדיוק.

377
00:18:50,980 --> 00:18:53,050
אז אנחנו פותחים את זה
קובץ מסד הנתונים, ש

378
00:18:53,050 --> 00:18:56,040
אני מניח שהוא סוג מסוים
של מסד נתוני ציונים.

379
00:18:56,040 --> 00:19:01,100
ואנחנו רק הדפסנו את
ציונים של כל תלמיד לקובץ ש.

380
00:19:01,100 --> 00:19:02,140
מגניב?

381
00:19:02,140 --> 00:19:02,640
טוב.

382
00:19:02,640 --> 00:19:03,811

383
00:19:03,811 --> 00:19:04,310
מדהים.

384
00:19:04,310 --> 00:19:05,100
אישור.

385
00:19:05,100 --> 00:19:06,950
בואו נחזור to--

386
00:19:06,950 --> 00:19:08,646
>> קהל: יש לי שאלה מהירה.

387
00:19:08,646 --> 00:19:11,570
האם printf לא ללולאה?

388
00:19:11,570 --> 00:19:12,870
זה רק באם הלולאה?

389
00:19:12,870 --> 00:19:14,370
1 דובר: לא, זה ללולאה.

390
00:19:14,370 --> 00:19:16,150

391
00:19:16,150 --> 00:19:18,810
אני לא יכול לראות את העכבר שלי טוב מאוד עד כאן.

392
00:19:18,810 --> 00:19:21,359
אז אני נאבק ל
פורמט שצריך.

393
00:19:21,359 --> 00:19:22,525
הסוגר זה צריך להיות נעלם.

394
00:19:22,525 --> 00:19:23,610

395
00:19:23,610 --> 00:19:25,130
זה צריך להיות כאן למטה.

396
00:19:25,130 --> 00:19:26,605
זה מה שהוא בך ללולאה.

397
00:19:26,605 --> 00:20:10,680

398
00:20:10,680 --> 00:20:11,180
יש.

399
00:20:11,180 --> 00:20:12,160
עכשיו זה די.

400
00:20:12,160 --> 00:20:16,720
אז ככה זה צריך be-- חוץ
שלסוגר האחרון שפטרתי.

401
00:20:16,720 --> 00:20:17,220
אישור.

402
00:20:17,220 --> 00:20:19,491
האם זה הגיוני לכולם?

403
00:20:19,491 --> 00:20:19,990
אישור.

404
00:20:19,990 --> 00:20:23,750
אנחנו הולכים לעבור
לדבר הבא then--

405
00:20:23,750 --> 00:20:26,180
אשר, למעשה, שאתה הולך
לצריך לראות את הקוד.

406
00:20:26,180 --> 00:20:28,370
אז אני פשוט הולך
להעתיק שמעל עכשיו.

407
00:20:28,370 --> 00:20:31,500

408
00:20:31,500 --> 00:20:32,000
אישור.

409
00:20:32,000 --> 00:20:35,110
אז אני הולך להראות לכם את הקוד הזה.

410
00:20:35,110 --> 00:20:38,240
ואני רוצה שתנסה ודמות
את מה שהיא אמורה לעשות.

411
00:20:38,240 --> 00:20:49,740

412
00:20:49,740 --> 00:20:52,480
>> אז נתן that-- לקחת דקה או כך.

413
00:20:52,480 --> 00:20:54,440
נסה להבין מה קורה כאן.

414
00:20:54,440 --> 00:21:58,840

415
00:21:58,840 --> 00:21:59,570
>> יש לך רעיונות?

416
00:21:59,570 --> 00:22:08,180

417
00:22:08,180 --> 00:22:12,470
>> אנחנו יודעים שיש לנו לפחות שני
טיעונים בשורת הפקודה, נכון?

418
00:22:12,470 --> 00:22:16,270
אני מניח שאחד מהם הולך להיות
ש[ לא ברור] של התכנית שלנו היא

419
00:22:16,270 --> 00:22:17,530
ואז משהו אחר.

420
00:22:17,530 --> 00:22:19,980
כי אם [לא ברור] הוא פחות
משני, שצועקים עליהם.

421
00:22:19,980 --> 00:22:21,140
נכון?

422
00:22:21,140 --> 00:22:25,300
ומן השימוש, זה נראה כמו
זה הולך להיות סוג של קובץ.

423
00:22:25,300 --> 00:22:26,260
כולנו מסכימים לזה?

424
00:22:26,260 --> 00:22:29,110

425
00:22:29,110 --> 00:22:31,570
אז עכשיו, מה הלולאה עושה?

426
00:22:31,570 --> 00:22:32,570
מה זה עובר?

427
00:22:32,570 --> 00:22:35,000

428
00:22:35,000 --> 00:22:36,449
>> קהל: כל הקבצים.

429
00:22:36,449 --> 00:22:37,240
1 SPEAKER: בדיוק.

430
00:22:37,240 --> 00:22:39,650
זה עובר את כל
קבצים שיש לנו קלט יש.

431
00:22:39,650 --> 00:22:40,720

432
00:22:40,720 --> 00:22:46,040
אז עבור כל קובץ, זה
פתיחה כמה מחרוזת שם.

433
00:22:46,040 --> 00:22:47,560
הוא נפתח קובץ ש.

434
00:22:47,560 --> 00:22:48,060
נכון?

435
00:22:48,060 --> 00:22:49,140

436
00:22:49,140 --> 00:22:52,380
וזה לקרוא ממנו.

437
00:22:52,380 --> 00:22:53,420

438
00:22:53,420 --> 00:22:55,540
כמובן, לבדוק אם זה null.

439
00:22:55,540 --> 00:22:57,220
ואז הוא מדפיס.

440
00:22:57,220 --> 00:23:01,460
אם זה null, זה פשוט אומר לנו
כי זה לא שקובץ קיים.

441
00:23:01,460 --> 00:23:04,290
כי תזכור, עם
לקרוא הקבצים שלנו צריך להתקיים.

442
00:23:04,290 --> 00:23:04,810
נכון?

443
00:23:04,810 --> 00:23:06,870
עם כתיבה וצרף,
אתה יכול לצאת מזה.

444
00:23:06,870 --> 00:23:08,970
אבל עם קריאה, הקובץ שלנו צריך להתקיים.

445
00:23:08,970 --> 00:23:10,430

446
00:23:10,430 --> 00:23:13,330
>> ולאחר מכן אם הוא קיים,
מה אנחנו עושים כאן?

447
00:23:13,330 --> 00:23:14,810

448
00:23:14,810 --> 00:23:15,780
בואו נתחיל כאן.

449
00:23:15,780 --> 00:23:18,815
מה זה do-- תו ראשון זה.

450
00:23:18,815 --> 00:23:20,960

451
00:23:20,960 --> 00:23:21,790
מה זה עושה?

452
00:23:21,790 --> 00:23:24,100
הוא מקבל תו אחד, נכון?

453
00:23:24,100 --> 00:23:25,400
אז מה הוא עושה את זה?

454
00:23:25,400 --> 00:23:26,775
זה מתחיל להיות התו הראשון.

455
00:23:26,775 --> 00:23:28,860

456
00:23:28,860 --> 00:23:30,200
מישהו יודע EOF?

457
00:23:30,200 --> 00:23:31,170
>> קהל: סופו של קובץ?

458
00:23:31,170 --> 00:23:32,680
>> SPEAKER 1: סוף file-- בדיוק.

459
00:23:32,680 --> 00:23:35,310
כך שזה הולך לעבור
את הקובץ כולו, נכון?

460
00:23:35,310 --> 00:23:36,710

461
00:23:36,710 --> 00:23:40,780
ואז זה הולך לעדכן על ידי
מקבל כל תו שלאחר מכן.

462
00:23:40,780 --> 00:23:41,565
נכון?

463
00:23:41,565 --> 00:23:43,636
ומה הוא עושה?

464
00:23:43,636 --> 00:23:44,760
קהל: לשים שin--

465
00:23:44,760 --> 00:23:46,741

466
00:23:46,741 --> 00:23:49,170
>> 1 SPEAKER: הדפסי Putchar
לשומר המסך שלך.

467
00:23:49,170 --> 00:23:50,867

468
00:23:50,867 --> 00:23:51,950
[לא ברור] האופי.

469
00:23:51,950 --> 00:23:54,300
ואז כשזה [לא ברור]
זה יהיה לסגור את התיק.

470
00:23:54,300 --> 00:23:57,370
>> קהל: האם אתה לא צריך [? ? אחר ?]

471
00:23:57,370 --> 00:23:59,005
>> 1 SPEAKER: לא בהכרח.

472
00:23:59,005 --> 00:24:01,480
אני מתכוון, זה משתמע סוג של בזה.

473
00:24:01,480 --> 00:24:06,780
בגלל זה אף חוזר,, כל עוד
כזה לא תופס את זה, אתה בסדר.

474
00:24:06,780 --> 00:24:07,940

475
00:24:07,940 --> 00:24:10,250
אני מתכוון שזה כנראה טוב
להתאמן כדי לעשות אחר.

476
00:24:10,250 --> 00:24:15,755
אבל דבר אחר הוא לא תמיד
נחוץ במיוחד

477
00:24:15,755 --> 00:24:17,610
אם יש לך משהו
כמו שיבה, ש

478
00:24:17,610 --> 00:24:20,640
משמעות הדבר היא כי במקרה זה, אם זה תופס
זה, התכנית שלך הולכת להיגמר

479
00:24:20,640 --> 00:24:21,850
וזה אף פעם לא יגיע לזה.

480
00:24:21,850 --> 00:24:23,030

481
00:24:23,030 --> 00:24:29,190
זה יותר למקרה שבו אתה
לא בהכרח חוזר משהו.

482
00:24:29,190 --> 00:24:31,370
כי אם זה לא היה
חוזר כל דבר,

483
00:24:31,370 --> 00:24:34,430
זה אומר שאם זה היה נכון,
שאר זה עדיין ירוץ.

484
00:24:34,430 --> 00:24:36,138
ובמקרה כזה, אתה
היה רוצה שווא.

485
00:24:36,138 --> 00:24:38,240
אם זה חוזר, ו
הסיום של התכנית שלך,

486
00:24:38,240 --> 00:24:41,960
אחר אין צורך בכל
הזמן, תלוי בהקשר.

487
00:24:41,960 --> 00:24:43,084

488
00:24:43,084 --> 00:24:44,375
יעקב, שיש לך שאלה?

489
00:24:44,375 --> 00:24:46,100
קהל: כן.

490
00:24:46,100 --> 00:24:49,300
כך גם fgetc לקבל את התו הבא?

491
00:24:49,300 --> 00:24:50,734
איך האופי אין להגדיל?

492
00:24:50,734 --> 00:24:51,400
1 SPEAKER: כן.

493
00:24:51,400 --> 00:24:52,774
אז fgetc מקבל את התו הבא.

494
00:24:52,774 --> 00:24:54,140

495
00:24:54,140 --> 00:24:56,866
אתה יכול לחשוב על זה כמו C ++ במובן מסוים.

496
00:24:56,866 --> 00:24:58,350
>> קהל: אז מה היה EOF?

497
00:24:58,350 --> 00:25:00,877
>> 1 SPEAKER: EOF זה סופו של קובץ.

498
00:25:00,877 --> 00:25:03,960
זה רק סמן שמאפשר לך לדעת
כי אתה בסופו של הקובץ שלך.

499
00:25:03,960 --> 00:25:06,742
אז זה הולך להדפיס
לפלט הסטנדרטי שלך.

500
00:25:06,742 --> 00:25:08,950
ואז זה הולך לסגור
הקובץ כאשר זה נעשה.

501
00:25:08,950 --> 00:25:10,700
ואז בואו נלך ל
הקובץ הבא, נכון?

502
00:25:10,700 --> 00:25:12,660
כך שבסך הכול, מה התכנית הזאת עושה?

503
00:25:12,660 --> 00:25:15,402

504
00:25:15,402 --> 00:25:16,090
>> [לא ברור]

505
00:25:16,090 --> 00:25:16,900
>> 1 SPEAKER: כן.

506
00:25:16,900 --> 00:25:18,770
זה פשוט מדפיס את כל מה שיש.

507
00:25:18,770 --> 00:25:23,270
אז CAT אם אי פעם בחורים השתמשו
ולאחר מכן את השם של חלק file--

508
00:25:23,270 --> 00:25:26,240
אני לא יודע אם מישהו מכם יש לי
אי פעם עשה את זה על המסוף שלך.

509
00:25:26,240 --> 00:25:29,630
אבל אם אי פעם להשתמש ב
פקודת CAT-- C-A-T--

510
00:25:29,630 --> 00:25:31,880
ולאחר מכן כל מה שקובץ
יש לך there-- זה

511
00:25:31,880 --> 00:25:37,260
מדפיס את זה למסוף שלך, ש
יכול להיות סופר שימושי לכמה דברים.

512
00:25:37,260 --> 00:25:38,746
אני משתמש בו הרבה.

513
00:25:38,746 --> 00:25:40,120
האם זה הגיוני לכולם?

514
00:25:40,120 --> 00:25:41,480

515
00:25:41,480 --> 00:25:42,100
מגניב?

516
00:25:42,100 --> 00:25:46,530
>> אישור אז המשימה שלך now-- או על ידי
בעצמך או עם האנשים סביב you--

517
00:25:46,530 --> 00:25:54,930
רק כדי לכתוב תכנית פשוטה
שפשוט יכתוב "שלום, עולם!"

518
00:25:54,930 --> 00:25:56,255
לקובץ.

519
00:25:56,255 --> 00:26:00,215
>> [לא ברור]

520
00:26:00,215 --> 00:26:56,210

521
00:26:56,210 --> 00:26:57,040
>> [לא ברור]

522
00:26:57,040 --> 00:26:59,248
>> 1 SPEAKER: הייתי כמו, עשה
אני עושה את זה בשבוע שקשה שעבר?

523
00:26:59,248 --> 00:27:00,201

524
00:27:00,201 --> 00:27:01,492
אני לא חושב שזה היה כל כך נורא.

525
00:27:01,492 --> 00:27:02,479

526
00:27:02,479 --> 00:27:03,520
אני שמח שאתה כאן.

527
00:27:03,520 --> 00:27:04,655
זה באמת גורם לי אושר.

528
00:27:04,655 --> 00:27:07,565

529
00:27:07,565 --> 00:27:10,160
אני בחורה של הנאות פשוטות.

530
00:27:10,160 --> 00:27:11,688
אני פשוט אוהב כאשר הסעיף שלי לומד.

531
00:27:11,688 --> 00:27:13,830

532
00:27:13,830 --> 00:27:18,270
אז אני פשוט מקבל את זה התחיל ל
אתם כל כך שאנחנו יכולים קוד ביחד.

533
00:27:18,270 --> 00:27:22,290
אני לא אוהב לשים מישהו ב
המקום אלא אם כן אתה רוצה להיות.

534
00:27:22,290 --> 00:27:26,486

535
00:27:26,486 --> 00:27:30,086
>> קהל: לחידון, לעשות
יש לנו לכתוב תכנית?

536
00:27:30,086 --> 00:27:33,260
>> 1 SPEAKER: ייתכן שתתבקש ל
לכתוב תוכניות פשוטות ביד.

537
00:27:33,260 --> 00:27:35,940

538
00:27:35,940 --> 00:27:36,590
כן.

539
00:27:36,590 --> 00:27:38,510
>> קהל: החידון הוא בשבוע הבא, נכון?

540
00:27:38,510 --> 00:27:40,108
>> 1 SPEAKER: החידון הוא ביום רביעי הבא.

541
00:27:40,108 --> 00:27:40,855

542
00:27:40,855 --> 00:27:43,730
זה אומר שיש [יפה? מנוע חיפוש מותאם אישית?]
דירוג מסיבה שלאחר מכן, ש

543
00:27:43,730 --> 00:27:50,390
כלומר, תקבל את הניקוד שלך
בחזרה שnight-- באיזו שעה?

544
00:27:50,390 --> 00:27:50,890
מי יודע?

545
00:27:50,890 --> 00:27:51,973
אבל זה יהיה באותו הלילה.

546
00:27:51,973 --> 00:28:02,020

547
00:28:02,020 --> 00:28:02,855
>> בְּסֵדֶר.

548
00:28:02,855 --> 00:28:04,250
איך אנחנו רוצים להתחיל את זה?

549
00:28:04,250 --> 00:28:07,964

550
00:28:07,964 --> 00:28:09,630
אני אתן לך מתחיל hint-- עם זה.

551
00:28:09,630 --> 00:28:11,455
>> קהל: אתה צריך לפתוח את קובץ.

552
00:28:11,455 --> 00:28:12,250
>> 1 SPEAKER: כן.

553
00:28:12,250 --> 00:28:14,060
אז מה אתה רוצה לקרוא לזה?

554
00:28:14,060 --> 00:28:16,150
האם אתה רק רוצה לקרוא לזה "קובץ"?

555
00:28:16,150 --> 00:28:17,480
בואו נעשה את זה קל.

556
00:28:17,480 --> 00:28:26,752
אז fopen-- מה
מבחן תפוקה הולך להיות?

557
00:28:26,752 --> 00:28:36,130
קורא לזה "שלום".

558
00:28:36,130 --> 00:28:37,810
ומה המצב שלנו?

559
00:28:37,810 --> 00:28:39,764

560
00:28:39,764 --> 00:28:41,055
מה שאנחנו עושים בקובץ זה?

561
00:28:41,055 --> 00:28:42,676

562
00:28:42,676 --> 00:28:43,500
>> קהל: קרא.

563
00:28:43,500 --> 00:28:44,401

564
00:28:44,401 --> 00:28:44,900
כתיבה.

565
00:28:44,900 --> 00:28:46,191
1 SPEAKER: אנו כותבים אליו.

566
00:28:46,191 --> 00:28:47,360

567
00:28:47,360 --> 00:28:47,860
יפה.

568
00:28:47,860 --> 00:28:50,330

569
00:28:50,330 --> 00:28:52,860
אוקיי, אז יש לנו את הקובץ עכשיו.

570
00:28:52,860 --> 00:28:54,920

571
00:28:54,920 --> 00:28:56,212
מה אנחנו צריכים לעשות?

572
00:28:56,212 --> 00:28:57,420
קהל: בדוק אם זה null.

573
00:28:57,420 --> 00:28:59,820
1 SPEAKER: בדוק אם זה null-- בדיוק.

574
00:28:59,820 --> 00:29:01,980
זה מה שאני רוצה לשמוע.

575
00:29:01,980 --> 00:29:05,930
זה צריך להיות אוטומטי, במיוחד
פחות או יותר מנקודה זו והלאה.

576
00:29:05,930 --> 00:29:07,530

577
00:29:07,530 --> 00:29:10,950
אם אתה מתחיל segfaulting, אתה כנראה
לא בדקתי לnull איפשהו.

578
00:29:10,950 --> 00:29:12,480
תשע פעמים מתוך עשר, זה
הולך להיות השגיאה שלך.

579
00:29:12,480 --> 00:29:15,400
אז אם אתה יכול פשוט לקבל ב
הרגל, תמיד לבדוק אם זה null,

580
00:29:15,400 --> 00:29:18,150
החיים שלך הולך להיות
נחמד וeasy-- או קל יותר.

581
00:29:18,150 --> 00:29:19,480
>> אז לבדוק כדי לראות אם זה null.

582
00:29:19,480 --> 00:29:21,200

583
00:29:21,200 --> 00:29:24,820
אז אם זה לא ריק, ש
מה שווה את התמורה

584
00:29:24,820 --> 00:29:26,784
means-- לא null-- זה תקף.

585
00:29:26,784 --> 00:29:27,700
מה אנחנו רוצים לעשות?

586
00:29:27,700 --> 00:29:29,750

587
00:29:29,750 --> 00:29:31,570
אנחנו רק רוצים להדפיס
בקובץ זה, נכון?

588
00:29:31,570 --> 00:29:32,923
אז מה אנחנו הולכים להשתמש?

589
00:29:32,923 --> 00:29:34,092
>> קהל: fprintf

590
00:29:34,092 --> 00:29:36,800
>> SPEAKER 1: יפה Fprintf--.

591
00:29:36,800 --> 00:29:38,150

592
00:29:38,150 --> 00:29:44,000
וfprintf לוקחת שתי arguments-- בי
זה הולך ומה אנחנו רוצים להדפיס.

593
00:29:44,000 --> 00:29:45,820
אז מה, לא?

594
00:29:45,820 --> 00:29:46,570
איפה זה הולך?

595
00:29:46,570 --> 00:29:47,490
>> קהל: קובץ.

596
00:29:47,490 --> 00:29:48,785
>> 1 SPEAKER: זה הולך להגיש.

597
00:29:48,785 --> 00:29:49,784

598
00:29:49,784 --> 00:29:50,950
ומה אנחנו רוצים מודפסים?

599
00:29:50,950 --> 00:29:52,900

600
00:29:52,900 --> 00:29:58,065
"שלום, עולם!"

601
00:29:58,065 --> 00:29:58,565
בְּסֵדֶר.

602
00:29:58,565 --> 00:30:03,670
יש לנו thing-- האחרון
עוד הפרדיגמה גדולה כאן.

603
00:30:03,670 --> 00:30:04,479

604
00:30:04,479 --> 00:30:05,145
קהל: לסגור.

605
00:30:05,145 --> 00:30:05,853
SPEAKER 1: סגור.

606
00:30:05,853 --> 00:30:09,990

607
00:30:09,990 --> 00:30:10,540
הנה לך.

608
00:30:10,540 --> 00:30:13,384
>> קהל: האם זה קורה
אם הקובץ הוא null?

609
00:30:13,384 --> 00:30:15,050
1 דובר: לא, זה אם זה לא ריק.

610
00:30:15,050 --> 00:30:16,881
קהל: אה, אם זה not-- אישור.

611
00:30:16,881 --> 00:30:21,728

612
00:30:21,728 --> 00:30:25,410
לfopen ולאחר מכן
שני טיעונים שייכנסו פנימה,

613
00:30:25,410 --> 00:30:27,655
מה הטענה הראשונה אומרת שוב?

614
00:30:27,655 --> 00:30:30,392
>> SPEAKER 1: הטענה היא
בדיוק כמו השם של הקובץ

615
00:30:30,392 --> 00:30:31,350
שאתה רוצה ללכת ל.

616
00:30:31,350 --> 00:30:36,020
אז אחרי זה פועל, שהיית
יש לי כמה קבצים בשם "שלום"

617
00:30:36,020 --> 00:30:38,320
ש" שלום, עולם "בתוכו.

618
00:30:38,320 --> 00:30:38,820
זה כל מה ש.

619
00:30:38,820 --> 00:30:39,500
רק שם.

620
00:30:39,500 --> 00:30:42,685

621
00:30:42,685 --> 00:30:48,650
>> קהל: ומכיוון שזה כתיבה,
קובץ לא צריך כבר קיים.

622
00:30:48,650 --> 00:30:49,675
האם זה מה שאמר?

623
00:30:49,675 --> 00:30:50,410
>> 1 SPEAKER: נכון.

624
00:30:50,410 --> 00:30:50,910
בדיוק.

625
00:30:50,910 --> 00:30:53,110

626
00:30:53,110 --> 00:30:55,839
אם "שלום" כקובץ
לא קיים עדיין, זה

627
00:30:55,839 --> 00:30:58,380
הולך ליצור קובץ בשם
שלום "ולכתוב את זה בשבילך.

628
00:30:58,380 --> 00:30:59,631

629
00:30:59,631 --> 00:31:03,610
>> קהל: כאשר אתה אומר לי
התכנית לכתבה לקובץ,

630
00:31:03,610 --> 00:31:08,075
למה אתה כותב "קובץ" במקום
את שמו של הקובץ וfprintf--

631
00:31:08,075 --> 00:31:13,600
>> 1 SPEAKER: כי במקרה הזה, יש לנו
שFILE-- הגדול כל בכוכב caps--,

632
00:31:13,600 --> 00:31:14,260
להגיש.

633
00:31:14,260 --> 00:31:17,370
אז זה מצביע לקובץ
על זה אתה מדבר.

634
00:31:17,370 --> 00:31:19,930
זוהי הדרך ש
רק אנו מתייחסים אליו.

635
00:31:19,930 --> 00:31:24,850
אז במקרה הזה, אתה
יכול לחשוב על אהה file--,

636
00:31:24,850 --> 00:31:31,271
אנו יכולים להשתמש בזה-- קובץ כאן
מתייחס לפתיחה של "שלום"

637
00:31:31,271 --> 00:31:32,145
ולתת לה לכתוב.

638
00:31:32,145 --> 00:31:34,728
>> קהל: האם אנו יכולים לשים את "שלום"
במקום [? רק? קובץ] f?

639
00:31:34,728 --> 00:31:40,160
1 דובר: לא, כי "שלום"
צריך להיות פתוח וניתן לכתיבה.

640
00:31:40,160 --> 00:31:41,820

641
00:31:41,820 --> 00:31:45,980
קובץ כאן הוא כמו
ציין שאומר בסדר, אנחנו

642
00:31:45,980 --> 00:31:49,190
יש לי hello-- file-- זה
שאנחנו מסתכלים.

643
00:31:49,190 --> 00:31:50,680
זה כבר נפתח.

644
00:31:50,680 --> 00:31:52,140
ואנחנו הולכים לכתוב את זה.

645
00:31:52,140 --> 00:31:55,130
אם אתה פשוט להשתמש "שלום",
שמגולם בזה.

646
00:31:55,130 --> 00:31:56,846
אז זה הולך להתחרפן.

647
00:31:56,846 --> 00:31:58,590

648
00:31:58,590 --> 00:32:00,300
אני מתכוון, אתה יכולת לקרוא לזה.

649
00:32:00,300 --> 00:32:03,960
אתה יכול לעשות את הקובץ,
כוכב, "הלו", שווה לזה.

650
00:32:03,960 --> 00:32:07,840
אבל כל העניין הוא שאתה
צריך מצביע כוכב קובץ על מנת

651
00:32:07,840 --> 00:32:09,281
כדי להיות מסוגל להשתמש בפונקציות אלה.

652
00:32:09,281 --> 00:32:11,280
קהל: אתה יכול לעשות
קובץ, כוכב, קובץ, "הלו"

653
00:32:11,280 --> 00:32:13,113
או שאתה צריך לשים את
קובץ כוכב, קובץ על-ידי אותו?

654
00:32:13,113 --> 00:32:16,330
SPEAKER 1: אתה יכול
לעשות קובץ, כוכב, "הלו".

655
00:32:16,330 --> 00:32:19,790
אתה יכול לשנות את זה ל
כל שם שאתה רוצה.

656
00:32:19,790 --> 00:32:22,114
זה שרירותי לחלוטין
מה השם שהוא.

657
00:32:22,114 --> 00:32:23,179

658
00:32:23,179 --> 00:32:24,220
אתה יכול שם זה שום דבר.

659
00:32:24,220 --> 00:32:25,501

660
00:32:25,501 --> 00:32:28,020
שם זה עף ספגטי, אם אתה רוצה.

661
00:32:28,020 --> 00:32:29,690
>> קהל: מהו "w" בציטוטים?

662
00:32:29,690 --> 00:32:31,540
>> 1 דובר: "w" הוא פשוט המצב.

663
00:32:31,540 --> 00:32:33,170
אז אנחנו כותבים בקובץ זה.

664
00:32:33,170 --> 00:32:34,410

665
00:32:34,410 --> 00:32:35,320
כולם טובים?

666
00:32:35,320 --> 00:32:36,227
ברור?

667
00:32:36,227 --> 00:32:36,981
כן.

668
00:32:36,981 --> 00:32:40,365
>> קהל: אז כשזה כותב את זה
קובץ, שבו אנחנו לאחר מכן מוצאים את הקובץ הזה?

669
00:32:40,365 --> 00:32:43,820
>> 1 SPEAKER: זה יהיה באותו
ספרייה שבה אתם נמצאים.

670
00:32:43,820 --> 00:32:45,650

671
00:32:45,650 --> 00:32:48,880
אם אתה בpset שלוש ו
אתה מפעיל את זה, בתוך pset שלך

672
00:32:48,880 --> 00:32:52,600
שלוש תיקייה הוא הולכת להיות
הקובץ הזה שנקרא "שלום".

673
00:32:52,600 --> 00:32:53,160
מגניב?

674
00:32:53,160 --> 00:32:53,757
כולם טובים?

675
00:32:53,757 --> 00:32:55,840
אני מרגיש כמו כולכם
מקבל את זה, וזה נהדר.

676
00:32:55,840 --> 00:32:57,290

677
00:32:57,290 --> 00:32:57,790
אישור.

678
00:32:57,790 --> 00:33:05,960
אז בחזרה לshow-- השקופיות שלי
אני אוהב כאשר דברים עובדים.

679
00:33:05,960 --> 00:33:08,674
אישור, pointers-- האם אתם מתרגשים?

680
00:33:08,674 --> 00:33:09,465
מצביעים הם גדולים.

681
00:33:09,465 --> 00:33:11,581

682
00:33:11,581 --> 00:33:13,580
הם לוקחים קצת
לעטוף את הראש סביב.

683
00:33:13,580 --> 00:33:15,288
זו השנה השנייה שלי
מצביעי הוראה.

684
00:33:15,288 --> 00:33:16,850
ואני חושב שסוף סוף יש לי את זה.

685
00:33:16,850 --> 00:33:18,650
אז אם אתה במאבק, שזה בסדר.

686
00:33:18,650 --> 00:33:19,940

687
00:33:19,940 --> 00:33:24,070
כפי שאמרתי קודם, ציור תמונות
עוזר הרבה עם דברים בCS,

688
00:33:24,070 --> 00:33:27,400
כמה שאני חושב שאנשים נוטים
לחשוב הו, אנחנו במחשב.

689
00:33:27,400 --> 00:33:28,399
אנחנו צריכים פשוט קוד.

690
00:33:28,399 --> 00:33:30,190
תמונות ציור No--
יהיה באמת לעזור לך.

691
00:33:30,190 --> 00:33:32,773
ואני באמת ממליץ לך
להתחבר לצד הילד בגן שלך

692
00:33:32,773 --> 00:33:35,010
ולהביא את העפרונות
או סמנים ותיקו.

693
00:33:35,010 --> 00:33:36,110
כי זה יעזור לך.

694
00:33:36,110 --> 00:33:39,380
ואם אתה רואה אותי בשעתי עבודה, אני
יהיה נושא סביב ערימות של נייר

695
00:33:39,380 --> 00:33:41,580
עם עטי ציור את הדברים.

696
00:33:41,580 --> 00:33:44,370
>> אז במיוחד עם
pointers-- לצייר תמונות.

697
00:33:44,370 --> 00:33:47,970
ואני בטוח שאנחנו באמת הולכים ל
להיות ציור כמה תמונות גם כאן.

698
00:33:47,970 --> 00:33:51,270
>> אז אתם כל זכיתם לראות בינקי,
דבר claymation מגניב.

699
00:33:51,270 --> 00:33:54,720
ואנחנו חושבים שזה ממש מצחיק כש
הוא מתפוצץ לתוך חבורה של חתיכות.

700
00:33:54,720 --> 00:33:56,280

701
00:33:56,280 --> 00:33:57,755
זה קצת אתנחתא קומית לכיתה.

702
00:33:57,755 --> 00:34:02,140

703
00:34:02,140 --> 00:34:05,900
[לא ברור] היכולת הגדולה הזה C
להיות מסוגל לשלוט בזיכרון.

704
00:34:05,900 --> 00:34:10,090
וזה אחד הדברים שבאמת
עושה את זה בשפה כזו חזקה.

705
00:34:10,090 --> 00:34:13,469
אבל עם כוח גדול מגיע
אחריות גדולה.

706
00:34:13,469 --> 00:34:16,230
ודברים מטורפים יכולים לקרות
אם אתה לא זהיר.

707
00:34:16,230 --> 00:34:18,560
לכן, כאשר אתה משתמש ב
מצביעים, אתה רוצה לעשות

708
00:34:18,560 --> 00:34:21,440
בטוח שאתה באמת מבין
בדיוק מה שאתה עושה.

709
00:34:21,440 --> 00:34:25,530
אני מקווה שקצת הבא של
הזמן יעזור לך להבין באמת

710
00:34:25,530 --> 00:34:27,850
מצביעים, כיצד להשתמש בם,
וכיצד לתפעל אותם.

711
00:34:27,850 --> 00:34:29,170

712
00:34:29,170 --> 00:34:33,460
>> אז memory-- אני בטוח שיש לנו
ראה תרשים זה לפני.

713
00:34:33,460 --> 00:34:38,540
כך שזה רק תרשים פשוט של
איך דברים יכולים להיות מאוחסנים בזיכרון.

714
00:34:38,540 --> 00:34:43,145
אז בעצם יש לך אלה
במערכים אדירים של לוקים בייט אחד

715
00:34:43,145 --> 00:34:46,000
זה מה שיש לנו here-- קל
תוספות שאחד בכל פעם.

716
00:34:46,000 --> 00:34:51,810
זה בhex [לא ברור]
כך שמונה סיביות בלוקים.

717
00:34:51,810 --> 00:34:55,510
וכל בלוק קשור
עם כמה כתובת הקסדצימלי.

718
00:34:55,510 --> 00:34:58,750
אז אם אי פעם תראה את
0x, שפשוט notating

719
00:34:58,750 --> 00:35:00,670
שזה כתובת הקסדצימלי.

720
00:35:00,670 --> 00:35:03,970
אתה יכול להניח שזה אומר
כמה כתובת בזיכרון.

721
00:35:03,970 --> 00:35:06,935
על כתובות זיכרון אנחנו מדברים
בכל פעם שאתה רואה הקסדצימלי.

722
00:35:06,935 --> 00:35:10,420

723
00:35:10,420 --> 00:35:14,630
>> יש לנו ints משתנה,
צף הם משתנים שמאחסנים.

724
00:35:14,630 --> 00:35:16,260
אז ints חנות ints.

725
00:35:16,260 --> 00:35:17,430
חנות צף צף.

726
00:35:17,430 --> 00:35:20,260
אז יש לנו גם מצביעים
שכתובות זיכרון חנות.

727
00:35:20,260 --> 00:35:21,660
זה סוג של מיפוי.

728
00:35:21,660 --> 00:35:24,240
מצביעים הם באופן בלעדי
לכתובות זיכרון.

729
00:35:24,240 --> 00:35:25,780

730
00:35:25,780 --> 00:35:27,292
אז זה כמו הסוג שלך יש.

731
00:35:27,292 --> 00:35:29,550

732
00:35:29,550 --> 00:35:34,470
המכשיר שלכם הוא 32 סיביות, מה שאומר ש
שכתובת הזיכרון שלך היא ארבעה בתים.

733
00:35:34,470 --> 00:35:37,830
אז כל מצביע שיש לך
גם הוא הולך להיות ארבעה בתים.

734
00:35:37,830 --> 00:35:43,200
או שמא אם זה ארבעה בתים,
זיכרון הוא ארבעה בתים.

735
00:35:43,200 --> 00:35:44,790
זיכרון חנות מצביעים.

736
00:35:44,790 --> 00:35:46,430
לכן, הם ארבעה בתים.

737
00:35:46,430 --> 00:35:48,460
Cool-- רק רוצה לחזק את זה.

738
00:35:48,460 --> 00:35:50,120

739
00:35:50,120 --> 00:35:52,220
>> אתה צריך לקבל קומיקס זה עכשיו.

740
00:35:52,220 --> 00:35:55,040
אני לא יודע כמה מכם
הם אוהדי xkcd, אבל אני אוהב את xkcd.

741
00:35:55,040 --> 00:35:55,780
זה נהדר.

742
00:35:55,780 --> 00:35:57,290

743
00:35:57,290 --> 00:35:57,790
>> בְּסֵדֶר.

744
00:35:57,790 --> 00:36:01,640
אז יצירת pointers-- כמו שאמרתי, זה
פחות או יותר בדיוק כמו כל דבר אחר.

745
00:36:01,640 --> 00:36:02,930
יש לך סוג.

746
00:36:02,930 --> 00:36:04,050
יש לך שם.

747
00:36:04,050 --> 00:36:04,810
נכון?

748
00:36:04,810 --> 00:36:10,410
זה מה שיש לנו שם.
[? Hex?] כוכב אומר שזה מצביע,

749
00:36:10,410 --> 00:36:12,250
ואז מה שאתה רוצה לקרוא לזה.

750
00:36:12,250 --> 00:36:15,770
אז הסוג מייצג
מה שאתה יכול לאחסן.

751
00:36:15,770 --> 00:36:16,850

752
00:36:16,850 --> 00:36:17,990
בסדר?

753
00:36:17,990 --> 00:36:24,350
באותו אופן שאם אנחנו עושים ints,
אנחנו יודעים שאנחנו אחסון int יש.

754
00:36:24,350 --> 00:36:25,990

755
00:36:25,990 --> 00:36:30,280
עם מצביע, זה
מחזיק כתובת זיכרון.

756
00:36:30,280 --> 00:36:34,240
אבל מה זה אומר הוא that-- הנה שבי
ציור הולך להיות שימושי.

757
00:36:34,240 --> 00:36:36,170

758
00:36:36,170 --> 00:36:45,980
אז במקרה הזה, יש לנו
כמה value-- נניח ארבעה.

759
00:36:45,980 --> 00:36:49,306
ארבעה הוא בכתובת אחת.

760
00:36:49,306 --> 00:36:49,805
בסדר?

761
00:36:49,805 --> 00:36:51,550

762
00:36:51,550 --> 00:36:56,170
>> ראשון זה כאן פירושו
שזה 2x מצביע.

763
00:36:56,170 --> 00:36:56,740
נכון?

764
00:36:56,740 --> 00:36:57,628
זה כמה x מצביע.

765
00:36:57,628 --> 00:36:58,852

766
00:36:58,852 --> 00:37:00,940
x יכול להיות משהו, לא משנה מה.

767
00:37:00,940 --> 00:37:01,960

768
00:37:01,960 --> 00:37:05,130
לא משנה מה x is-- אומר x הוא ארבעה.

769
00:37:05,130 --> 00:37:07,280
זה הולך לאחסון
כתובת זיכרון כאן.

770
00:37:07,280 --> 00:37:12,260
אז int, כוכב, x-- זה
כמה חריץ אחר בmemory--

771
00:37:12,260 --> 00:37:13,590
מי יודע מה זה.

772
00:37:13,590 --> 00:37:15,430
אבל זה הולך לאחסון כתובת כאן.

773
00:37:15,430 --> 00:37:27,040
אז זה יהיה like--
במקרה זה, לא משנה מה,

774
00:37:27,040 --> 00:37:32,630
מאוחסן ב0x1-- מה מאוחסן
בכתובת שהמצביע שלנו מחזיק,

775
00:37:32,630 --> 00:37:35,280
יש להתאים את עם
מה שמיועד.

776
00:37:35,280 --> 00:37:40,330
אז ב0x1, במקרה הזה, זה הוא x.

777
00:37:40,330 --> 00:37:42,500

778
00:37:42,500 --> 00:37:49,340
זה רק יכול אי פעם להיות
int בזמן שאנחנו משתמשים בזה.

779
00:37:49,340 --> 00:37:52,950
>> באופן דומה, אם יש לנו
1Y אחר, כל מה ש

780
00:37:52,950 --> 00:37:59,130
כתובת מאוחסנת עם y יש
להיות אותו דבר char-- עם z.

781
00:37:59,130 --> 00:38:05,840
באותו אופן, כל פעם שאתה
לנסות ולעשות intx שווה 0.4,

782
00:38:05,840 --> 00:38:09,275
זה הולך לצעוק עליך ולהיות
אין כמו, אתה אמר שאתה רוצה int.

783
00:38:09,275 --> 00:38:10,525
זה אמור להיות int.

784
00:38:10,525 --> 00:38:11,900
תפסיק לנסות להפוך אותו לצוף.

785
00:38:11,900 --> 00:38:14,150
>> אז לתת לדברים להיות מה שהם רוצים להיות.

786
00:38:14,150 --> 00:38:15,159

787
00:38:15,159 --> 00:38:16,200
לתת לדברים להיות הם עצמם.

788
00:38:16,200 --> 00:38:19,380

789
00:38:19,380 --> 00:38:23,450
אז דבר גדול הוא רק
כל סוג של מצביע

790
00:38:23,450 --> 00:38:26,101
זה, זה רק
דבר שאתה יכול לאחסן שם.

791
00:38:26,101 --> 00:38:26,600
בסדר?

792
00:38:26,600 --> 00:38:27,910

793
00:38:27,910 --> 00:38:31,160
בעזרת תרגול, כמו ב
בשבוע שעבר, כל מה ש

794
00:38:31,160 --> 00:38:32,817
נראה באמת סוג של המופשט.

795
00:38:32,817 --> 00:38:34,150
אנחנו הולכים לעשות קצת תרגול.

796
00:38:34,150 --> 00:38:36,760
זה צריך יותר הגיוני.

797
00:38:36,760 --> 00:38:44,580
>> אז התייחסות וdereferencing-- זה
באמת חשוב להגיע ישר אלה.

798
00:38:44,580 --> 00:38:46,630
אני עדיין צריך לרענן
מדי פעם.

799
00:38:46,630 --> 00:38:48,450
ואני כמו המתנה, אשר אחד אני רוצה?

800
00:38:48,450 --> 00:38:56,080
אז האמפרסנד בעצם ייתן לי
אתה ההתייחסות או הכתובת של.

801
00:38:56,080 --> 00:39:00,100
אז זה מחזיר את הכתובת ב
לזכרו של אשר משתנה מאוחסן.

802
00:39:00,100 --> 00:39:01,170

803
00:39:01,170 --> 00:39:07,020
אז זה הולך ממש לחזור אליכם
הקסדצימלי, ואילו ביטול התייחסותו

804
00:39:07,020 --> 00:39:10,641
הולך בעצם לתת לך
נתונים שמאוחסנים שם.

805
00:39:10,641 --> 00:39:11,140
בסדר?

806
00:39:11,140 --> 00:39:12,680

807
00:39:12,680 --> 00:39:16,060
אז אנחנו הולכים להסתכל על דוגמא
ממש מהר, או בעצם ליד.

808
00:39:16,060 --> 00:39:18,050

809
00:39:18,050 --> 00:39:19,150
>> אישור.

810
00:39:19,150 --> 00:39:21,790
אז אנחנו צריכים לחשוב באמת
בזהירות על זה.

811
00:39:21,790 --> 00:39:23,860
אז הנה יש לנו כמה x מספר שלם.

812
00:39:23,860 --> 00:39:26,485
אני הולך לנסות ולצייר את זה
למיטב היכולות שלי.

813
00:39:26,485 --> 00:39:30,230

814
00:39:30,230 --> 00:39:32,410
אז אנחנו הולכים להיות x חריץ זה.

815
00:39:32,410 --> 00:39:35,850

816
00:39:35,850 --> 00:39:37,315
וזה אחסון חמישה.

817
00:39:37,315 --> 00:39:38,640

818
00:39:38,640 --> 00:39:40,090
הכתובת שלו היא 0x4.

819
00:39:40,090 --> 00:39:41,920

820
00:39:41,920 --> 00:39:43,160
מגניב?

821
00:39:43,160 --> 00:39:44,100
כל טוב.

822
00:39:44,100 --> 00:39:45,470
>> אז עכשיו יש לנו מצביע זה.

823
00:39:45,470 --> 00:39:46,916

824
00:39:46,916 --> 00:39:47,990
זה נגמר כאן.

825
00:39:47,990 --> 00:39:52,130

826
00:39:52,130 --> 00:39:57,560
והאמפרסנד נותן לנו
הכתובת של משהו.

827
00:39:57,560 --> 00:40:00,780
אז, במקרה זה, זה את הכתובת של x.

828
00:40:00,780 --> 00:40:01,875
מהי הכתובת של x?

829
00:40:01,875 --> 00:40:05,660

830
00:40:05,660 --> 00:40:12,590
04-- ומצביע זה הוא ב0x08.

831
00:40:12,590 --> 00:40:14,490

832
00:40:14,490 --> 00:40:14,990
מגניב?

833
00:40:14,990 --> 00:40:16,570

834
00:40:16,570 --> 00:40:21,570
כך שאתה יכול לחשוב על זה
המצביע, 04, רק מצביע לכאן.

835
00:40:21,570 --> 00:40:22,840

836
00:40:22,840 --> 00:40:25,740
והם נקראים מצביעים
כי כפי שאנו מקבלים יותר לתוך זה,

837
00:40:25,740 --> 00:40:28,450
אתה הולך לראות מצביע על דברים.

838
00:40:28,450 --> 00:40:31,470
ובלוק אחד מצביע על עוד
בלוק יעשה הרבה יותר הגיוני.

839
00:40:31,470 --> 00:40:32,760

840
00:40:32,760 --> 00:40:33,890
אז הנה שתי.

841
00:40:33,890 --> 00:40:38,230
ולאחר מכן יש לנו כמה
עותק, שהוא 0x0c what--.

842
00:40:38,230 --> 00:40:41,290

843
00:40:41,290 --> 00:40:43,420
וזה הולך
dereference המצביע שלנו.

844
00:40:43,420 --> 00:40:46,790
>> אז מה זה אומר הוא
קיי, אז הנה המצביע שלנו.

845
00:40:46,790 --> 00:40:53,090
הערך זה מאחסן הוא 0x04, ומה
זה אומר שיגיע לכתובת זו

846
00:40:53,090 --> 00:40:54,300
ותגיד לי מה יש בו.

847
00:40:54,300 --> 00:40:55,520

848
00:40:55,520 --> 00:40:57,710
אז זה ביעילות
מה הלחץ הזה עושה.

849
00:40:57,710 --> 00:40:58,750

850
00:40:58,750 --> 00:41:01,280
אתה יכול לחשוב על זה כמו הכוכב שלך.

851
00:41:01,280 --> 00:41:05,410
אז או קיי, כאשר אנו עושים כוכב, זה אומר מעקב.

852
00:41:05,410 --> 00:41:06,810
תגיע לכתובת זו.

853
00:41:06,810 --> 00:41:11,430
וזה בעצם רק הבא
החץ הזה לנתח זיכרון זה.

854
00:41:11,430 --> 00:41:15,380
ולתת לנו מה יש בו, שהוא 5.

855
00:41:15,380 --> 00:41:18,840
זה למה העותק שלנו שווה ל 5.

856
00:41:18,840 --> 00:41:20,120
האם זה הגיוני?

857
00:41:20,120 --> 00:41:22,769
האם מישהו צריך אותי כדי לעבור
כי שוב, או לאט יותר?

858
00:41:22,769 --> 00:41:24,560
אתה רוצה שאני אלך
דרכו עוד פעם אחת?

859
00:41:24,560 --> 00:41:25,060
אישור.

860
00:41:25,060 --> 00:41:27,549

861
00:41:27,549 --> 00:41:28,840
אנחנו הולכים לצייר מחדש את זה שוב.

862
00:41:28,840 --> 00:41:31,930

863
00:41:31,930 --> 00:41:37,205
כאשר אנחנו מתחילים, כולנו מסכימים שיש לנו
כמה נתח של זיכרון זה משתנה

864
00:41:37,205 --> 00:41:40,890
x שהצבנו שווה ל 5.

865
00:41:40,890 --> 00:41:42,910
אין לנו שליטה בו בזיכרון.

866
00:41:42,910 --> 00:41:45,520
אז במקום זה הוא פשוט
באופן שרירותי שהוקצה.

867
00:41:45,520 --> 00:41:47,770

868
00:41:47,770 --> 00:41:48,731
טוב שיש?

869
00:41:48,731 --> 00:41:49,230
אישור.

870
00:41:49,230 --> 00:41:50,420

871
00:41:50,420 --> 00:41:53,330
אז לאתחל מצביע לint.

872
00:41:53,330 --> 00:41:56,900
זו הסיבה שמותר לו להצביע על
x כי יש לנו int כאן.

873
00:41:56,900 --> 00:42:00,840
יש לנו עוד נתח מ
זיכרון כי מצביע זה

874
00:42:00,840 --> 00:42:03,485
הוא משתנה בדיוק כמו כל דבר אחר.

875
00:42:03,485 --> 00:42:06,615
זה נקבע באופן שרירותי
כמה מקום בזיכרון.

876
00:42:06,615 --> 00:42:07,630

877
00:42:07,630 --> 00:42:10,830
ומה הוא מאחסן היא הכתובת של x.

878
00:42:10,830 --> 00:42:13,200
אמפרסנד אומר כתובת של x.

879
00:42:13,200 --> 00:42:14,575
אז מה היא הכתובת של x?

880
00:42:14,575 --> 00:42:19,179

881
00:42:19,179 --> 00:42:20,614
>> קהל: זה zero--

882
00:42:20,614 --> 00:42:21,280
1 SPEAKER: 0x04.

883
00:42:21,280 --> 00:42:24,350

884
00:42:24,350 --> 00:42:25,940
אז then-- אחרון.

885
00:42:25,940 --> 00:42:30,650
יש לנו כמה copy-- שוב
רק עוד משתנה.

886
00:42:30,650 --> 00:42:32,520
אז בואו להקצות מקום שרירותי.

887
00:42:32,520 --> 00:42:35,260

888
00:42:35,260 --> 00:42:38,080
ואנחנו dereference המצביע שלנו.

889
00:42:38,080 --> 00:42:42,490
כוכב פירושו ללכת ל
כתובת מאוחסנת במצביע שלי.

890
00:42:42,490 --> 00:42:44,480
תגיד לי מה יש שם.

891
00:42:44,480 --> 00:42:47,290
אז אחסנה את הכתובת
במצביע שלנו הוא 0x04.

892
00:42:47,290 --> 00:42:49,070

893
00:42:49,070 --> 00:42:51,310
אז אנחנו הולכים לכתובת זו.

894
00:42:51,310 --> 00:42:52,402

895
00:42:52,402 --> 00:42:54,590
זה מצביע לכתובת זו.

896
00:42:54,590 --> 00:42:57,481
מה יש בפנים בלוק הזיכרון הזה?

897
00:42:57,481 --> 00:42:57,980
זה חמש.

898
00:42:57,980 --> 00:42:59,210

899
00:42:59,210 --> 00:43:01,650
אז זה מה שאנו מקצים העותק שלנו.

900
00:43:01,650 --> 00:43:03,430

901
00:43:03,430 --> 00:43:04,860
כולם טובים?

902
00:43:04,860 --> 00:43:05,360
מגניב.

903
00:43:05,360 --> 00:43:07,010

904
00:43:07,010 --> 00:43:08,330
תמונות Again--.

905
00:43:08,330 --> 00:43:19,750

906
00:43:19,750 --> 00:43:25,200
>> אז מעקב הערכים here-- אני
הולך לתת לכם לחשוב על זה.

907
00:43:25,200 --> 00:43:26,550

908
00:43:26,550 --> 00:43:27,750
אנחנו יכולים לצייר תמונה אחרת.

909
00:43:27,750 --> 00:43:31,260
אבל אני רוצה שתנסה וסיבה
דרך זה בעצמך לרגע.

910
00:43:31,260 --> 00:44:01,430

911
00:44:01,430 --> 00:44:04,149
>> מאז הם לא נתנו לי
שלנו כתובת לדוגמה,

912
00:44:04,149 --> 00:44:06,940
אני רק הולך לעשות x-- אמפרסנד
שאמור לעזור להסיע אותו הביתה.

913
00:44:06,940 --> 00:44:07,950
אמפרסנד משמעות כתובת.

914
00:44:07,950 --> 00:44:09,540

915
00:44:09,540 --> 00:44:12,360
>> אז בראשון, כולם
ללכת עם הקו הראשון.

916
00:44:12,360 --> 00:44:15,690
של five-- כמה סט x חלק
חריץ אקראי בזיכרון.

917
00:44:15,690 --> 00:44:17,660

918
00:44:17,660 --> 00:44:23,200
מצביע כוכב Int שווה
לכתובתו של x, נכון?

919
00:44:23,200 --> 00:44:28,180
מצביע כוכב Int יוצר
הבלוק הזה, קורא לזה מצביע,

920
00:44:28,180 --> 00:44:30,650
ומקצה אותו לכתובת של x.

921
00:44:30,650 --> 00:44:32,750

922
00:44:32,750 --> 00:44:34,230
אני נורא בסימן חיבור.

923
00:44:34,230 --> 00:44:36,460

924
00:44:36,460 --> 00:44:40,550
>> עכשיו מה שאנחנו עושים הוא שאנחנו אומרים
אישור, dereference המצביע שלנו.

925
00:44:40,550 --> 00:44:42,760
אז אנחנו הולכים על אישור, מה במצביע שלנו?

926
00:44:42,760 --> 00:44:44,820
זה x אמפרסנד.

927
00:44:44,820 --> 00:44:49,400
עבור לx אמפרסנד ולהקצות מחדש אותו.

928
00:44:49,400 --> 00:44:51,620

929
00:44:51,620 --> 00:44:57,480
>> אז עכשיו, x האמפרסנד הולך להיות 35.

930
00:44:57,480 --> 00:45:01,540

931
00:45:01,540 --> 00:45:05,174
אז בעצם, כשאתה
ביטול ההפניה למבנה, שאתה הולך על אישור.

932
00:45:05,174 --> 00:45:07,090
אתה הולך להיות ציור
תמונות כמו זו.

933
00:45:07,090 --> 00:45:09,423
אתה הולך להיות ציור
החצים שלך על איפה זה.

934
00:45:09,423 --> 00:45:16,030
אז ללכת לחריץ זה בזיכרון וגם
תן לי את זה בחזרה ערך, או לשנות אותו.

935
00:45:16,030 --> 00:45:21,620
במקרה זה, כי אנחנו בשעה זו
ערך, שאנחנו מקצים את זה כדי להיות 35.

936
00:45:21,620 --> 00:45:24,700
בעוד שבעבר
אחד, אם אתה שם לב, אנחנו

937
00:45:24,700 --> 00:45:27,680
היו הקצאה מה היה
כאן למשהו אחר.

938
00:45:27,680 --> 00:45:30,450

939
00:45:30,450 --> 00:45:32,245
>> אז יש להם השולחן מדהים הזה.

940
00:45:32,245 --> 00:45:35,000

941
00:45:35,000 --> 00:45:36,890
זה לא שרע.

942
00:45:36,890 --> 00:45:37,970
אתם עובדים על זה.

943
00:45:37,970 --> 00:45:39,640
אני הולך לצייר את זה על הלוח.

944
00:45:39,640 --> 00:45:41,306
אנחנו הולכים למלא אותו יחד, בסדר?

945
00:45:41,306 --> 00:45:42,290

946
00:45:42,290 --> 00:45:45,530
אז לתפוס את נייר, לתפוס כמה
שותף, להתחיל לעבוד.

947
00:45:45,530 --> 00:45:53,897

948
00:45:53,897 --> 00:45:55,605
אני הולך לקבל
חתיכה גדולה של גיר.

949
00:45:55,605 --> 00:45:56,624

950
00:45:56,624 --> 00:45:58,150
כי זה הולך להיות הרבה.

951
00:45:58,150 --> 00:45:59,410

952
00:45:59,410 --> 00:45:59,910
אישור.

953
00:45:59,910 --> 00:48:08,567

954
00:48:08,567 --> 00:48:09,150
פרופסור: אישור.

955
00:48:09,150 --> 00:48:11,599

956
00:48:11,599 --> 00:48:12,890
בואו נתחיל עם השורה הראשונה.

957
00:48:12,890 --> 00:48:14,070

958
00:48:14,070 --> 00:48:16,970
נתחיל שם, אז אתם
אולי יכול לעבוד דרך כמה יותר.

959
00:48:16,970 --> 00:48:17,870
אישור.

960
00:48:17,870 --> 00:48:19,810
שווה פעמים ב ג אז מה הוא?

961
00:48:19,810 --> 00:48:21,420

962
00:48:21,420 --> 00:48:23,260
זה לא שאלה מכשילה, אני מבטיח.

963
00:48:23,260 --> 00:48:24,440
>> תלמיד: 4 פעמים 5.

964
00:48:24,440 --> 00:48:25,420
>> פרופסור: 4 פעמים 5.

965
00:48:25,420 --> 00:48:25,920
20.

966
00:48:25,920 --> 00:48:26,730
אז מה ב?

967
00:48:26,730 --> 00:48:27,921

968
00:48:27,921 --> 00:48:28,420
תלמיד: 4.

969
00:48:28,420 --> 00:48:30,204

970
00:48:30,204 --> 00:48:31,043
>> פרופסור: ו- C?

971
00:48:31,043 --> 00:48:31,542
תלמיד: 5.

972
00:48:31,542 --> 00:48:32,083
פרופסור: 5.

973
00:48:32,083 --> 00:48:35,960
ואז זה רק הולך
להיות אמפרסנד, ב אמפרסנד,

974
00:48:35,960 --> 00:48:38,575
אמפרסנד ג, נכון?

975
00:48:38,575 --> 00:48:39,728

976
00:48:39,728 --> 00:48:40,596
לא רע.

977
00:48:40,596 --> 00:48:42,081
זה די פשוט.

978
00:48:42,081 --> 00:48:42,580
אישור.

979
00:48:42,580 --> 00:48:44,300
אז הבא.

980
00:48:44,300 --> 00:48:48,725
שווה פעמים ג, במקרה
אף אחד לא הכיר את זה.

981
00:48:48,725 --> 00:48:49,812

982
00:48:49,812 --> 00:48:53,300
האם כולם מכירים
עם הזמן שווה?

983
00:48:53,300 --> 00:49:00,105
אישור, כל זה means-- זה
קיצור לשווה פעמים ג.

984
00:49:00,105 --> 00:49:04,840
גם אתה יכול לעשות את זה עם החלוקה,
עם תוספת, עם חיסור.

985
00:49:04,840 --> 00:49:12,130
אתה יכול לעשות את שווים, או בתוספת שווה ג
משמעות הדבר היא שווה ג תוספת, מינוס שווה

986
00:49:12,130 --> 00:49:15,190
ג יהיה שווה ג מינוס.

987
00:49:15,190 --> 00:49:16,690
זה רק סוכר תחבירי.

988
00:49:16,690 --> 00:49:19,380

989
00:49:19,380 --> 00:49:24,140
>> אז, במקרה זה, שווה ל
פעמים ג ייתן לנו מה?

990
00:49:24,140 --> 00:49:25,910

991
00:49:25,910 --> 00:49:28,186
שוב, לא שאלה מכשילה.

992
00:49:28,186 --> 00:49:28,965
>> תלמיד: 100.

993
00:49:28,965 --> 00:49:29,300
>> פרופסור: 100.

994
00:49:29,300 --> 00:49:30,383
האם כל דבר אחר לשנות?

995
00:49:30,383 --> 00:49:31,790

996
00:49:31,790 --> 00:49:32,290
מס '

997
00:49:32,290 --> 00:49:37,380

998
00:49:37,380 --> 00:49:39,850
אולי אני סוף סוף אקבל
טוב יותר בסימן החיבור שלי.

999
00:49:39,850 --> 00:49:42,047
>> תלמיד: אוקיי, מצטער, איך אתה מקבל 100?

1000
00:49:42,047 --> 00:49:42,630
פרופסור: אישור.

1001
00:49:42,630 --> 00:49:46,594
אז שווה ל
פעמים ג, כה פעמים ג.

1002
00:49:46,594 --> 00:49:48,510
תלמיד: אה, אתה משתמש ב
לprevious--

1003
00:49:48,510 --> 00:49:49,135
פרופסור: כן.

1004
00:49:49,135 --> 00:49:51,450
אז אלה הם ערכינו העדכנית ביותר.

1005
00:49:51,450 --> 00:49:53,990
אלה הם מה שאתה צריך להיות
באמצעותה אנו מעבירים את, אישור.

1006
00:49:53,990 --> 00:49:57,290

1007
00:49:57,290 --> 00:50:01,520
אז, ב הוא שינוי הדבר היחיד, נכון?

1008
00:50:01,520 --> 00:50:02,910
אז בואו למלא בכל דבר אחר.

1009
00:50:02,910 --> 00:50:09,110

1010
00:50:09,110 --> 00:50:11,330
ב 'מה ב הולך להיות?

1011
00:50:11,330 --> 00:50:13,020

1012
00:50:13,020 --> 00:50:14,140
להיות או לא להיות.

1013
00:50:14,140 --> 00:50:18,680

1014
00:50:18,680 --> 00:50:20,240
אז מה הוא עושה את זה?

1015
00:50:20,240 --> 00:50:21,605
מה הוא כוכב הרשות הפלסטינית עושה?

1016
00:50:21,605 --> 00:50:23,280

1017
00:50:23,280 --> 00:50:25,350
>> תלמיד: קוד למיקום של הרשות הפלסטינית.

1018
00:50:25,350 --> 00:50:26,390

1019
00:50:26,390 --> 00:50:27,480
>> סטודנט: לא, לא ממש.

1020
00:50:27,480 --> 00:50:29,470
אז זה התייחסות ד.

1021
00:50:29,470 --> 00:50:31,580
>> תלמיד: אז b הוא ערך בידיים של הרשות הפלסטינית.

1022
00:50:31,580 --> 00:50:37,340
>> פרופסור: כן, אז רשות פלסטינית
הכתובת של, נכון?

1023
00:50:37,340 --> 00:50:42,430
אז זה אומר ללכת למקום שבו
מאוחסן ולתת לו ערך ש.

1024
00:50:42,430 --> 00:50:43,884
אז מה הוא ב?

1025
00:50:43,884 --> 00:50:44,425
תלמיד: 100.

1026
00:50:44,425 --> 00:50:46,534
פרופסור: 100.

1027
00:50:46,534 --> 00:50:47,450
מושלם.

1028
00:50:47,450 --> 00:50:49,879
אוקיי, אז המחשב הוא מה שמשנה.

1029
00:50:49,879 --> 00:50:51,170
כל השאר נשאר אותו הדבר.

1030
00:50:51,170 --> 00:50:57,160

1031
00:50:57,160 --> 00:50:58,620
מה מחשב הולך להיות?

1032
00:50:58,620 --> 00:51:00,770

1033
00:51:00,770 --> 00:51:01,580
משימה פשוטה.

1034
00:51:01,580 --> 00:51:03,520

1035
00:51:03,520 --> 00:51:05,990
המחשב שווה לרשות פלסטינית, ומה היא הרשות הפלסטינית?

1036
00:51:05,990 --> 00:51:07,049
>> תלמיד: אמפרסנד.

1037
00:51:07,049 --> 00:51:07,840
פרופסור: מושלם.

1038
00:51:07,840 --> 00:51:09,490

1039
00:51:09,490 --> 00:51:10,740
עכשיו אנחנו מתחיל להיות מעניינים.

1040
00:51:10,740 --> 00:51:12,310

1041
00:51:12,310 --> 00:51:15,230
אישור, בואו לשבור את זה למטה.

1042
00:51:15,230 --> 00:51:21,110
ראשית, מה פעמים ב ג, כי זה
החלק קל של זה, נכון?

1043
00:51:21,110 --> 00:51:22,360
B פעמים ג is--

1044
00:51:22,360 --> 00:51:23,320
>> תלמיד: 500.

1045
00:51:23,320 --> 00:51:28,880
>> פרופסור: כן, כל כך
מה זה עושה,

1046
00:51:28,880 --> 00:51:33,705
אם שלו PB הכוכב, מה משתנה?

1047
00:51:33,705 --> 00:51:35,320

1048
00:51:35,320 --> 00:51:37,242
>> תלמיד: מה בthe--

1049
00:51:37,242 --> 00:51:38,200
פרופסור: מה בב?

1050
00:51:38,200 --> 00:51:41,340
תלמיד: מה בחלל
PB שמצביע.

1051
00:51:41,340 --> 00:51:43,406
פרופסור: וPB מצביע to--

1052
00:51:43,406 --> 00:51:43,905
תלמיד: ב '

1053
00:51:43,905 --> 00:51:46,740
פרופסור: ב 'אז רק
שינוי דבר הוא ב, נכון.

1054
00:51:46,740 --> 00:51:50,800
ג אז ב פעמים, 500.

1055
00:51:50,800 --> 00:51:52,367
אז זה מה שמשנה עכשיו.

1056
00:51:52,367 --> 00:51:59,091

1057
00:51:59,091 --> 00:51:59,590
מגניב.

1058
00:51:59,590 --> 00:52:00,340

1059
00:52:00,340 --> 00:52:00,840
יפה.

1060
00:52:00,840 --> 00:52:01,905
אתם עושים נהדרים.

1061
00:52:01,905 --> 00:52:03,650

1062
00:52:03,650 --> 00:52:06,740
בסדר, פירוק הזה.

1063
00:52:06,740 --> 00:52:08,050

1064
00:52:08,050 --> 00:52:09,630
C משתנה, נכון?

1065
00:52:09,630 --> 00:52:11,530
כדי שנוכל למלא בכל דבר אחר.

1066
00:52:11,530 --> 00:52:12,540

1067
00:52:12,540 --> 00:52:13,205
בואו נראה.

1068
00:52:13,205 --> 00:52:19,125

1069
00:52:19,125 --> 00:52:19,625
אישור.

1070
00:52:19,625 --> 00:52:21,420

1071
00:52:21,420 --> 00:52:24,740
אנחנו יודעים שג הולך להיות
מכפלה של שני מספרים, נכון?

1072
00:52:24,740 --> 00:52:26,290

1073
00:52:26,290 --> 00:52:27,980
מה שני מספרים, אם כי?

1074
00:52:27,980 --> 00:52:28,970
>> תלמיד: וג?

1075
00:52:28,970 --> 00:52:31,930
>> פרופסור: אז הוא
נכון עבור הראשון.

1076
00:52:31,930 --> 00:52:34,385
אז אנחנו ד התייחסות p של, נכון?

1077
00:52:34,385 --> 00:52:35,390

1078
00:52:35,390 --> 00:52:42,870
P של נקודות ל, כך שאנחנו יודעים ש
זה הולך להיות 100 פעמים מה?

1079
00:52:42,870 --> 00:52:46,232
פעמים מה עושה נקודת מחשב ל?

1080
00:52:46,232 --> 00:52:47,410

1081
00:52:47,410 --> 00:52:48,740
מצביע.

1082
00:52:48,740 --> 00:52:55,038
אז 100 פעמים 100 הוא 10,000.

1083
00:52:55,038 --> 00:52:56,170
האם זה הגיוני?

1084
00:52:56,170 --> 00:52:57,640

1085
00:52:57,640 --> 00:52:58,200
מגניב.

1086
00:52:58,200 --> 00:53:00,500
למתוח את הבית, בחורים, השורה האחרונה.

1087
00:53:00,500 --> 00:53:01,190
אישור.

1088
00:53:01,190 --> 00:53:02,160
מה השתנה כאן?

1089
00:53:02,160 --> 00:53:05,640

1090
00:53:05,640 --> 00:53:06,935
>> תלמיד: א

1091
00:53:06,935 --> 00:53:09,435
פרופסור: א מושלם, כל כך
כל דבר אחר יכול להישאר אותו הדבר.

1092
00:53:09,435 --> 00:53:16,210

1093
00:53:16,210 --> 00:53:16,710
אישור.

1094
00:53:16,710 --> 00:53:17,970
ומה הוא?

1095
00:53:17,970 --> 00:53:23,610

1096
00:53:23,610 --> 00:53:26,060
אז זה פעמים מה?

1097
00:53:26,060 --> 00:53:27,120
זה PB כוכב.

1098
00:53:27,120 --> 00:53:29,750

1099
00:53:29,750 --> 00:53:34,490
אז PB כוכב פירושו הנה
PB, נקודות PB ל b.

1100
00:53:34,490 --> 00:53:35,370
>> תלמיד: 500.

1101
00:53:35,370 --> 00:53:36,230
>> פרופסור: 500.

1102
00:53:36,230 --> 00:53:39,236
אז יש לנו פי 500 100.

1103
00:53:39,236 --> 00:53:41,758
זה 50,000.

1104
00:53:41,758 --> 00:53:43,216
אוף!

1105
00:53:43,216 --> 00:53:45,646
תראה את זה.

1106
00:53:45,646 --> 00:53:47,982
>> תלמיד: למה יש לנו
וג לlast--

1107
00:53:47,982 --> 00:53:48,690
פרופסור: מצטער.

1108
00:53:48,690 --> 00:53:50,080
תלמיד: אה, בסדר.

1109
00:53:50,080 --> 00:53:51,600
פרופסור: רע שלי.

1110
00:53:51,600 --> 00:53:52,890
הרבה כתיבה.

1111
00:53:52,890 --> 00:53:53,917

1112
00:53:53,917 --> 00:53:54,500
כולם טובים?

1113
00:53:54,500 --> 00:53:55,630

1114
00:53:55,630 --> 00:53:56,660
לא רע, נכון?

1115
00:53:56,660 --> 00:53:58,490
פשוט לוקח קצת
זמן לעבוד דרך.

1116
00:53:58,490 --> 00:54:01,080
אם אתה תשבור אותו,
להבין מה כל חלק

1117
00:54:01,080 --> 00:54:03,197
מתייחס to-- כ
עם כל מה שזה,

1118
00:54:03,197 --> 00:54:05,780
yes-- לפרק אותו למעט
בעיות ולאחר מכן לשלב מחדש,

1119
00:54:05,780 --> 00:54:07,345
ואתה יכול לעשות כמה דברים מדהים.

1120
00:54:07,345 --> 00:54:08,970
יש תשובות, אבל עשו את זה.

1121
00:54:08,970 --> 00:54:10,324

1122
00:54:10,324 --> 00:54:11,115
פעולות אריתמטיות על מצביעים.

1123
00:54:11,115 --> 00:54:13,961

1124
00:54:13,961 --> 00:54:14,460
אה.

1125
00:54:14,460 --> 00:54:15,510
הידיים שלי הן כל גירי.

1126
00:54:15,510 --> 00:54:17,970
אז הוספה או הפחתה
int מתאים את המצביע

1127
00:54:17,970 --> 00:54:21,890
על ידי הגודל של הסוג של מצביע.

1128
00:54:21,890 --> 00:54:22,940

1129
00:54:22,940 --> 00:54:28,390
זוכר איך כל סוג
יש בגדלים שונים?

1130
00:54:28,390 --> 00:54:34,890
אז כמו כפול או ארוך ארוך
שמונה וint הוא ארבעה אבל char הוא אחד.

1131
00:54:34,890 --> 00:54:38,360
>> אז מה שאתה רוצה לעשות
is-- דבר אחד לזכור

1132
00:54:38,360 --> 00:54:44,080
כי הוא פשוט כמה
ערך מצביע משנה למעשה

1133
00:54:44,080 --> 00:54:46,550
יהיה תלוי ב
סוג של מצביע זה הוא.

1134
00:54:46,550 --> 00:54:50,820

1135
00:54:50,820 --> 00:54:51,820
כולם טובים עם זה?

1136
00:54:51,820 --> 00:54:52,760
האם אני יכול למחוק אותו?

1137
00:54:52,760 --> 00:54:53,440
אנחנו טובים?

1138
00:54:53,440 --> 00:54:53,940
מדהים.

1139
00:54:53,940 --> 00:55:01,020

1140
00:55:01,020 --> 00:55:07,501
>> אז אם יש לנו כמה מצביע
that-- זה הולך be-- אני

1141
00:55:07,501 --> 00:55:08,834
הולך לעשות את זה מצביע int.

1142
00:55:08,834 --> 00:55:10,610

1143
00:55:10,610 --> 00:55:12,760
הוא מאחסן את זה.

1144
00:55:12,760 --> 00:55:14,210

1145
00:55:14,210 --> 00:55:20,170
אם היית אומר מצביע
ועוד אחד, מה זה הולך לעשות

1146
00:55:20,170 --> 00:55:23,420
הוא זה הולך לעדכן
זה על ידי הגודל של int

1147
00:55:23,420 --> 00:55:25,950
כי זה
סוג של מצביע זה הוא.

1148
00:55:25,950 --> 00:55:28,260
>> עם C, כל מה שהוא
מאוד קפדן ומוסדר.

1149
00:55:28,260 --> 00:55:29,440

1150
00:55:29,440 --> 00:55:35,260
מצביע int הולך לעדכן על ידי
כמות השטח int היה לוקח.

1151
00:55:35,260 --> 00:55:36,260
Int הוא ארבעה בתים.

1152
00:55:36,260 --> 00:55:37,650

1153
00:55:37,650 --> 00:55:39,060
>> אז מה זה היה הופך ל?

1154
00:55:39,060 --> 00:55:40,876

1155
00:55:40,876 --> 00:55:44,390
אתה פשוט מוסיף ארבעה על זה.

1156
00:55:44,390 --> 00:55:50,040
עכשיו המצביע היה be-- אישור.

1157
00:55:50,040 --> 00:55:51,820

1158
00:55:51,820 --> 00:55:55,380
>> אז אם זה היה char ועשינו מצביע
ועוד אחד, מה זה היה עכשיו?

1159
00:55:55,380 --> 00:56:00,300

1160
00:56:00,300 --> 00:56:03,330
אם זה started-- מעמיד פנים שאנחנו
started-- עכשיו זה 0x08.

1161
00:56:03,330 --> 00:56:04,850

1162
00:56:04,850 --> 00:56:10,850
בואו עכשיו אומרים שזה היה
char מצביע, והוספנו אחד.

1163
00:56:10,850 --> 00:56:11,850
מה זה משנה ל?

1164
00:56:11,850 --> 00:56:14,989

1165
00:56:14,989 --> 00:56:16,030
כמה בתים הוא char?

1166
00:56:16,030 --> 00:56:16,680
>> קהל: אחת.

1167
00:56:16,680 --> 00:56:17,304
>> 1 SPEAKER: אחת.

1168
00:56:17,304 --> 00:56:18,309
קהל: אז 0x09.

1169
00:56:18,309 --> 00:56:19,600
1 SPEAKER: אז זה יהיה תשע.

1170
00:56:19,600 --> 00:56:22,571

1171
00:56:22,571 --> 00:56:23,820
אז רק משהו לזכור.

1172
00:56:23,820 --> 00:56:28,340
רק כאשר אתה מוסיף אחד, זה לא
הוספה אחד אלא אם כן זה char.

1173
00:56:28,340 --> 00:56:34,190
זה מוסיף כמה
ביטי הסוג שהוא,

1174
00:56:34,190 --> 00:56:36,960
וזו הסיבה שיש לנו
משוואה זו כאן.

1175
00:56:36,960 --> 00:56:40,190
אז זה הפעמים int הגודל
מהסוג של מצביע.

1176
00:56:40,190 --> 00:56:42,850

1177
00:56:42,850 --> 00:56:44,730
>> אז יש לנו הדוגמא כאן.

1178
00:56:44,730 --> 00:56:47,250

1179
00:56:47,250 --> 00:56:54,430
y הוטל על שערך, 0x4,
כשעשינו Y ועוד שווה לאחד.

1180
00:56:54,430 --> 00:56:56,830
מה יש בו, מה ש
בx, לא משנה.

1181
00:56:56,830 --> 00:56:58,610
מה עושה שינוי הוא מה שהוא בy.

1182
00:56:58,610 --> 00:57:04,980
כתובת מאוחסנת בy מעודכן על ידי ארבעה
כי יש ארבעה בתים בint

1183
00:57:04,980 --> 00:57:06,097
וזה מצביע int.

1184
00:57:06,097 --> 00:57:07,290

1185
00:57:07,290 --> 00:57:07,790
>> בְּסֵדֶר.

1186
00:57:07,790 --> 00:57:09,123
אז עכשיו יש לנו עוד תרגיל.

1187
00:57:09,123 --> 00:57:11,140

1188
00:57:11,140 --> 00:57:13,500
אז השאלה היא מה יהיה להדפיס.

1189
00:57:13,500 --> 00:57:36,710

1190
00:57:36,710 --> 00:57:37,650
יש לך רעיונות?

1191
00:57:37,650 --> 00:57:41,690

1192
00:57:41,690 --> 00:57:43,699
>> קהל: מספר
דמויות בחתול מאושר?

1193
00:57:43,699 --> 00:57:44,490
1 SPEAKER: בדיוק.

1194
00:57:44,490 --> 00:57:45,531
אז כמו בחוט שלך.

1195
00:57:45,531 --> 00:57:47,302

1196
00:57:47,302 --> 00:57:48,260
האם כולם מקבלים את זה?

1197
00:57:48,260 --> 00:57:49,509
האם אנחנו רוצים ללכת בו?

1198
00:57:49,509 --> 00:57:50,300

1199
00:57:50,300 --> 00:57:52,010
>> כן, בסדר.

1200
00:57:52,010 --> 00:57:57,385
אז מה יש לנו here-- אני
כמו זה כל כך הרבה יותר.

1201
00:57:57,385 --> 00:57:59,340
אין לי ל
[לא ברור] עד כדי גיחוך.

1202
00:57:59,340 --> 00:58:01,690
>> אז יש לנו המחרוזת שלנו כאן, חתול מאושר.

1203
00:58:01,690 --> 00:58:02,950
יפה.

1204
00:58:02,950 --> 00:58:05,080
יש לנו כמה דלפק ש
אנחנו עוקבים אחרי.

1205
00:58:05,080 --> 00:58:11,430
אז יש לנו כמה מצביע char *
כי רק מוגדר שווה לStr.

1206
00:58:11,430 --> 00:58:14,320
מה זה עושה הוא זה
הקצאת חלק מצביע

1207
00:58:14,320 --> 00:58:16,380
לתחילת המחרוזת שלך.

1208
00:58:16,380 --> 00:58:19,840
כי אני בטוח, כפי ש
הוזכר בהרצאה,

1209
00:58:19,840 --> 00:58:22,290
אנחנו נותנים לך בחורים זה
טיפוס בשם מחרוזת.

1210
00:58:22,290 --> 00:58:29,070
>> אבל באמת בחוטים הם רק
מערך ל-- כמו char *.

1211
00:58:29,070 --> 00:58:32,330
זה מצביע לחבורה של דמויות
כי הם רציפים בזיכרון.

1212
00:58:32,330 --> 00:58:33,680

1213
00:58:33,680 --> 00:58:36,280
אז זה רק מגדיר את זה
שווה לכל מחרוזת היא

1214
00:58:36,280 --> 00:58:38,980
זוהה על ידי שבו
התו הראשון שלה הוא.

1215
00:58:38,980 --> 00:58:42,710
אז זה רק הגדרת שלב מסוים
שווה לתחילת המחרוזת.

1216
00:58:42,710 --> 00:58:44,130
כולם טוב שם?

1217
00:58:44,130 --> 00:58:44,960
מגניב.

1218
00:58:44,960 --> 00:58:49,840
>> אז זה הוא ביטול התייחסות המצביע שלנו.

1219
00:58:49,840 --> 00:58:53,760
אז זה באמת הולך
תן לנו קצת ערך לכאן,

1220
00:58:53,760 --> 00:58:55,610
במחרוזת שלנו שאנחנו מדברים.

1221
00:58:55,610 --> 00:58:58,342
ואנחנו אומרים כל זמן ש
זה לא שליחות קטלנית null.

1222
00:58:58,342 --> 00:59:00,550
אז להמשיך עד שאתה מקבל
לסוף המחרוזת.

1223
00:59:00,550 --> 00:59:02,180

1224
00:59:02,180 --> 00:59:04,190
עדכון המצביע שלך על ידי אחד.

1225
00:59:04,190 --> 00:59:09,250
אז r, זה יהיה ממש לעדכן על ידי אחד
בכל פעם, כי זה char,

1226
00:59:09,250 --> 00:59:09,820
* char.

1227
00:59:09,820 --> 00:59:10,930

1228
00:59:10,930 --> 00:59:12,340
>> כך שזה הולך לעבור.

1229
00:59:12,340 --> 00:59:13,290
זה הולך לעדכן.

1230
00:59:13,290 --> 00:59:16,705
אז בפעם הראשונה זה פועל,
זה הולך להיות כאן בשעות.

1231
00:59:16,705 --> 00:59:17,590
זה הולך לעדכן.

1232
00:59:17,590 --> 00:59:18,185
>> זה יהיה.

1233
00:59:18,185 --> 00:59:21,310
זה יהיה p, y, וכן הלאה וכן הלאה.

1234
00:59:21,310 --> 00:59:22,300
אנו נעדכן את הדלפק.

1235
00:59:22,300 --> 00:59:26,160
כאשר הוא מגיע לסוף, זה
רק מדפיס כמה רחוק זה הגיע.

1236
00:59:26,160 --> 00:59:27,550

1237
00:59:27,550 --> 00:59:28,050
כן.

1238
00:59:28,050 --> 00:59:31,475
>> קהל: אז הוא מביא בחשבון
החלל כאחד, נכון?

1239
00:59:31,475 --> 00:59:31,974
אישור.

1240
00:59:31,974 --> 00:59:34,294

1241
00:59:34,294 --> 00:59:35,222
>> 1 SPEAKER: חושב כך.

1242
00:59:35,222 --> 00:59:36,830
האם זה question--

1243
00:59:36,830 --> 00:59:37,746
>> קהל: [לא ברור].

1244
00:59:37,746 --> 00:59:37,968

1245
00:59:37,968 --> 00:59:38,884
>> 1 SPEAKER: אין בעיה.

1246
00:59:38,884 --> 00:59:39,720

1247
00:59:39,720 --> 00:59:42,736
אני זה לעשות את זה.

1248
00:59:42,736 --> 00:59:47,710
טוב, אז הדבר אחד ש
להבין שעם מערך הוא,

1249
00:59:47,710 --> 00:59:51,736
גם אתה יכול להתייחס אליו כ
מצביע כי מערכים הם רק

1250
00:59:51,736 --> 00:59:52,860
נקודות רצופות של זיכרון.

1251
00:59:52,860 --> 00:59:53,970

1252
00:59:53,970 --> 00:59:56,380
>> כך שאתה יכול להתייחס אליו באותה הצורה.

1253
00:59:56,380 --> 00:59:59,000
אתה יכול לתפעל אותם
עם מצביעים, מדי.

1254
00:59:59,000 --> 01:00:04,770
כך, במקום, בזה
מקרה, הדבר מקביל

1255
01:00:04,770 --> 01:00:07,490
יהיה מערך 0 שווה 1.

1256
01:00:07,490 --> 01:00:08,760

1257
01:00:08,760 --> 01:00:15,210
>> אבל באותו אופן שבי
מחרוזת נקבעה

1258
01:00:15,210 --> 01:00:18,740
עד תחילת שבי
התו הראשון שלו הוא,

1259
01:00:18,740 --> 01:00:22,270
מערך נקבע על ידי
שבו האלמנט הראשון שלה הוא.

1260
01:00:22,270 --> 01:00:25,120
בגלל שאנחנו יודעים, אנחנו
ביותר, כי אלה

1261
01:00:25,120 --> 01:00:27,985
הולכים להיות רציף
בלוקים של זיכרון.

1262
01:00:27,985 --> 01:00:29,360
זה מה שמאפשר לנו לעשות את זה.

1263
01:00:29,360 --> 01:00:31,193
אנחנו יודעים שהם רציפים
בלוקים של זיכרון.

1264
01:00:31,193 --> 01:00:32,230

1265
01:00:32,230 --> 01:00:36,500
>> אז במקרה הזה, על ידי ביטול התייחסות
רק מערך, שאומר לנו,

1266
01:00:36,500 --> 01:00:40,800
אישור, ללכת לתחילת
המערך שלך, שהוא כאן.

1267
01:00:40,800 --> 01:00:42,640
אז אתה יכול להגדיר את זה שווה לאחד.

1268
01:00:42,640 --> 01:00:48,610
ובמקרה הזה, כל מה שהמערך שלך
הסוג הוא, כאשר אתה מעדכן אותו על ידי אחד,

1269
01:00:48,610 --> 01:00:50,830
זה בדיוק כמו עדכון
שלו לאינדקס הבא.

1270
01:00:50,830 --> 01:00:52,760

1271
01:00:52,760 --> 01:00:56,360
אתה יכול לעשות את זה בגלל שאתה
יודע מה יש במערך שלך.

1272
01:00:56,360 --> 01:00:59,770
אז הוא יודע כמה ל
לעדכן את המצביע שלך על ידי,

1273
01:00:59,770 --> 01:01:02,925
מה כתובת כדי לעדכן אותו לכך
כי אתה בחריץ הבא.

1274
01:01:02,925 --> 01:01:04,740

1275
01:01:04,740 --> 01:01:09,400
>> כך שזה רק צורה שונה
כתיבת מערך 0 שווה 1,

1276
01:01:09,400 --> 01:01:15,114
מערך 1 שווה 2, מערך
תושבת 2 שווה 3.

1277
01:01:15,114 --> 01:01:16,780
זאת פשוט דרך נוספת לחשוב על זה.

1278
01:01:16,780 --> 01:01:19,600
כי הם רציפים
בלוקים בזיכרון,

1279
01:01:19,600 --> 01:01:21,830
אתה יכול להתייחס אליהם או
על ידי המערך notation--

1280
01:01:21,830 --> 01:01:24,390
שאני באופן אישי
למצוא easier-- אבל אולי

1281
01:01:24,390 --> 01:01:27,347
אתה צריך לתפעל אותו
בקפדנות על ידי כתובות זיכרון.

1282
01:01:27,347 --> 01:01:28,930
וזו הדרך שאתה הייתי עושה את זה.

1283
01:01:28,930 --> 01:01:30,630

1284
01:01:30,630 --> 01:01:32,630
סוג של יותר כמו
דבר מגניב שאתה יכול לעשות

1285
01:01:32,630 --> 01:01:35,213
לעומת אולי לא משהו שאתה
הולך לממש בפועל.

1286
01:01:35,213 --> 01:01:36,960

1287
01:01:36,960 --> 01:01:38,630
>> אני משתמש בו ב -61.

1288
01:01:38,630 --> 01:01:41,710
אתם כנראה לא צריכים
לדאוג בקשר לזה יותר מדי.

1289
01:01:41,710 --> 01:01:43,693
אבל אם אתה מעוניין,
לקחת 61 בשנה הבאה.

1290
01:01:43,693 --> 01:01:45,269

1291
01:01:45,269 --> 01:01:46,560
אנחנו בבחורים למתוח את הבית.

1292
01:01:46,560 --> 01:01:47,510
אני יודע, זה ארוך.

1293
01:01:47,510 --> 01:01:50,570

1294
01:01:50,570 --> 01:01:58,880
הזיכרון דינמי Allocation--
כך אנו יודעים כי אחד

1295
01:01:58,880 --> 01:02:01,790
דברים כאשר דברנו ב
הסעיף הראשון שלנו יחד,

1296
01:02:01,790 --> 01:02:04,560
הסתכלנו החלפה
פונקציה שבה היה

1297
01:02:04,560 --> 01:02:08,010
מחוץ להיקף תפקידו העיקרי שלנו.

1298
01:02:08,010 --> 01:02:14,370
ואנחנו עוברים בערכים אלה
שהיו יעיל עותקים.

1299
01:02:14,370 --> 01:02:20,570
>> וברגע שההחלפה סיים
ביצוע, זה פשוט השאיר את ערימה.

1300
01:02:20,570 --> 01:02:22,830
זכרו, יש לנו
מחסנית מסגרת להחלפה.

1301
01:02:22,830 --> 01:02:26,070
זה משאיר את ואלה
ערכים לעזוב איתו.

1302
01:02:26,070 --> 01:02:27,050
והם נעלמו.

1303
01:02:27,050 --> 01:02:28,615
אנחנו לא יכולים לעשות שום דבר
איתם ואנחנו היינו עצובים

1304
01:02:28,615 --> 01:02:29,989
כי אנחנו לא יכולים להחליף את הערכים שלנו.

1305
01:02:29,989 --> 01:02:31,070

1306
01:02:31,070 --> 01:02:36,560
>> אבל עם C, כפי שציינתי, אתה
יש להם הרבה כוח על זיכרון.

1307
01:02:36,560 --> 01:02:43,310
אז מה שאתה יכול לעשות הוא שאתה יכול
להקצות דברים על הערימה כאן

1308
01:02:43,310 --> 01:02:46,830
שיישאר שם עד
אתה אומר להם אחרת.

1309
01:02:46,830 --> 01:02:48,280
>> הם כמו ילדים טובים.

1310
01:02:48,280 --> 01:02:49,150
הם שוהים שם.

1311
01:02:49,150 --> 01:02:50,270
הם לא משאירים.

1312
01:02:50,270 --> 01:02:52,750
הם יישארו שם עד שאתה
כמו, בסדר, אתה יכול ללכת משם.

1313
01:02:52,750 --> 01:02:55,920
>> ואילו דברים על הערימה, who--
הם כמו ילדים שובבים.

1314
01:02:55,920 --> 01:02:59,160
הם פשוט יברחו כאשר אתה רוצה
להיות שם ואז הם נעלמים.

1315
01:02:59,160 --> 01:03:00,160
אתה לא יכול לקבל אותם בחזרה.

1316
01:03:00,160 --> 01:03:01,350

1317
01:03:01,350 --> 01:03:07,187
>> אז הערימה is-- אנחנו הולכים
לדבר על malloc וחופשי, ש

1318
01:03:07,187 --> 01:03:08,895
אני בטוח שאתם
שמע על בהרצאה.

1319
01:03:08,895 --> 01:03:10,270

1320
01:03:10,270 --> 01:03:14,210
וזה בעצם דרך
יש נתונים מאוד עקשנים.

1321
01:03:14,210 --> 01:03:18,920
אז אתה יכול לשמור את הנתונים
בסביבה כמה שאתה רוצה.

1322
01:03:18,920 --> 01:03:19,546
מהמ.

1323
01:03:19,546 --> 01:03:21,475
>> קהל: אתה יכול להגדיר ערימה ומחסנית?

1324
01:03:21,475 --> 01:03:24,030
האם הם אוהבים מקומות לשים את הדברים?

1325
01:03:24,030 --> 01:03:26,630
>> 1 SPEAKER: אז הם
בעצם פשוט- הם

1326
01:03:26,630 --> 01:03:29,530
הדרך בה אנו מתייחסים רק לזיכרון.

1327
01:03:29,530 --> 01:03:37,300
אז ערימה היא רק מקומות שבם
זיכרון מוקצה באופן דינמי,

1328
01:03:37,300 --> 01:03:40,960
בעוד ערימה מתייחסת
יותר לערום מסגרות

1329
01:03:40,960 --> 01:03:45,950
כי הם יותר מרכזיים ל
פונקציות שבעצם פועלות.

1330
01:03:45,950 --> 01:03:47,200
באמת שאין לך שליטה.

1331
01:03:47,200 --> 01:03:50,690
>> ההבדל הגדול, יש לך שליטה
מעל הערימה, אם אתה רוצה.

1332
01:03:50,690 --> 01:03:52,710
יש לך פחות שליטה על הערימה.

1333
01:03:52,710 --> 01:03:55,030
הערימה תלויה ב
פונקציות הפועלות,

1334
01:03:55,030 --> 01:03:58,320
והסדר שבו הם נמצאים
לרוץ, ואיך הם חזרו דברים.

1335
01:03:58,320 --> 01:04:01,290
ואילו עם הערימה, כ
אנו רואים, שאתה יכול להגיד,

1336
01:04:01,290 --> 01:04:06,639
בסדר, אני רוצה ערך זה להיות
בסביבה עד שאני אומר לך אחרת.

1337
01:04:06,639 --> 01:04:08,180
אין באפשרותך להיפטר מזה.

1338
01:04:08,180 --> 01:04:09,300
אתה לא רשאי לבטל אותה.

1339
01:04:09,300 --> 01:04:11,675
אתה הולך לשמור אותו סביב
כל עוד אני אומר לך.

1340
01:04:11,675 --> 01:04:15,780
אתה מקבל להיות הבוס בערימה,
בעוד stack-- אולי אם

1341
01:04:15,780 --> 01:04:18,080
כמו להתברג בדרך שלך
אתה יכול להיות הבוס.

1342
01:04:18,080 --> 01:04:19,340
אבל לא ממש.

1343
01:04:19,340 --> 01:04:20,480

1344
01:04:20,480 --> 01:04:22,070
וזה באמת רק זיכרון.

1345
01:04:22,070 --> 01:04:24,260
זה דרכים שונות רק
הפניה לזיכרון.

1346
01:04:24,260 --> 01:04:25,800

1347
01:04:25,800 --> 01:04:26,400
>> מגניב.

1348
01:04:26,400 --> 01:04:28,630
אז עם זה, איך
לשלוט בזיכרון שלך.

1349
01:04:28,630 --> 01:04:32,070
זה עם malloc, ש
אתה הולך לקבל לשימוש.

1350
01:04:32,070 --> 01:04:37,100
אז זה קצר רק
להקצאת זיכרון.

1351
01:04:37,100 --> 01:04:38,459
זה כל מה שזה.

1352
01:04:38,459 --> 01:04:41,250
יש חבורה של מגניב אחרים
פונקציות שיש לי alloc בסוף,

1353
01:04:41,250 --> 01:04:42,750
והם עומדים לדברים שונים.

1354
01:04:42,750 --> 01:04:43,550

1355
01:04:43,550 --> 01:04:49,050
>> כך שכאשר אתה צריך אחסון צריך
לשרוד יותר הפונקציה הנוכחית שלך כל כך

1356
01:04:49,050 --> 01:04:51,010
שכאשר הנוכחי שלך
פונקציה בורחת,

1357
01:04:51,010 --> 01:04:55,774
עדיין יש לך את הנתונים שב
קיבלתי ממנה, אתה רוצה להשתמש malloc.

1358
01:04:55,774 --> 01:04:57,190
זה יהיה לאתחל אותו בערמה.

1359
01:04:57,190 --> 01:05:00,140
וכמו שאמרתי ולשמור
אומר, תוכל לשמור אותו שם

1360
01:05:00,140 --> 01:05:03,050
עד שאתה אומר את זה בדרך אחרת,
וזה הדבר החשוב כאן.

1361
01:05:03,050 --> 01:05:08,450
>> אז דבר אחד שם לב, ו
זה בדרך כלל באמת חשוב,

1362
01:05:08,450 --> 01:05:13,620
הוא שזה sizeof
הוא סופר שימושי לשימוש

1363
01:05:13,620 --> 01:05:16,440
כי בהתאם לסוג
של מכונה שלך פועל,

1364
01:05:16,440 --> 01:05:22,470
ייתכן שיש לו כמויות משתנות
זיכרון שזה לוקח.

1365
01:05:22,470 --> 01:05:26,870
אז אתה תמיד רוצה גודל של כל כך להשתמש
שאתה לא מכונה תלויה,

1366
01:05:26,870 --> 01:05:30,300
כדי שהקוד שלך
לרוץ על כל מכונה.

1367
01:05:30,300 --> 01:05:32,360
>> וזה רק חלק
כתיבת קוד טוב.

1368
01:05:32,360 --> 01:05:34,610
אם זה עובד במחשב אחד,
אבל לא כל האחרים,

1369
01:05:34,610 --> 01:05:36,440
כמה שימושי הייתה התכנית שלך?

1370
01:05:36,440 --> 01:05:38,420
אז אתה תמיד רוצה
לוודא ולהשתמש sizeof.

1371
01:05:38,420 --> 01:05:41,306
>> קהל: אז זה כמו
גודל של 10 אינץ '[לא ברור]?

1372
01:05:41,306 --> 01:05:43,698
>> 1 דובר: זה הוא בגודל של 10 ints.

1373
01:05:43,698 --> 01:05:44,197
כן.

1374
01:05:44,197 --> 01:05:45,360

1375
01:05:45,360 --> 01:05:48,830
אז גודל של ints יחזור
כמה זה int אחד לקחת.

1376
01:05:48,830 --> 01:05:51,530
או גודל של char, כיצד
הרבה לוקח char אחד.

1377
01:05:51,530 --> 01:05:54,150
ואז כמה בלוקים
של שאתה רוצה?

1378
01:05:54,150 --> 01:05:57,590
>> אז במקרה הזה, אנחנו רוצים משהו
שאנחנו יכולים לאחסן 10 ints ל.

1379
01:05:57,590 --> 01:06:00,240
וזה יעבוד ללא קשר
של מכונה, וזה מגניב.

1380
01:06:00,240 --> 01:06:01,720

1381
01:06:01,720 --> 01:06:04,846
אז כמה בתים יהיו
שבעצם נותן לך?

1382
01:06:04,846 --> 01:06:06,190
מתמטיקה מהירה.

1383
01:06:06,190 --> 01:06:06,787
>> קהל: 40.

1384
01:06:06,787 --> 01:06:07,370
1 SPEAKER: 40.

1385
01:06:07,370 --> 01:06:07,869
בדיוק.

1386
01:06:07,869 --> 01:06:09,520

1387
01:06:09,520 --> 01:06:12,030
אז אחר דבר גדול.

1388
01:06:12,030 --> 01:06:14,840
מצביע או malloc יכול לחזור null.

1389
01:06:14,840 --> 01:06:17,910
>> אז שוב, תמיד לבדוק ל
לראות אם הוא חזר null

1390
01:06:17,910 --> 01:06:19,620
לפני שאתה מנסה לעשות עם זה כלום.

1391
01:06:19,620 --> 01:06:23,430

1392
01:06:23,430 --> 01:06:27,350
אם תנסה וdereference
מצביע זה עכשיו,

1393
01:06:27,350 --> 01:06:29,720
זה פשוט הולך segfault
כי אתה הלך וניסה

1394
01:06:29,720 --> 01:06:31,730
לגעת null כאשר אתה לא צריך.

1395
01:06:31,730 --> 01:06:34,000
אז תמיד לבדוק null.

1396
01:06:34,000 --> 01:06:36,075
שוב, כל מה שאתה יכול לעשות.

1397
01:06:36,075 --> 01:06:38,300

1398
01:06:38,300 --> 01:06:39,720
>> אולי זה יחזיר null.

1399
01:06:39,720 --> 01:06:42,740
זה יחזור null אם אתה או
מתוך שטח, או מכל סיבה

1400
01:06:42,740 --> 01:06:44,350
זה נתקל בכמה באגים זיכרון.

1401
01:06:44,350 --> 01:06:45,890

1402
01:06:45,890 --> 01:06:47,510
לפעמים זה פשוט מחזיר null.

1403
01:06:47,510 --> 01:06:48,990
אז אתה פשוט צריך לבדוק את זה.

1404
01:06:48,990 --> 01:06:51,050
זה כל מה ששקופית שזה אומרת.

1405
01:06:51,050 --> 01:06:53,366

1406
01:06:53,366 --> 01:06:55,240
ואז מה שיש לנו
כאן היא קריאה לשחרור.

1407
01:06:55,240 --> 01:07:00,550
אז באותה הצורה שאם אתה
לפתוח קובץ, עליך לסגור את קובץ,

1408
01:07:00,550 --> 01:07:04,340
אם אתה זיכרון malloc,
עליך לשחרר זיכרון ש.

1409
01:07:04,340 --> 01:07:06,530
ואתם תקבלו
לעשות דברים ממש מגניבים.

1410
01:07:06,530 --> 01:07:09,624
>> ויש תכנית שאתה יכול לרוץ ל
לראות אם אתה אי פעם דולף זיכרון.

1411
01:07:09,624 --> 01:07:11,040
אבל אתה לא רוצה דליפת זיכרון.

1412
01:07:11,040 --> 01:07:11,820
זה ממש רע.

1413
01:07:11,820 --> 01:07:13,191

1414
01:07:13,191 --> 01:07:15,020
רק דברים לבלגן.

1415
01:07:15,020 --> 01:07:20,939
>> זה רע לעשות בדיוק כמו תכנות
חכם לחיסכון בעיצוב.

1416
01:07:20,939 --> 01:07:22,980
אבל זה פשוט סוג גם
רע עבור המחשב שלך.

1417
01:07:22,980 --> 01:07:26,780
דברים כל כך פשוט חופשיים
כאשר אתה Malloc.

1418
01:07:26,780 --> 01:07:28,190

1419
01:07:28,190 --> 01:07:30,210
>> אתם רואים את הסימטריות כאן.

1420
01:07:30,210 --> 01:07:31,180
סופר פשוט.

1421
01:07:31,180 --> 01:07:33,010
רק חינם ולאחר מכן
כל מה שהמצביע שלך,

1422
01:07:33,010 --> 01:07:34,843
מה שמו של
המצביע שלך הוא, וזה

1423
01:07:34,843 --> 01:07:36,710
ידאג לשחרר אותו עבורך.

1424
01:07:36,710 --> 01:07:38,200

1425
01:07:38,200 --> 01:07:38,700
מגניב.

1426
01:07:38,700 --> 01:07:40,410

1427
01:07:40,410 --> 01:07:42,530
>> אז יש לנו את זה.

1428
01:07:42,530 --> 01:07:44,770
אז אנחנו פשוט הולכים ל
ללכת דרך תכנית זו.

1429
01:07:44,770 --> 01:07:46,560
ואז אתם נעשים.

1430
01:07:46,560 --> 01:07:50,240
>> אז פשוט עיקרי [לא ברור].

1431
01:07:50,240 --> 01:07:51,690
אז יש לנו כמה * int מצביע.

1432
01:07:51,690 --> 01:07:53,648
אז יש לנו מצביע
זה הולך להחזיק ints.

1433
01:07:53,648 --> 01:07:54,500

1434
01:07:54,500 --> 01:07:56,170
וכמה ints זה הולך להחזיק?

1435
01:07:56,170 --> 01:07:57,400

1436
01:07:57,400 --> 01:07:58,170
רק אחד.

1437
01:07:58,170 --> 01:07:59,400

1438
01:07:59,400 --> 01:08:01,100
גודל של int.

1439
01:08:01,100 --> 01:08:03,900
>> אנחנו בודקים כדי לראות אם
המצביע הוא null כי זה

1440
01:08:03,900 --> 01:08:06,130
הוא, שאנחנו רוצים לומר לא עושים שום דבר.

1441
01:08:06,130 --> 01:08:07,065
זה רע.

1442
01:08:07,065 --> 01:08:08,130

1443
01:08:08,130 --> 01:08:12,130
אז אנחנו להדפיס איזו שגיאה מ
זיכרון, לרוב לחזור 1,

1444
01:08:12,130 --> 01:08:14,260
כאתם משמשים ל.

1445
01:08:14,260 --> 01:08:17,390
>> ואז יש לנו כאן, אנחנו
dereference המצביע שלנו.

1446
01:08:17,390 --> 01:08:22,840
אז זה אומר שאנחנו הולכים לחנות
משהו במיקום שניתן לנו.

1447
01:08:22,840 --> 01:08:24,350

1448
01:08:24,350 --> 01:08:30,830
Int * מצביע, או malloc, מחזיר את
כתובת שבו מניח בצד זה

1449
01:08:30,830 --> 01:08:31,750
זיכרון בשבילך.

1450
01:08:31,750 --> 01:08:32,830

1451
01:08:32,830 --> 01:08:34,800
אז זה בעצם
נותן לך like-- אם אתה

1452
01:08:34,800 --> 01:08:38,149
חושב על חבורה של
בתים בשכונה

1453
01:08:38,149 --> 01:08:40,640
שאתה רוצה לשים
ברהיטים, malloc שלך

1454
01:08:40,640 --> 01:08:43,850
זה כמו אישור, אתה מקבל
ללכת לבית שלוש.

1455
01:08:43,850 --> 01:08:45,800
וזה נותן לך
כתובת של בית בן שלוש.

1456
01:08:45,800 --> 01:08:48,775
>> אז את זה עכשיו, זה
חנויות מצביע כתובת,

1457
01:08:48,775 --> 01:08:50,149
מאחסן את הכתובת של הבית שלך.

1458
01:08:50,149 --> 01:08:51,470

1459
01:08:51,470 --> 01:08:54,640
* אמצעי PTR, על אישור, אני בבית שלי.

1460
01:08:54,640 --> 01:08:55,326
מגניב.

1461
01:08:55,326 --> 01:08:56,580
אני צריך לקבל קצת מספרים שלמים.

1462
01:08:56,580 --> 01:08:59,229
>> אז אתה שואל על מישהו
כדי לתת לך רהיטים עכשיו.

1463
01:08:59,229 --> 01:09:00,430
אז אתה מקבל כמה int.

1464
01:09:00,430 --> 01:09:05,100
וזה מכניס את המצביע זה
איפה זה מצביע על.

1465
01:09:05,100 --> 01:09:08,670
>> ואז זה פשוט מדפיס
את, אתה נכנס לכל מקום.

1466
01:09:08,670 --> 01:09:11,060
ושוב, ההתייחסות.

1467
01:09:11,060 --> 01:09:15,649
אז זה כמו שאתה נכנס לזה
לטפל וראית מה היה שם.

1468
01:09:15,649 --> 01:09:17,120

1469
01:09:17,120 --> 01:09:17,630
מגניב?

1470
01:09:17,630 --> 01:09:20,174
>> ואז כמובן אנו משחררים המצביע שלנו.

1471
01:09:20,174 --> 01:09:21,590
אל תשכח לשחרר את המצביע שלך.

1472
01:09:21,590 --> 01:09:22,933
אל תשכח לבדוק null.

1473
01:09:22,933 --> 01:09:24,349
אל תשכח לשחרר את המצביע שלך.

1474
01:09:24,349 --> 01:09:27,270
יש לך שני דברים שאתה זוכר מ
זה, או שאתה צריך לזכור.

1475
01:09:27,270 --> 01:09:27,770
כן.

1476
01:09:27,770 --> 01:09:31,590
קהל: [לא ברור] דברים
כמו ש, char * s.

1477
01:09:31,590 --> 01:09:33,760
איך אנחנו אף פעם לא באים בחינם אלה?

1478
01:09:33,760 --> 01:09:34,529
>> 1 SPEAKER: Hm?

1479
01:09:34,529 --> 01:09:36,450
>> קהל: הם אלה כמו מחרוזות?

1480
01:09:36,450 --> 01:09:39,160
אתה אמר מייתרים
בדיוק כמו char * s, נכון?

1481
01:09:39,160 --> 01:09:41,200
אז למה אנחנו לא לשחרר את המיתרים?

1482
01:09:41,200 --> 01:09:43,204
>> SPEAKER 1: אתה רק ל
בחינם אם אתה mallocing.

1483
01:09:43,204 --> 01:09:44,620
קהל: אה, אם אתה mallocing.

1484
01:09:44,620 --> 01:09:47,399
SPEAKER 1: אז malloc
וחופשי הם שני דברים

1485
01:09:47,399 --> 01:09:49,000
כי אתה צריך תמיד יש ביחד.

1486
01:09:49,000 --> 01:09:51,630
ו פתוח קרוב ו,, שני דברים
צריך להיות לך ביחד.

1487
01:09:51,630 --> 01:09:54,471
בשני המקרים האלה, לבדוק null.

1488
01:09:54,471 --> 01:09:54,971
כן.

1489
01:09:54,971 --> 01:09:57,130
>> קהל: אז חופשי הוא רק
מאפשר משהו אחר

1490
01:09:57,130 --> 01:09:59,690
להיות מאוחסן שם אחרי
תכנית זו השתמשה בו?

1491
01:09:59,690 --> 01:10:01,946
>> 1 SPEAKER: זה רק אומר,
אישור, אני גמרתי עם זה.

1492
01:10:01,946 --> 01:10:03,320
אתה לא צריך לשמור את זה בסביבה.

1493
01:10:03,320 --> 01:10:05,340

1494
01:10:05,340 --> 01:10:08,190
אחרת המחשב שלך
בדיוק כמו לנסות ולשמור אותו שם.

1495
01:10:08,190 --> 01:10:10,910
ואז אתה can't-- הוא פועל
לבעיות זיכרון בהמשך.

1496
01:10:10,910 --> 01:10:13,660
אתה תמיד רוצה לשחרר אותו כי
זה אומר לי המחשב, על אישור, אני

1497
01:10:13,660 --> 01:10:15,190
לעשות עם המקום הזה של זיכרון.

1498
01:10:15,190 --> 01:10:17,190
אתה יכול לקבל אותו בחזרה
עבורי לשימוש מאוחר יותר.

1499
01:10:17,190 --> 01:10:19,250

1500
01:10:19,250 --> 01:10:20,500
מגניב?

1501
01:10:20,500 --> 01:10:21,320
כן.

1502
01:10:21,320 --> 01:10:26,950
>> קהל: אז השתמשנו ב% d רק
בגלל כפול שחוזר,

1503
01:10:26,950 --> 01:10:28,330
או למה [לא ברור] is--.

1504
01:10:28,330 --> 01:10:30,170

1505
01:10:30,170 --> 01:10:31,620
>> קהל: אתה יכול להשתמש ב% i?

1506
01:10:31,620 --> 01:10:32,760
>> 1 SPEAKER: ניתן להשתמש% i.

1507
01:10:32,760 --> 01:10:35,052

1508
01:10:35,052 --> 01:10:36,135
כל שאלות רגע האחרונות?

1509
01:10:36,135 --> 01:10:38,310

1510
01:10:38,310 --> 01:10:38,985
קדימה.

1511
01:10:38,985 --> 01:10:40,610
קהל: יש לי רק שאלה מהירה.

1512
01:10:40,610 --> 01:10:50,200
אז משתנה PTR, that's--
כמו, עם ptr = malloc * int,

1513
01:10:50,200 --> 01:10:54,142
זה פשוט אומר שזה
מצביע על מקום בmemory--

1514
01:10:54,142 --> 01:10:55,600
SPEAKER 1: האם אתה רוצה [לא ברור]?

1515
01:10:55,600 --> 01:10:58,050
קהל: --that זה
גודל ל-- לא, זה בסדר.

1516
01:10:58,050 --> 01:11:01,292
אבל זה רק מצביע על מקום ב
זיכרון זה בדיוק כמו ארבעה בתים.

1517
01:11:01,292 --> 01:11:02,000
1 SPEAKER: נכון.

1518
01:11:02,000 --> 01:11:03,030

1519
01:11:03,030 --> 01:11:07,070
אז malloc הגודל של int אומר,
בסדר, אני הולך לברוח,

1520
01:11:07,070 --> 01:11:08,780
למצוא ארבעה בתים של זיכרון בשבילך.

1521
01:11:08,780 --> 01:11:10,700
כאשר היא מגלה כי ארבעה
בתים של זיכרון, זה

1522
01:11:10,700 --> 01:11:14,030
נותן לך בחזרה את הכתובת
היכן זה מתחיל,

1523
01:11:14,030 --> 01:11:16,160
וזה מה שמאוחסן
במצביע, או PTR.

1524
01:11:16,160 --> 01:11:17,510

1525
01:11:17,510 --> 01:11:18,010
טוב.

1526
01:11:18,010 --> 01:11:18,742

1527
01:11:18,742 --> 01:11:21,700
אתם נראים פחות מבולבלים ממה שרוב
אנשים כשאני מדבר על מצביע,

1528
01:11:21,700 --> 01:11:23,670
אז אני מרגיש די טוב עכשיו.

1529
01:11:23,670 --> 01:11:24,520
>> בְּסֵדֶר.

1530
01:11:24,520 --> 01:11:27,960
כמו תמיד, אתם צריכים את כל
להוציא ציוני pset2 שלך עד עכשיו.

1531
01:11:27,960 --> 01:11:32,769
אני יודע שיש כבר כמה רופף
דברים שבו כתוב, נוסחה לא תקפה

1532
01:11:32,769 --> 01:11:33,310
או משהו.

1533
01:11:33,310 --> 01:11:36,166
אם אתה מקבל את זה, כל
הציונים שלך הם חוקיים בצד שלי.

1534
01:11:36,166 --> 01:11:38,040
אז אני יכול לשלוח לך
צילומי מסך של הציונים שלך.

1535
01:11:38,040 --> 01:11:39,011

1536
01:11:39,011 --> 01:11:41,760
רק תודיע לי גם אם אתה
חסר כל ציונים או משהו

1537
01:11:41,760 --> 01:11:43,060
לא נראה הגיוני.

1538
01:11:43,060 --> 01:11:43,720
בואו אליי.

1539
01:11:43,720 --> 01:11:44,830

1540
01:11:44,830 --> 01:11:48,830
>> אני כבר סופר גאה בך
בחורים כבר, אז לשמור את זה.

1541
01:11:48,830 --> 01:11:50,640
ולנוח טוב של השבוע שלך.

1542
01:11:50,640 --> 01:11:53,440
אני בטוח שאני תראה את חלק
שלך בשעתי עבודה.

1543
01:11:53,440 --> 01:11:55,414