1
00:00:00,000 --> 00:00:00,960

2
00:00:00,960 --> 00:00:03,360
>> [השמעת מוסיקה]

3
00:00:03,360 --> 00:00:11,050

4
00:00:11,050 --> 00:00:12,065
>> דווין: בסדר, בחורים.

5
00:00:12,065 --> 00:00:13,642

6
00:00:13,642 --> 00:00:15,350
אז זה הסקירה
לחידון הראשון.

7
00:00:15,350 --> 00:00:17,751
האם כולם מוכנים ל
החידון ביום רביעי?

8
00:00:17,751 --> 00:00:18,292
אליסון: וו!

9
00:00:18,292 --> 00:00:18,743
תלמיד: וו!

10
00:00:18,743 --> 00:00:19,242
דווין: כן.

11
00:00:19,242 --> 00:00:19,920
אליסון: כן!

12
00:00:19,920 --> 00:00:20,920
דווין: s מוכן הבחור הזה.

13
00:00:20,920 --> 00:00:22,200
בחור ש, שתי ידיים, נחמד.

14
00:00:22,200 --> 00:00:23,234

15
00:00:23,234 --> 00:00:25,900
אז סקירת חידון היום, זה הולך
להיות כשעה וחצי.

16
00:00:25,900 --> 00:00:27,940
אנחנו הולכים לעבור על כל גדולים
מושגים שאתם צריכים לדעת לחידון.

17
00:00:27,940 --> 00:00:31,434
אנחנו הולכים לעבור על כמה קידוד על ידי
דוגמאות יד, הנמצאות בכל חידון.

18
00:00:31,434 --> 00:00:34,350
ואם יש לך שאלות, תרגיש חופשי
להרים את היד שלך והכל

19
00:00:34,350 --> 00:00:34,945
כמו ש.

20
00:00:34,945 --> 00:00:36,695
ובכן, לוגיסטיקה על
החידון מקוון.

21
00:00:36,695 --> 00:00:38,450
אז אנחנו הולכים לפצל אנשים
עד לחדרים שונים.

22
00:00:38,450 --> 00:00:39,491
הוא מבוסס על שמם.

23
00:00:39,491 --> 00:00:43,630
אז אם יש לך שאלות לגבי איפה
ללכת או על מה הוא חומר, כמו,

24
00:00:43,630 --> 00:00:46,810
המילה הרשמית על מה שקורה
כדי להיות בחידון, לבדוק באינטרנט.

25
00:00:46,810 --> 00:00:48,420
וזה כל מה מעודכן.

26
00:00:48,420 --> 00:00:51,280
אז אם אין שאלות ל
ראשית, אנחנו הולכים להתחיל.

27
00:00:51,280 --> 00:00:52,790

28
00:00:52,790 --> 00:00:53,710
והנה אליסון.

29
00:00:53,710 --> 00:00:56,060

30
00:00:56,060 --> 00:00:57,000
>> [מחיאות כפות]

31
00:00:57,000 --> 00:00:59,300
>> אליסון: בסדר, תודה, רוב.

32
00:00:59,300 --> 00:01:00,280
מעריך את זה.

33
00:01:00,280 --> 00:01:01,350

34
00:01:01,350 --> 00:01:03,050
דווין צריך התהפך לזה.

35
00:01:03,050 --> 00:01:07,240
זוהי הרשימה בלתי ממצה של
נושאים, כמו תמיד, כמו דווין אמר רק.

36
00:01:07,240 --> 00:01:10,860
עיין בתיעוד של
באינטרנט על חידון אפס.

37
00:01:10,860 --> 00:01:13,680
אבל זה די much--
זה הופיע בתכנית הלימודים

38
00:01:13,680 --> 00:01:15,550
הוא כל מה שעברנו על עד כה.

39
00:01:15,550 --> 00:01:18,290
הכל כאן משחק הוגן,
כמו גם כל דבר אחר

40
00:01:18,290 --> 00:01:21,380
שייתכן שהוזכר בהרצאה.

41
00:01:21,380 --> 00:01:25,070
>> הסעיף שלי, כאן, הוא
רק הרבה של ביקורת.

42
00:01:25,070 --> 00:01:27,775
ישנם כמה תרגילים
כי אתם יכולים לעבוד על.

43
00:01:27,775 --> 00:01:30,650
אבל על פי רוב, אנחנו באמת
רוצה להגיע לדווין עם קוד אלה

44
00:01:30,650 --> 00:01:31,710
על ידי תרגילי יד.

45
00:01:31,710 --> 00:01:33,940
>> אז אני הולך לעוף בזה.

46
00:01:33,940 --> 00:01:36,330
אם יש לך שאלות, לעצור אותי.

47
00:01:36,330 --> 00:01:37,270
הרם את ידך.

48
00:01:37,270 --> 00:01:39,250
אני מבטיח שאני בטח אראה אותך.

49
00:01:39,250 --> 00:01:41,042
אם לא, פשוט לנפנף אותו.

50
00:01:41,042 --> 00:01:42,250
אני הולך לדבר מהר.

51
00:01:42,250 --> 00:01:43,950
אני מקווה שכולם בסדר עם זה.

52
00:01:43,950 --> 00:01:48,020
>> אישור, מילה מיוחדת, דווין ברור
שכחתי לדפדף שקופיות אלה.

53
00:01:48,020 --> 00:01:51,880
[צוחק] אתה בצרות, גבר.

54
00:01:51,880 --> 00:01:55,770
אז טיפים לחידון אפס,
לתרגל קידוד על נייר.

55
00:01:55,770 --> 00:01:58,950
אתם הולכים לקבל קצת
להתאמן עם זה עכשיו עם דיווין,

56
00:01:58,950 --> 00:02:00,655
כדי שלא להיות לגמרי בעצמך.

57
00:02:00,655 --> 00:02:03,030
אני חושב שאנחנו עומדים
באמצעות שתי הפונקציות הללו.

58
00:02:03,030 --> 00:02:04,500
אז אתה תהיה מוכן לשם גם.

59
00:02:04,500 --> 00:02:05,958
>> להיות מוכר עם סטי הבעיה שלך.

60
00:02:05,958 --> 00:02:08,150
נשאלו שאלות
בחידונים קודמים

61
00:02:08,150 --> 00:02:12,680
שישאל אותך, למשל, לקוד
משהו דומה מאוד למריו.

62
00:02:12,680 --> 00:02:15,060
אז להיות מאוד מוכר עם
הבעיה שלך קובעת, כמו גם

63
00:02:15,060 --> 00:02:17,827
כשאלות שאנו שואלים אותך
בתחילת בטופס

64
00:02:17,827 --> 00:02:19,660
כי לך למלא, יהיה
ישרת אותך היטב.

65
00:02:19,660 --> 00:02:20,940

66
00:02:20,940 --> 00:02:23,380
>> האם חידון קודם תחת
אילוצי הזמן.

67
00:02:23,380 --> 00:02:25,430
חידונים אלה הם ארוכים.

68
00:02:25,430 --> 00:02:26,850
הזמן עובר ממש מהר.

69
00:02:26,850 --> 00:02:30,480
ולעתים קרובות, אתה לא מבין עד כמה
מהר זה הולך עד שאתה בעצם

70
00:02:30,480 --> 00:02:32,180
לשים את עצמך תחת אילוצים אלה.

71
00:02:32,180 --> 00:02:36,500
אז אם אתה יכול רק לסלול את, אתה יודע,
בדקה ה -75, או ערב או מחר

72
00:02:36,500 --> 00:02:41,020
לקחת את אחד השאלונים הללו תחת
כי, אתה תהיה במצב הרבה יותר טוב.

73
00:02:41,020 --> 00:02:43,060
>> וגם, יצירת גיליון ההתייחסות שלך.

74
00:02:43,060 --> 00:02:45,290
זכור, אתה מקבל אחד
העמוד ראשון ובחזרה

75
00:02:45,290 --> 00:02:47,040
כהתייחסות לחידון שלך ביום רביעי.

76
00:02:47,040 --> 00:02:49,074
יצירה שהיא דרך מצוינת ללמוד.

77
00:02:49,074 --> 00:02:51,990
כל דבר שאתה נתקלת בבעיה
עם ברצונך לכלול שם.

78
00:02:51,990 --> 00:02:55,627
כל דבר שTFS שלך היה,
כאילו, זה באמת חשוב.

79
00:02:55,627 --> 00:02:57,960
אתה צריך לדעת את זה, הם
אולי דברים שיש לך שם

80
00:02:57,960 --> 00:02:59,931
אם אין לך אותם בזיכרון.

81
00:02:59,931 --> 00:03:02,680
גם אם אתה מכיר אותם באמת
טוב, לפעמים שיש את זה שם

82
00:03:02,680 --> 00:03:07,030
הוא פשוט סוג של נחמה בשבילך,
שאני יודע חידונים הם מלחיצים.

83
00:03:07,030 --> 00:03:09,260
אז כל נוחות שאתה מקבל יכול לעזור.

84
00:03:09,260 --> 00:03:13,072
בסדר, גם, לישון ו
לאכול ואוהבים את הדברים הרגילים

85
00:03:13,072 --> 00:03:14,280
שאנו אומרים לכם לחידונים.

86
00:03:14,280 --> 00:03:16,320

87
00:03:16,320 --> 00:03:18,890
>> אז החל בצורה קלה,
סוגי נתונים וגדלים.

88
00:03:18,890 --> 00:03:22,720
כפי שאמרתי, זה רק הולך
להיות לי לזרוק הרבה דברים

89
00:03:22,720 --> 00:03:24,320
עד כאן שאתה צריך לדעת.

90
00:03:24,320 --> 00:03:27,600
אז יש לנו התווים שלנו
כי אחד בתים, ints

91
00:03:27,600 --> 00:03:30,390
כי הם ארבעה בתים, ארוכים
ארוך, שהם שמונה בתים.

92
00:03:30,390 --> 00:03:33,280
בעיקרון, זה רק אתה
רוצה להחזיק את מספרים שלמים גדולים יותר.

93
00:03:33,280 --> 00:03:35,490
צף, שהם ארבעה,
זוגות, שהם שמונה.

94
00:03:35,490 --> 00:03:38,150
שוב, רק נותן לך יותר
מקום לצפת.

95
00:03:38,150 --> 00:03:41,290
ולאחר מכן הקלד כוכב, כך שכל
מצביע על מכונה 32 ביט,

96
00:03:41,290 --> 00:03:44,650
וזה כל מה שאתם צריכים
לדעת, הוא ארבעה בתים.

97
00:03:44,650 --> 00:03:46,542
>> אז כל הדברים שאתה צריך
יודע, אולי דברים

98
00:03:46,542 --> 00:03:48,250
אתה רוצה להיות ב
גיליון ההתייחסות שלך.

99
00:03:48,250 --> 00:03:50,350

100
00:03:50,350 --> 00:03:53,520
אישור, המרת ינארי
לינארי, המרה

101
00:03:53,520 --> 00:03:56,860
להקסדצימלי, הלוך ושוב,
כל הדברים שכדאי לדעת.

102
00:03:56,860 --> 00:03:59,480
אז בינארי לעשרוני.

103
00:03:59,480 --> 00:04:03,309
אתם רוצים לקחת את דקה מהירה
ולנסות להבין כל אחד מאלה

104
00:04:03,309 --> 00:04:04,600
ואז תגיד לי מה הם?

105
00:04:04,600 --> 00:04:06,500

106
00:04:06,500 --> 00:04:10,240
>> יש לי גם סוכריות בתיק שלי, כך שכל אחד
מי עונה מקבל ממתקים, דרך אגב.

107
00:04:10,240 --> 00:04:13,560

108
00:04:13,560 --> 00:04:14,480
ויש לי הרבה ממנו.

109
00:04:14,480 --> 00:04:15,760

110
00:04:15,760 --> 00:04:16,870
תן לי לתפוס את זה.

111
00:04:16,870 --> 00:04:18,480
אני הולך לתת את זה לגייב.

112
00:04:18,480 --> 00:04:21,829
אז אתה יכול לחלק את ממתקים ל
מי שנחמד ושיתופי.

113
00:04:21,829 --> 00:04:23,490
>> אישור, ראיתי שני יש בחלק האחורי.

114
00:04:23,490 --> 00:04:26,418

115
00:04:26,418 --> 00:04:28,370
>> תלמיד: כן, הראשון הוא 42.

116
00:04:28,370 --> 00:04:30,280
>> אליסון: כן, ראשון הוא 42, נכון.

117
00:04:30,280 --> 00:04:31,163

118
00:04:31,163 --> 00:04:32,038
תלמיד: [לא ברור].

119
00:04:32,038 --> 00:04:34,810
[שחוק]

120
00:04:34,810 --> 00:04:37,030
אליסון: שני אחת,
יש חזרה בצהוב?

121
00:04:37,030 --> 00:04:38,910
תלמיד: 110010.

122
00:04:38,910 --> 00:04:43,410
אליסון: נכון, וזה
אחרון, כאן למטה בתחתית?

123
00:04:43,410 --> 00:04:44,570
כמו כן, כן, אתה יודע רוצה?

124
00:04:44,570 --> 00:04:45,550
פשוט לזרוק את סוכריות.

125
00:04:45,550 --> 00:04:46,483
מה דעתך על ממתקים לכולם?

126
00:04:46,483 --> 00:04:47,510
>> תלמיד: [לא ברור] לאחר שנסיים.

127
00:04:47,510 --> 00:04:48,051
>> אליסון: ששש.

128
00:04:48,051 --> 00:04:49,380

129
00:04:49,380 --> 00:04:50,910
ולאחר מכן עבר אחד.

130
00:04:50,910 --> 00:04:52,000
מי רוצה לענות?

131
00:04:52,000 --> 00:04:52,744
בדיוק שם.

132
00:04:52,744 --> 00:04:54,480
>> תלמיד: 11100.

133
00:04:54,480 --> 00:04:56,820
>> אליסון: 11100, להסתכל על זה.

134
00:04:56,820 --> 00:04:58,790
מזל טוב, עבודה נהדרת, כולם.

135
00:04:58,790 --> 00:05:03,370
אישור, כולם סוג של הבנה
התהליך לעושה את זה?

136
00:05:03,370 --> 00:05:08,700
יש לך, הולך בינארי לעשרוני
כפי שאני נוהג לעשות את זה, כותב את

137
00:05:08,700 --> 00:05:09,920
החזקות של 2.

138
00:05:09,920 --> 00:05:18,350
אז אני אומר, בסדר, 0 פעמים 2-0, כך
זה 0, 1 פי 2 עד הראשון,

139
00:05:18,350 --> 00:05:21,400
הוא 2 הולכים ואילך דרך.

140
00:05:21,400 --> 00:05:25,790
האם מישהו רוצה שאני במפורש
לעבור דוגמא לינארי?

141
00:05:25,790 --> 00:05:26,840

142
00:05:26,840 --> 00:05:28,140
אישור, מגניב.

143
00:05:28,140 --> 00:05:30,390
>> עשרוני בינארי הוא דומה מאוד.

144
00:05:30,390 --> 00:05:31,550

145
00:05:31,550 --> 00:05:33,630
אני נוטה לכתוב את החזקות של 2.

146
00:05:33,630 --> 00:05:38,660
התחל עם אחד שהוא הגדול ביותר,
אך אינו עובר את הנקודה העשרונית

147
00:05:38,660 --> 00:05:39,710
שאתה מחפש.

148
00:05:39,710 --> 00:05:42,870
ולאחר מכן סוג של דרך העבודה שלך
לאחור והוסיף את דברים כמו צורך.

149
00:05:42,870 --> 00:05:45,200
>> ולאחר מכן עם תוספת, זה
בדיוק כמו בנוסף נורמלי.

150
00:05:45,200 --> 00:05:51,110
אם אי פעם יש לך את המקרה שבו אתה
הוספת שני 1s, זה כמובן הופך 2.

151
00:05:51,110 --> 00:05:56,875
2 בינארי כרגע הוא 1 0 כך שאתה צריך
לבצע 1 שלך לטור הבא.

152
00:05:56,875 --> 00:05:57,375
מגניב.

153
00:05:57,375 --> 00:05:59,220

154
00:05:59,220 --> 00:06:03,240
>> הקסדצימלי, זה יכול להיות משהו
כי הוא מעט פחות מוכר.

155
00:06:03,240 --> 00:06:06,600
אז כפי שרוב בדיוק ספר לי
לפני כן, הטריק שלו לזה

156
00:06:06,600 --> 00:06:10,210
רק לפצל אותה
לארבעה נתחים בייט, בסדר?

157
00:06:10,210 --> 00:06:11,050
ביטים, מצטער.

158
00:06:11,050 --> 00:06:11,720
רואה?

159
00:06:11,720 --> 00:06:12,220
תודה רוב.

160
00:06:12,220 --> 00:06:15,874
זו הסיבה שאתה כאן. [רעש]
אוקיי, אז אנחנו פשוט לשבור אותו

161
00:06:15,874 --> 00:06:16,790
לארבעה נתחים סיביות.

162
00:06:16,790 --> 00:06:21,570
אז עם קבצים בינאריים להקסדצימלי,
אנחנו מסתכלים הראשונים 4,

163
00:06:21,570 --> 00:06:25,573
וזה אם יש לנו ארבעה 1s ב
שורה, מה מספר האם זה מסמל?

164
00:06:25,573 --> 00:06:26,540
>> תלמיד: פ

165
00:06:26,540 --> 00:06:32,751
>> אליסון: אז במקרה הזה,
מה הוא 11111111 or-- כן?

166
00:06:32,751 --> 00:06:33,250
תלמיד: FF.

167
00:06:33,250 --> 00:06:34,600
אליסון: מושלם, FF.

168
00:06:34,600 --> 00:06:36,900
כל כך גדול, ממתקים בשבילך.

169
00:06:36,900 --> 00:06:41,100
עכשיו, איך הקסדצימלי לינארי, אנו
רק תחשוב על זה סוג של בכיוון הפוך.

170
00:06:41,100 --> 00:06:46,420
עבור כל מספר או אות ש
יש לנו בהקסדצימלי שלנו,

171
00:06:46,420 --> 00:06:53,930
רק להמיר אותו לשלה ארבעה קצת
[צוחק] להמרת ארבעה קצת שלה.

172
00:06:53,930 --> 00:06:58,696
אז 5, במקרה זה, מה הוא 5 אם
אנחנו מייצגים אותו עם ארבע חתיכות?

173
00:06:58,696 --> 00:06:59,608
>> תלמיד: 010?

174
00:06:59,608 --> 00:07:00,520
ממ-הממ.

175
00:07:00,520 --> 00:07:03,605
ולאחר מכן, שהוא
למעשה 10, יהיה?

176
00:07:03,605 --> 00:07:06,230

177
00:07:06,230 --> 00:07:08,040
1010.

178
00:07:08,040 --> 00:07:09,670
אז יש לנו את זה, כאן.

179
00:07:09,670 --> 00:07:13,990
אז המרה בין הקסדצימלי
ו בינארית היא בעצם לא כל כך רעה.

180
00:07:13,990 --> 00:07:16,565
אם אתה מסתכל על זה בארבעה קצת
נתחים, הולכים להיות זהב.

181
00:07:16,565 --> 00:07:18,330

182
00:07:18,330 --> 00:07:19,300
Everyone-- כן?

183
00:07:19,300 --> 00:07:21,903
>> ROB: זה טיפשי,
אבל אני תמיד זוכר

184
00:07:21,903 --> 00:07:23,500
, מאז של אמור להיות 10.

185
00:07:23,500 --> 00:07:26,230
ובינארי פשוט 10 10, אז--

186
00:07:26,230 --> 00:07:27,310
>> אליסון: אה, יש לנו ללכת.

187
00:07:27,310 --> 00:07:28,615
>> ROB: היי.

188
00:07:28,615 --> 00:07:30,020
>> אליסון: היי, ממתקים לרוב.

189
00:07:30,020 --> 00:07:31,707

190
00:07:31,707 --> 00:07:33,290
יש דברים שאינם שוקולד שם.

191
00:07:33,290 --> 00:07:34,180
אז אתה יכול לקבל קצת.

192
00:07:34,180 --> 00:07:35,790

193
00:07:35,790 --> 00:07:36,760
מתמטיקה אז ASCII.

194
00:07:36,760 --> 00:07:38,206

195
00:07:38,206 --> 00:07:38,705
להתנהג.

196
00:07:38,705 --> 00:07:40,630

197
00:07:40,630 --> 00:07:44,720
אז המתמטיקה ASCII, כפי שאתם
כנראה זוכר היטב

198
00:07:44,720 --> 00:07:48,480
p להגדיר 2 עם VISIONEER ו
קיסר, שעשית הרבה זה.

199
00:07:48,480 --> 00:07:49,610

200
00:07:49,610 --> 00:07:51,980
זכור, הדמויות
ביסודו רק מספרים.

201
00:07:51,980 --> 00:07:54,780
אז אנחנו יכולים לעשות את המתמטיקה איתם,
בדיוק כמו שאנחנו עושים במתמטיקה עם ints.

202
00:07:54,780 --> 00:07:58,090
>> אז יש לנו רק קצת
דבר פשוט כאן.

203
00:07:58,090 --> 00:08:00,940
יש לנו כמה בזה
אותחל ל -65.

204
00:08:00,940 --> 00:08:07,440
ו- B שווה לערך ASCII של
בתוספת 1, C char שווה D מינוס 1,

205
00:08:07,440 --> 00:08:09,060
וD char שווה 68.

206
00:08:09,060 --> 00:08:13,130
אז אנחנו הולכים להדפסה
כולם, כפי שאנו רואים כאן.

207
00:08:13,130 --> 00:08:15,650
ומישהו יכול להגיד לי
מה זה יהיה להדפיס?

208
00:08:15,650 --> 00:08:17,335

209
00:08:17,335 --> 00:08:18,210
תלמיד: [לא ברור].

210
00:08:18,210 --> 00:08:20,540
אליסון: בדיוק, כל כך
דבר אחד שיבחין

211
00:08:20,540 --> 00:08:22,900
שאנחנו מדפיסים את
תווים בכל פעם, כאן.

212
00:08:22,900 --> 00:08:28,290
אנו מייעדים למרות שA ו- B
הם ints כאשר אנו הכריזו עליהם לעיל.

213
00:08:28,290 --> 00:08:32,870
אנחנו מדפיסים אותם כדמויות על ידי
C אחוזים והצהרת printf שלנו,

214
00:08:32,870 --> 00:08:34,610
ולכן הם כל יודפסו בתווים.

215
00:08:34,610 --> 00:08:40,730
וכמובן, רצון ערך ASCII 65
להדפיס כא ערך ASCII של פלוס 1

216
00:08:40,730 --> 00:08:43,669
יהיו 66, אשר היו
גאים ב 'כך שלמעשה, אנחנו

217
00:08:43,669 --> 00:08:49,107
תקבל כולם א ב ג ד טוב שם?

218
00:08:49,107 --> 00:08:49,690
שאלות?

219
00:08:49,690 --> 00:08:50,721

220
00:08:50,721 --> 00:08:51,220
מדהים.

221
00:08:51,220 --> 00:08:52,500

222
00:08:52,500 --> 00:08:53,455
>> אישור, היקף.

223
00:08:53,455 --> 00:08:55,090

224
00:08:55,090 --> 00:08:59,950
אז ההיקף הוא ללא ספק מאוד
דבר חשוב להבין, כאן.

225
00:08:59,950 --> 00:09:03,250
הרבה מכם, אם אתה
יש שגיאות קומפילציה,

226
00:09:03,250 --> 00:09:06,085
וזה אומר שאין לך
גישה לחלק משתנה,

227
00:09:06,085 --> 00:09:08,540
זה כנראה בגלל שאתה
הגדיר אותו בתוך לולאה

228
00:09:08,540 --> 00:09:12,210
ולאחר מכן ניסיתי לגשת אליו
מחוץ לזה, או להיפך.

229
00:09:12,210 --> 00:09:16,410
>> אז היקף בליבה שלה,
זה פשוט קובע בי

230
00:09:16,410 --> 00:09:20,800
אנו אומרים משתנים קיימים, שבו אנו
יכול לשנות את זה, שבו אנו יכולים לגשת אליו.

231
00:09:20,800 --> 00:09:24,550
זה פשוט סוג של אמירה אלה
המקומות היחידים שבו יש לך גישה

232
00:09:24,550 --> 00:09:26,060
למשתנה זה.

233
00:09:26,060 --> 00:09:30,080
>> אז שני טווחים שאנחנו מדברים על
במהלך השיעור הם גלובליים ומקומיים.

234
00:09:30,080 --> 00:09:35,080
משתנים גלובליים אז אנחנו מדברים על
כאשר אתם מגדירים אותם מעל עיקריים.

235
00:09:35,080 --> 00:09:38,390
זה אומר שכולו שלך
יש תכנית גישה אליו,

236
00:09:38,390 --> 00:09:42,090
והיא קיימת לעוד
כפועל תכנית, בסדר?

237
00:09:42,090 --> 00:09:45,100
מקומי אומר שזה
יותר מרותק לאזור.

238
00:09:45,100 --> 00:09:50,520
אז בכל פעם שיש לך פונקציות ספציפיות
כמו החלפה, אנחנו תמיד מדברים על.

239
00:09:50,520 --> 00:09:54,380
אנחנו תמיד מדברים על החלפות עם ו
ב 'ו-ב' קיימים בתוך הפונקציה ש.

240
00:09:54,380 --> 00:09:55,690
הם לא קיימים בשום מקום אחר.

241
00:09:55,690 --> 00:09:56,860

242
00:09:56,860 --> 00:10:00,610
>> כמו גם, כאשר יש לך אם
הצהרות או ללולאות.

243
00:10:00,610 --> 00:10:04,670
בכל פעם שיש לנו, למשל, ב
ללולאה שיש לנו int אני שווה 0.

244
00:10:04,670 --> 00:10:06,630
יש לנו כמה מצב ואנחנו מעדכנים אותו.

245
00:10:06,630 --> 00:10:10,270
אני קיים רק בתוך
פלטה של ​​שללולאה.

246
00:10:10,270 --> 00:10:13,270
אם אתה מנסה לגשת אליו במקום אחר,
המהדר שלך היה צועק עליך.

247
00:10:13,270 --> 00:10:14,560
זה יהיה כמו, מה אתה מנסה לעשות?

248
00:10:14,560 --> 00:10:15,400
זה לא קיים.

249
00:10:15,400 --> 00:10:16,644

250
00:10:16,644 --> 00:10:18,435
אז זה שני
סוגים שונים של היקף.

251
00:10:18,435 --> 00:10:19,486

252
00:10:19,486 --> 00:10:20,860
האם זה הגיוני לכולם?

253
00:10:20,860 --> 00:10:23,870

254
00:10:23,870 --> 00:10:27,890
>> כך למשל כאן, זה
הוא רק חלק תכנית פשוטה.

255
00:10:27,890 --> 00:10:29,120

256
00:10:29,120 --> 00:10:32,890
מה אתם חושבים הוא
הולך לקרות בכל נקודה

257
00:10:32,890 --> 00:10:34,210
כי אנחנו מנסים להדפיס?

258
00:10:34,210 --> 00:10:40,150
אז זה כאן,
מה הולך לקרות?

259
00:10:40,150 --> 00:10:43,047

260
00:10:43,047 --> 00:10:44,255
תלמיד: זה יהיה להדפיס שלוש.

261
00:10:44,255 --> 00:10:44,880
אליסון: נכון.

262
00:10:44,880 --> 00:10:45,930
זה יהיה להדפיס שלוש.

263
00:10:45,930 --> 00:10:47,272
מה לגבי כאן?

264
00:10:47,272 --> 00:10:48,230
תלמיד: זה לא יעבוד.

265
00:10:48,230 --> 00:10:48,910
אליסון: זה לא יעבוד.

266
00:10:48,910 --> 00:10:50,290
אתה מחוץ לתחום, נכון?

267
00:10:50,290 --> 00:10:55,160
משתנה מקומי לא קיימת
מחוץ לסוגריים אלה, בסדר?

268
00:10:55,160 --> 00:10:56,462
ואז מה כאן?

269
00:10:56,462 --> 00:10:57,850
>> תלמיד: [לא ברור].

270
00:10:57,850 --> 00:10:59,210
>> אליסון: מה?

271
00:10:59,210 --> 00:10:59,900
רוב, ללכת.

272
00:10:59,900 --> 00:11:00,854
>> ROB: אני רק אמרתי.

273
00:11:00,854 --> 00:11:04,200
משתנים גלובלי צריכים להיות
משתנה תחתון הגלובלי.

274
00:11:04,200 --> 00:11:05,660
>> אליסון: אה, כן, מצטער.

275
00:11:05,660 --> 00:11:06,200
תודה, רוב.

276
00:11:06,200 --> 00:11:07,480

277
00:11:07,480 --> 00:11:10,170
רוב של כמו קומפיילר התושב שלנו.

278
00:11:10,170 --> 00:11:12,684
הוא פשוט לצעוק עלינו כאשר אנו
צריכים את זה. [צוחק] כן, ש

279
00:11:12,684 --> 00:11:14,225
צריך להיות משתנים תחתון הגלובלי.

280
00:11:14,225 --> 00:11:15,760

281
00:11:15,760 --> 00:11:18,430
אז בהנחה ש
תחתון הגלובלי היה

282
00:11:18,430 --> 00:11:20,260
משתנה, מה שהולך לקרות כאן?

283
00:11:20,260 --> 00:11:21,260
תלמיד: זה יעבוד.

284
00:11:21,260 --> 00:11:22,093
אליסון: זה עובד.

285
00:11:22,093 --> 00:11:24,655
אז זה יהיה להדפיס, כל כך פשוט
דוגמא פשוטה מאוד.

286
00:11:24,655 --> 00:11:27,650

287
00:11:27,650 --> 00:11:29,870
אישור, אב טיפוס.

288
00:11:29,870 --> 00:11:33,680
אז ברור, שאנחנו באמת
להדגיש בשבילכם

289
00:11:33,680 --> 00:11:36,460
כדי להפוך את הפונקציות אם זה
הגיוני בתוכניות שלך.

290
00:11:36,460 --> 00:11:38,460
אבל כמובן, כאשר אתה
להפוך את הפונקציות משלך,

291
00:11:38,460 --> 00:11:40,930
בדרך כלל אתה מגדיר אותם לאחר עיקרי.

292
00:11:40,930 --> 00:11:42,430
ואתה מנסה לקרוא להם בעיקרי.

293
00:11:42,430 --> 00:11:46,030
ואם אתה לא משתמש באב טיפוס,
מהדר שלך לצעוק עליך.

294
00:11:46,030 --> 00:11:49,590
>> אב טיפוס הוא בעצם
רק אומר לך מהדר

295
00:11:49,590 --> 00:11:52,400
שיש לי פונקציה זו להלן עיקרי.

296
00:11:52,400 --> 00:11:54,970
אני הולך לקרוא את זה לפני שאני מגדיר את זה.

297
00:11:54,970 --> 00:11:56,360
רק יחזיק מעמד.

298
00:11:56,360 --> 00:12:00,660
אני מבטיח שזה מוגדר, ואתה
יהיה מה שאתה צריך.

299
00:12:00,660 --> 00:12:05,900
>> אז כמו שאנחנו עושים זה רק את ההחזר
סוג, שם הפונקציה שלך, הקלט שלך

300
00:12:05,900 --> 00:12:06,400
רשימה.

301
00:12:06,400 --> 00:12:09,760
זה בעצם השורה הראשונה
של ההצהרה על הפונקציה שלך.

302
00:12:09,760 --> 00:12:11,510
זה באמת כל מה שזה.

303
00:12:11,510 --> 00:12:14,440
אבל זה רק
סוג כללי בפורמט של.

304
00:12:14,440 --> 00:12:17,220
>> לכן בדוגמא שלנו כאן,
שאתם צריכים

305
00:12:17,220 --> 00:12:19,700
ראיתי בסעיף
בשלב מסוים, יש לנו

306
00:12:19,700 --> 00:12:23,220
כמה קוביית int ש
לוקח קצת int של קלט.

307
00:12:23,220 --> 00:12:25,870
ויש לנו העיקרי שלנו
פונקציה, הקוראת קובייה.

308
00:12:25,870 --> 00:12:28,670
וקובייה מוגדרת לאחר המעשה.

309
00:12:28,670 --> 00:12:34,450
>> אז אם לא היה לנו קלט קוביית int
בחלק העליון, כאשר אנו נקראים קובייה

310
00:12:34,450 --> 00:12:36,620
בתוך מהדר העיקרי, שלנו
היה מתרגז עלינו.

311
00:12:36,620 --> 00:12:38,890
זה יהיה כמו, מה
אתה מדבר?

312
00:12:38,890 --> 00:12:40,360
קובייה לא קיימת.

313
00:12:40,360 --> 00:12:41,910
אני לא יודע מה שאתה מבקש.

314
00:12:41,910 --> 00:12:43,490
ואני רק הולך להפסיק.

315
00:12:43,490 --> 00:12:47,330
>> אבל בגלל שעשינו אב הטיפוס שלנו
בחלק העליון, שאמרנו,

316
00:12:47,330 --> 00:12:49,800
אתה יודע, כשאתה רואה
קובייה, אל תדאג בקשר לזה.

317
00:12:49,800 --> 00:12:51,990
אני מבטיח שזה הוגדר מאוחר יותר.

318
00:12:51,990 --> 00:12:53,750
וזה ייתן לך לעשות מה שאתה רוצה.

319
00:12:53,750 --> 00:12:57,750
אז אם אי פעם יש להם תפקיד
שהוכרז לאחר שאתה קורא את זה

320
00:12:57,750 --> 00:13:00,570
בפעם הראשונה, אתה צריך
יש לו אב טיפוס בחלק העליון.

321
00:13:00,570 --> 00:13:01,640

322
00:13:01,640 --> 00:13:02,720
>> כן?

323
00:13:02,720 --> 00:13:04,412
>> ROB: זה בריבוע, לא עִקוּב.

324
00:13:04,412 --> 00:13:05,855
>> אליסון: הו אלוהים שלי.

325
00:13:05,855 --> 00:13:09,435
אני לא have-- גייב, חשבתי
היית מגינו.

326
00:13:09,435 --> 00:13:10,740

327
00:13:10,740 --> 00:13:12,760
בחורים אישור, לשאת איתי, כאן.

328
00:13:12,760 --> 00:13:14,440
אני מקווה שכולם מקבל את הרעיון.

329
00:13:14,440 --> 00:13:15,560

330
00:13:15,560 --> 00:13:20,380
אוקיי, אז זה צריך להיות
כבר בריבוע, לא חתוך לקוביות.

331
00:13:20,380 --> 00:13:22,700
אבל הרעיון נשאר אותו הדבר.

332
00:13:22,700 --> 00:13:23,702

333
00:13:23,702 --> 00:13:26,660
כל פונקציה שאנחנו קוראים אחרי
למעשה צריך להיות אב-טיפוס.

334
00:13:26,660 --> 00:13:27,730

335
00:13:27,730 --> 00:13:28,970
כולם טובים בזה?

336
00:13:28,970 --> 00:13:30,730

337
00:13:30,730 --> 00:13:32,310
כל שגיאות הקלדה אחרות?

338
00:13:32,310 --> 00:13:32,810
אישור.

339
00:13:32,810 --> 00:13:34,730

340
00:13:34,730 --> 00:13:36,230
כל שגיאות הקלדה כאן לפני שאנחנו מתחילים, רוב?

341
00:13:36,230 --> 00:13:37,356

342
00:13:37,356 --> 00:13:42,380
[צוחק] אוקיי, אז structs.

343
00:13:42,380 --> 00:13:45,040
בעיקרון, structs יאפשר לך
כדי ליצור סוג הנתונים שלך.

344
00:13:45,040 --> 00:13:49,264
כל כך הרבה כמו int או char או
לצוף, זה רק סוג אחר.

345
00:13:49,264 --> 00:13:51,680
אני רוצה לחשוב על זה כעל, כמו,
ליצור סוג הנתונים שלך.

346
00:13:51,680 --> 00:13:53,740
אז זה מאפשר לך לעשות את זה.

347
00:13:53,740 --> 00:13:56,160
והיא מחזיקה סוגים שונים של נתונים.

348
00:13:56,160 --> 00:14:01,030
>> אז אם אתה זוכר, במערך, אנחנו
יכול להחזיק רק דברים מסוג דומה.

349
00:14:01,030 --> 00:14:04,660
Structs יאפשר לנו להחזיק מספר רב של
דברים מסוגים שונים.

350
00:14:04,660 --> 00:14:08,944
אז במקרה הזה כאן, אנחנו
יש לי struct בשם סטודנטים,

351
00:14:08,944 --> 00:14:10,650
בשם כאן בתחתית.

352
00:14:10,650 --> 00:14:13,540
ויש לנו כמה id int
וכמה שם מחרוזת.

353
00:14:13,540 --> 00:14:14,620

354
00:14:14,620 --> 00:14:17,300
אז זה סתם עוד סוג הנתונים.

355
00:14:17,300 --> 00:14:18,950
עכשיו יש לנו טיפוס בשם סטודנטים.

356
00:14:18,950 --> 00:14:20,330

357
00:14:20,330 --> 00:14:24,750
>> אז בגלל שאנחנו יכולים לחשוב על
זה כעוד סוג הנתונים,

358
00:14:24,750 --> 00:14:27,760
אנו יכולים להצהיר על משתנים
כפי שאנו עושים מדי.

359
00:14:27,760 --> 00:14:32,680
אז במקום רק שיש, כמו,
תלמיד int, רק שיש לנו סטודנטים,

360
00:14:32,680 --> 00:14:33,390
תלמיד 1.

361
00:14:33,390 --> 00:14:33,560
אה, תראה.

362
00:14:33,560 --> 00:14:34,059
זה רוב.

363
00:14:34,059 --> 00:14:35,750

364
00:14:35,750 --> 00:14:38,880
אז הנה אנחנו מכריזים
struct, או משתנים

365
00:14:38,880 --> 00:14:40,940
בשם תלמיד 1 של תלמיד סוג.

366
00:14:40,940 --> 00:14:45,370
אז זה הולך לי id
ושם משויך אליו.

367
00:14:45,370 --> 00:14:48,430
>> והדרך בה אנו לגשת אלה
גורמים בתוך struct שלנו

368
00:14:48,430 --> 00:14:50,100
הוא עם מפעיל הנקודה, כאן.

369
00:14:50,100 --> 00:14:51,910

370
00:14:51,910 --> 00:14:54,660
אז במקרה הזה, אנחנו
הכריז איזה סטודנט 1.

371
00:14:54,660 --> 00:14:57,080
אנחנו מוקצים ID להיות 1.

372
00:14:57,080 --> 00:14:58,840
ואנחנו מוקצים שם להיות רוב.

373
00:14:58,840 --> 00:15:03,010

374
00:15:03,010 --> 00:15:04,960
אישור, כולם טובים בזה?

375
00:15:04,960 --> 00:15:06,787
השתמש בו רק like-- כן?

376
00:15:06,787 --> 00:15:09,530
>> תלמיד: כן, typedef-- כאשר
אנחנו צריכים להשתמש בtypedef?

377
00:15:09,530 --> 00:15:13,190
>> אליסון: אז typedef רק
אומר that-- רוב, אתה

378
00:15:13,190 --> 00:15:16,990
יכול לתקן אותי על זה אם אני wrong--
אבל typedef הוא רק בעצם הכרזה

379
00:15:16,990 --> 00:15:19,330
את זה כסוג שאתה יכול להשתמש, נכון?

380
00:15:19,330 --> 00:15:22,550
>> ROB: כן, זה בעצם,
כך שזה רק יצירת

381
00:15:22,550 --> 00:15:24,215
כינוי, או כינוי לסוג.

382
00:15:24,215 --> 00:15:25,590
אז אתה יכול להקליד ש[ לא ברור].

383
00:15:25,590 --> 00:15:27,140

384
00:15:27,140 --> 00:15:30,350
אז [לא ברור] קיים,
ועכשיו רק שיש לנו

385
00:15:30,350 --> 00:15:32,090
[לא ברור] אמצעים
בדיוק אותו הדבר.

386
00:15:32,090 --> 00:15:37,210
אז הנה, אנחנו הקלדה, אני חושב,
כמה struct מסוג 2 [לא ברור].

387
00:15:37,210 --> 00:15:40,680
כך שזה רק כינוי
עבור סוג נתון.

388
00:15:40,680 --> 00:15:44,344
>> תלמיד: מחרוזת ספרייה [לא ברור]
הוקלד כמו כוכב char.

389
00:15:44,344 --> 00:15:51,380

390
00:15:51,380 --> 00:15:54,390
>> אליסון: למטרות שלנו כאן,
אם אתה מכריז struct,

391
00:15:54,390 --> 00:15:55,600
פשוט לעשות typedef struct.

392
00:15:55,600 --> 00:15:57,680

393
00:15:57,680 --> 00:16:04,490
אוקיי, אז מראש, זה הוא
רק משתנה רגיל כאן.

394
00:16:04,490 --> 00:16:06,390
אנו לגשת אליו עם נקודה.

395
00:16:06,390 --> 00:16:08,580
אם יש לנו מצביע ל
struct, אנחנו יכולים למעשה

396
00:16:08,580 --> 00:16:10,700
להשתמש חץ, וזה די מגניב.

397
00:16:10,700 --> 00:16:17,130
>> אז במקרה הזה, יש לנו מצביע ל
תלמיד 1 שהוא תלמיד של סוג.

398
00:16:17,130 --> 00:16:19,020
זכור, עם שלך
בניית מצביע,

399
00:16:19,020 --> 00:16:23,710
אתה רוצה לא משנה מה סוג המצביע
מצביע על להיות בתחילת.

400
00:16:23,710 --> 00:16:25,960
אז יש לנו איזה סטודנט 1, כאן.

401
00:16:25,960 --> 00:16:27,370

402
00:16:27,370 --> 00:16:31,050
ומכיוון שתלמיד זה
1 הוא עכשיו מחודד,

403
00:16:31,050 --> 00:16:36,520
אנחנו באמת יכולים ללכת שם חץ 1 תלמיד
במקום נקודה, כי זה מצביע,

404
00:16:36,520 --> 00:16:37,640
ולהקצות רוב.

405
00:16:37,640 --> 00:16:40,720
ועכשיו אם אנחנו רוצים
לשנות רוב לדווין,

406
00:16:40,720 --> 00:16:43,570
זה רק מראה לך
דרך אחרת לעשות את זה.

407
00:16:43,570 --> 00:16:48,850
>> אז במקום להשתמש בחץ, לך
יכול also-- אני אסיים את זה ואז

408
00:16:48,850 --> 00:16:52,860
לקחת את זה question-- אתה יכול
גם לעשות תלמיד התייחסות 1.

409
00:16:52,860 --> 00:16:56,170
זה אומר כמו ללכת ל
כל מה שעל תלמיד 1, ש

410
00:16:56,170 --> 00:16:58,840
יהיה struct הסטודנטים שלנו.

411
00:16:58,840 --> 00:17:03,910
לגשת אליו עם נקודה והאלמנט
שאתה רוצה, ולאחר מכן להקצות מחדש אותו.

412
00:17:03,910 --> 00:17:05,326
הייתה שאלה.

413
00:17:05,326 --> 00:17:08,034
סטודנט: כן, אז איך קורה שיש לך
להשתמש [לא ברור] כשאתה

414
00:17:08,034 --> 00:17:10,367
עושה כוכב סטודנט ללא
[לא ברור] תלמיד?

415
00:17:10,367 --> 00:17:12,200
אליסון: כי זה
יוצר מצביע.

416
00:17:12,200 --> 00:17:13,616
ROB: אנחנו הולכים לדבר על זה.

417
00:17:13,616 --> 00:17:16,119
אליסון: אנחנו הולכים לדבר
על כך בהמשך בסקירה.

418
00:17:16,119 --> 00:17:17,660
אז פשוט להחזיק את המחשבה הזאת.

419
00:17:17,660 --> 00:17:20,560
אם זה עדיין מפריע לך ב
הסוף, לבוא לדבר עם אחד מאיתנו.

420
00:17:20,560 --> 00:17:23,380
>> אז אלה לעשות בדיוק את אותו הדבר.

421
00:17:23,380 --> 00:17:25,579
אנחנו רק מראים לך שני
דרכים שונות לעשות את זה.

422
00:17:25,579 --> 00:17:29,470
סטודנט 1 הוא החברה מצביע, כך
אתה יכול לגשת לרכיב שם

423
00:17:29,470 --> 00:17:30,960
בתוך struct עם חץ.

424
00:17:30,960 --> 00:17:36,440
או שאתה יכול dereference המצביע, ו
אז לגשת אליו כמו שאתה עושה בדרך כלל.

425
00:17:36,440 --> 00:17:38,430
האם זה הגיוני לכל אחד?

426
00:17:38,430 --> 00:17:39,480

427
00:17:39,480 --> 00:17:43,890
אם כל הדברים המצביע הם קצת
מבלבל, גייב יהיה לדבר על זה,

428
00:17:43,890 --> 00:17:45,740
ואז אולי זה
יהיה הגיוני יותר.

429
00:17:45,740 --> 00:17:46,240
כן?

430
00:17:46,240 --> 00:17:48,387
>> סטודנט: כן, אז איך הוא
זה שונה מ?

431
00:17:48,387 --> 00:17:49,470
אליסון: הקודם?

432
00:17:49,470 --> 00:17:52,330
אז התלמיד 1 בזה
המקרה הוא לא מצביע.

433
00:17:52,330 --> 00:17:54,380
זה פשוט struct שלך בפועל.

434
00:17:54,380 --> 00:17:55,400
>> תלמיד: אישור.

435
00:17:55,400 --> 00:17:57,645
>> אליסון: בעוד שזה אחד
הוא מצביע למבנה.

436
00:17:57,645 --> 00:17:58,910

437
00:17:58,910 --> 00:18:02,060
>> תלמיד: בסדר, אבל עושה את זה סוג של
בסופו של עובד באותו [לא ברור].

438
00:18:02,060 --> 00:18:03,310
>> אליסון: זה למעשה עובד אותו הדבר.

439
00:18:03,310 --> 00:18:04,560
התחביר שלך הוא פשוט שונה.

440
00:18:04,560 --> 00:18:05,185
תלמיד: אישור.

441
00:18:05,185 --> 00:18:07,600
>> אליסון: כן, הם
יעילות זהה.

442
00:18:07,600 --> 00:18:11,321
זה פשוט תלוי בהקשר,
ייתכן שתרצה אחד על פנים השני.

443
00:18:11,321 --> 00:18:11,820
כן?

444
00:18:11,820 --> 00:18:13,956
>> תלמיד: כאשר אתה עושה
אזכור של 1--

445
00:18:13,956 --> 00:18:14,580
אליסון: ממ-הממ?

446
00:18:14,580 --> 00:18:16,880
תלמיד: למה אתה
יש לי הסוגריים?

447
00:18:16,880 --> 00:18:19,575
אליסון: כי תלמיד
1 הוא המצביע.

448
00:18:19,575 --> 00:18:22,200
אז אתה צריך לוודא שאתה
רק ביטול הפניה למבנה המצביע.

449
00:18:22,200 --> 00:18:23,380
>> תלמיד: אישור.

450
00:18:23,380 --> 00:18:26,700
>> אליסון: אז במקרה הזה כאן,
הסוגריים סביבו

451
00:18:26,700 --> 00:18:29,875
משמעות הדבר היא שאתה ביטול התייחסות תלמיד 1.

452
00:18:29,875 --> 00:18:35,390
אז אתה הולך למקום שבי תלמיד
1 נקודות, שהוא struct שלך.

453
00:18:35,390 --> 00:18:38,010
אז עכשיו אתה יכול לחשוב
על זה כעל struct ש,

454
00:18:38,010 --> 00:18:39,785
כדי שנוכל להשתמש בפעולת הנקודה הרגילה שלנו.

455
00:18:39,785 --> 00:18:42,752

456
00:18:42,752 --> 00:18:43,585
יש עוד שאלות?

457
00:18:43,585 --> 00:18:45,840

458
00:18:45,840 --> 00:18:48,120
מגניב, מדהים.

459
00:18:48,120 --> 00:18:51,359
>> אז הדבר אחרון, אני חושב ש
היא השקופית האחרונה שלי, וו!

460
00:18:51,359 --> 00:18:52,775
אוקיי, אז צף חוסר דיוק נקודה.

461
00:18:52,775 --> 00:18:54,090

462
00:18:54,090 --> 00:18:56,820
דברנו בקצרה על
זה במהלך הרצאה.

463
00:18:56,820 --> 00:19:00,030
בעיקרון, יש לנו
רבים לאין שיעור אמיתי מספרים.

464
00:19:00,030 --> 00:19:02,237
ואם מישהו מכם
אוהב מתמטיקה, יש

465
00:19:02,237 --> 00:19:03,570
כל מיני דברים מגניבים איתנו.

466
00:19:03,570 --> 00:19:05,010

467
00:19:05,010 --> 00:19:07,190
>> אבל יש אינסוף
רבים אמיתיים מספרים.

468
00:19:07,190 --> 00:19:09,850
אבל הם רק בנים-תמותה
פיסות רבות שיש לנו.

469
00:19:09,850 --> 00:19:13,240
אז אתה תמיד הולך
יש חוסר דיוק, הוא כל.

470
00:19:13,240 --> 00:19:16,269
וזהו זה פשוט סוג של
כמו משהו שאתה צריך לדעת.

471
00:19:16,269 --> 00:19:19,060
כי כמו שאנחנו יכולים לשאול אותך מדוע
נקודה צפה חוסר דיוק קיימת?

472
00:19:19,060 --> 00:19:20,004

473
00:19:20,004 --> 00:19:21,420
אז רק משהו שאתם צריכים לדעת.

474
00:19:21,420 --> 00:19:23,770
ועם זה, אני פונה
זה מעל למצביעים.

475
00:19:23,770 --> 00:19:27,720

476
00:19:27,720 --> 00:19:28,520
>> בינקי: שלום, חבר 'ה.

477
00:19:28,520 --> 00:19:29,616
קוראים לי בינקי.

478
00:19:29,616 --> 00:19:30,990
אני הולך לדבר על מצביעים.

479
00:19:30,990 --> 00:19:33,247

480
00:19:33,247 --> 00:19:35,830
כן, כך מצביעים הוא למעשה
החלק האהוב עליי בקורס זה.

481
00:19:35,830 --> 00:19:39,740
אז רק כדי להבהיר במה אליסון
מדבר כאן, כך הסיבה

482
00:19:39,740 --> 00:19:43,810
why-- ההבדל היחיד כאן,
ההבדל הגדול היה בדרך

483
00:19:43,810 --> 00:19:44,760
אנו מצהירים דברים.

484
00:19:44,760 --> 00:19:47,560
אז כוכב סטודנט פירוש זה
הוא מצביע לתלמיד.

485
00:19:47,560 --> 00:19:52,960
בעוד השקופיות לפני, תלמיד
struct בפועל, כמו תלמיד בפועל,

486
00:19:52,960 --> 00:19:54,400
המכיל את כל הדברים האלה.

487
00:19:54,400 --> 00:19:57,050
>> והסיבה ש
רוצה to-- כן, דווין?

488
00:19:57,050 --> 00:19:58,630
>> דווין: מה החץ אומר?

489
00:19:58,630 --> 00:20:04,240
>> בינקי: אמצעי החץ
בדיוק כמו זה.

490
00:20:04,240 --> 00:20:06,150
אז אתה לא באמת צריך את החץ.

491
00:20:06,150 --> 00:20:11,060
כמו, אם אתה רק תכנית
ב- C, אתה יכול פשוט להשתמש בזה.

492
00:20:11,060 --> 00:20:12,850
מצטער, אני לא מה ש.

493
00:20:12,850 --> 00:20:14,920
אתה יכול פשוט להשתמש בתחביר זה.

494
00:20:14,920 --> 00:20:17,430
>> אבל יש אנשים ש, כאשר
הם עיצוב C,

495
00:20:17,430 --> 00:20:19,870
הם חשבו שאנשים
שימוש בתחביר שכל כך הרבה,

496
00:20:19,870 --> 00:20:23,970
שהם רוצים רק לבוא
עם מבנה תחביר לזה.

497
00:20:23,970 --> 00:20:26,820
וזה התרחש ב
הצורה של החץ הזה.

498
00:20:26,820 --> 00:20:29,210
וזה ממש נחמד, כי
הוא מסמל משהו

499
00:20:29,210 --> 00:20:33,670
כמו שאנחנו למעשה הבאים
החץ הזה, מצביע זה,

500
00:20:33,670 --> 00:20:35,300
לכמה מקום בזיכרון.

501
00:20:35,300 --> 00:20:40,410
וכאשר נגיע לשם, אנחנו רוצים
להסתכל על שמו של תלמיד ש,

502
00:20:40,410 --> 00:20:42,150
אם זה נשמע הגיוני.

503
00:20:42,150 --> 00:20:43,000
בסדר?

504
00:20:43,000 --> 00:20:44,290
>> אז זה בדיוק אותו הדבר.

505
00:20:44,290 --> 00:20:46,310
זה בדיוק אותו דבר כמו זה.

506
00:20:46,310 --> 00:20:48,130
הם מקבלים מלוקט בדיוק אותו הדבר, בסדר?

507
00:20:48,130 --> 00:20:50,100

508
00:20:50,100 --> 00:20:55,580
והסיבה כאן למה אנחנו malloc
משהו, הוא כי במקרה זה,

509
00:20:55,580 --> 00:20:59,120
המשתנה שלנו היא למעשה
רק משתנה מצביע.

510
00:20:59,120 --> 00:21:02,900
אז יש לנו קצת מקום רק ב
זיכרון שמחזיק את מצביע.

511
00:21:02,900 --> 00:21:06,570
באמת שאין לנו שום מקום
שמחזיק את struct בפועל.

512
00:21:06,570 --> 00:21:08,660
>> אז זה צריך להיעשות בשני שלבים.

513
00:21:08,660 --> 00:21:11,545
אנחנו צריכים ליצור את
זיכרון לשים struct ב.

514
00:21:11,545 --> 00:21:14,445
ויש לנו כדי ליצור את
זיכרון לסימון ב.

515
00:21:14,445 --> 00:21:16,570
אז הם בעצם שני
משתנים שונים, כאן.

516
00:21:16,570 --> 00:21:19,730
אחד מהם הוא של תלמיד סוג,
מלבד זה לא ממש להיות שם.

517
00:21:19,730 --> 00:21:21,900
והשני הוא
כוכב סטודנט סוג.

518
00:21:21,900 --> 00:21:24,900
ואז נקודות 1 תלמיד
יש, אם זה הגיוני.

519
00:21:24,900 --> 00:21:25,871

520
00:21:25,871 --> 00:21:26,370
בסדר?

521
00:21:26,370 --> 00:21:28,160

522
00:21:28,160 --> 00:21:31,860
>> אז הסיבה לכך שאנו משתמשים ב
מצביעים הוא כי הכל

523
00:21:31,860 --> 00:21:35,510
במחשב, בכל משתנה
יש שני דברים במחשב.

524
00:21:35,510 --> 00:21:36,580
יש לה הערך שלה.

525
00:21:36,580 --> 00:21:38,420
ויש לו את הכתובת שלו.

526
00:21:38,420 --> 00:21:41,390
ודרך טובה
להמשיג זה הוא שיש

527
00:21:41,390 --> 00:21:44,230
בעיות רבות בעת
אנסה להשתמש בפונקציות.

528
00:21:44,230 --> 00:21:47,200
ואנחנו הולכים לנסות
להסתכל לתוך אחד מאותם.

529
00:21:47,200 --> 00:21:50,370
כלומר, זה הולך
לחשוב על זיכרון כקופסות.

530
00:21:50,370 --> 00:21:52,810
>> אתה תמיד חשבת על משתנים
כשאתה אומר na שווה 5.

531
00:21:52,810 --> 00:21:54,430
אתה חושב לשים 5 לתיבה.

532
00:21:54,430 --> 00:21:55,520

533
00:21:55,520 --> 00:22:00,030
אז מה אם אתה רוצה לעבור
int שלפונקציה?

534
00:22:00,030 --> 00:22:03,230
אתה פשוט pass-- אני לא
יודע-- x לפונקציה.

535
00:22:03,230 --> 00:22:06,090
אבל מה שקורה הוא
בדרך כלל בני אדם, אתה

536
00:22:06,090 --> 00:22:09,050
היה חושב שמשהו כמו אני
עובר את התיבה לאדם.

537
00:22:09,050 --> 00:22:12,070
וזה לא ממש
יקרה במחשבים.

538
00:22:12,070 --> 00:22:17,770
מה שקורה הוא שאתה מעתיק את הערך
של התיבה לתיבה של האדם.

539
00:22:17,770 --> 00:22:22,440
>> אז מה שאני מנסה לומר הוא שאם
יש לך function-- sorry-- כאן,

540
00:22:22,440 --> 00:22:27,700
אם יש לנו פונקציה כמו לחמש עד
יש, אם אתה מנסה להעביר משתנה,

541
00:22:27,700 --> 00:22:29,450
זה פשוט הולך להעתיק.

542
00:22:29,450 --> 00:22:35,771
אם NX לאתחל שווה 3, זה הולך
כדי להעתיק ערך זה עד משתנה

543
00:22:35,771 --> 00:22:36,270
שם למעלה.

544
00:22:36,270 --> 00:22:37,005

545
00:22:37,005 --> 00:22:39,630
אישור, וזה סוג של הסיבה
לכן אנחנו רוצים להשתמש במצביעים.

546
00:22:39,630 --> 00:22:42,550
כי במקום
נותן רק את הערך,

547
00:22:42,550 --> 00:22:44,850
במקום רק עובר רק
הערך לפונקציה,

548
00:22:44,850 --> 00:22:46,530
אנחנו רוצים להעביר על ידי התייחסות.

549
00:22:46,530 --> 00:22:50,630
מה שאנחנו קוראים לעבור על ידי התייחסות הוא סוג
לתת את התיבה לפונקציה,

550
00:22:50,630 --> 00:22:53,890
כך שגם הפונקציה יכולה
לשנות את הערכים בתוך התיבה ש.

551
00:22:53,890 --> 00:22:57,280
>> אוקיי, אז רק חלק מצביע בסיסי
דברים הוא ליצור מצביעים,

552
00:22:57,280 --> 00:23:00,300
אתה פשוט להכריז עליו סוג, ו
אתה שם את כוכב מייד אחרי זה.

553
00:23:00,300 --> 00:23:02,307
והסוג הוא רק
מה שאתה מצביע על.

554
00:23:02,307 --> 00:23:04,390
אז אם זה כוכב int,
אתה מצביע על int.

555
00:23:04,390 --> 00:23:05,940
אם זה כוכב char,
אתה מצביע על תרשים.

556
00:23:05,940 --> 00:23:07,790
ואם זה כוכב סטודנט,
אתה מצביע על סטודנט.

557
00:23:07,790 --> 00:23:08,770
בסדר?

558
00:23:08,770 --> 00:23:10,510
>> והם ארוכים כל 4 הבתים.

559
00:23:10,510 --> 00:23:13,010
מכיוון שמשתנה זה
זה לא באמת

560
00:23:13,010 --> 00:23:15,380
צריך להחזיק char,
int, או סטודנט.

561
00:23:15,380 --> 00:23:16,890
זה רק צריך להחזיק את כתובת.

562
00:23:16,890 --> 00:23:21,390
זו הסיבה שהם כל 4 הבתים
ארוך במכונה 32 ביט רגיל.

563
00:23:21,390 --> 00:23:21,890
בסדר?

564
00:23:21,890 --> 00:23:25,600
אז הנה, x הוא משתנה המצביע
לint. נקודות y לchar. נקודות z

565
00:23:25,600 --> 00:23:26,580
למצוף.

566
00:23:26,580 --> 00:23:27,480
כל שאלות כאן?

567
00:23:27,480 --> 00:23:29,841

568
00:23:29,841 --> 00:23:30,340
מגניב.

569
00:23:30,340 --> 00:23:32,550
ויש שני
סמלים שונים שיש להם

570
00:23:32,550 --> 00:23:34,341
לזכור כאשר
מגיע למצביע.

571
00:23:34,341 --> 00:23:36,540
אז התייחסות ו
ביטול התייחסות הם לגדולים.

572
00:23:36,540 --> 00:23:38,100

573
00:23:38,100 --> 00:23:41,602
אז האמפרסנד של
שם משתנה נותן לך?

574
00:23:41,602 --> 00:23:42,310
תלמיד: כתובת.

575
00:23:42,310 --> 00:23:43,380
בינקי: כתובת.

576
00:23:43,380 --> 00:23:47,330
אז אם אתה מצהיר על int
שווה 5, אז אמפרסנד

577
00:23:47,330 --> 00:23:49,214
של הוא הולך לתת לך את הכתובת.

578
00:23:49,214 --> 00:23:51,130
ואתה באמת יכול לנסות
כדי להדפיס את זה ולראות

579
00:23:51,130 --> 00:23:54,640
מה בזיכרון כתובת
יש משתנה.

580
00:23:54,640 --> 00:23:57,380
ולאחר מכן dereferencing--
כך שהתייחסות,

581
00:23:57,380 --> 00:24:00,380
מקבל את ביטול הפנית address--
הוא בדיוק ההפך.

582
00:24:00,380 --> 00:24:04,120
אישור, ממש כמו בימים הוא
ההפך מחטיבה,

583
00:24:04,120 --> 00:24:06,060
כוכב הוא ההפך מהאמפרסנד.

584
00:24:06,060 --> 00:24:09,710
אז אמצעי ביטול התייחסות ללכת לשם.

585
00:24:09,710 --> 00:24:14,280
אז אם אתה נותן לי star--
לא יודע-- 50, זה

586
00:24:14,280 --> 00:24:20,320
הולך לנסות ללכת לכתובת של
מספר 50 בתוך המחשב שלך.

587
00:24:20,320 --> 00:24:22,840
אישור, ולמה אנחנו רואים
שהם ההפכים?

588
00:24:22,840 --> 00:24:27,320
כי מה שקורה אם אתה עושה
משהו כמו כוכב אמפרסנד?

589
00:24:27,320 --> 00:24:28,470

590
00:24:28,470 --> 00:24:33,460
ובכן, אמפרסנד נותן לך את הכתובת
של משתנה, את הכתובת של.

591
00:24:33,460 --> 00:24:35,830
אבל כוכב פירושו ללכת לשם.

592
00:24:35,830 --> 00:24:38,930
>> אז מה קורה אם אתה
גש לכתובת של?

593
00:24:38,930 --> 00:24:40,400
אתה פשוט מקבל, נכון?

594
00:24:40,400 --> 00:24:41,410

595
00:24:41,410 --> 00:24:43,600
אז הולך לכתובת של
הוא אותו הדבר כמו.

596
00:24:43,600 --> 00:24:47,580
זו הסיבה שהם בדרך כלל
התייחס לsame-- זה

597
00:24:47,580 --> 00:24:50,480
וזה מופנים ל
מפעילים הפוכים.

598
00:24:50,480 --> 00:24:50,980
בסדר?

599
00:24:50,980 --> 00:24:52,780

600
00:24:52,780 --> 00:24:53,790
כל כך מגניב.

601
00:24:53,790 --> 00:24:57,240
>> מתחת למכסה המנוע, למשל,
אם אנו מצהירים x int שווה 5,

602
00:24:57,240 --> 00:24:58,040
יש לנו משתנה.

603
00:24:58,040 --> 00:25:00,790
וזוכר שאמרתי כל
variable-- וזה דבר טוב

604
00:25:00,790 --> 00:25:03,820
כדי לשמור על mind-- יש לו שני
דברים שונים הקשורים ב.

605
00:25:03,820 --> 00:25:06,460
יש לו וערך התייחס.

606
00:25:06,460 --> 00:25:07,140
בסדר?

607
00:25:07,140 --> 00:25:09,180
>> אז הערך במקרה זה הוא 5.

608
00:25:09,180 --> 00:25:12,140
וכתובת is-- נניח, אני
מה שהופך משהו up-- זה 0x04.

609
00:25:12,140 --> 00:25:13,180

610
00:25:13,180 --> 00:25:17,200
והסיבה היחידה שאנחנו בדרך כלל
מייצג כתובות בהקסדצימלי

611
00:25:17,200 --> 00:25:19,770
הוא אחד, כי זה כמו טוב.

612
00:25:19,770 --> 00:25:21,600
זה הולך טוב עם בינארי.

613
00:25:21,600 --> 00:25:23,500
זה קל להמיר אל ומאת ינארי.

614
00:25:23,500 --> 00:25:26,890
וזה לא יגדל יותר מדי אם
יש לך מספר גדול מאוד.

615
00:25:26,890 --> 00:25:29,990
אז אנחנו רוצים להשתמש הקסדצימלי
בכתובות הדפסה.

616
00:25:29,990 --> 00:25:31,890
אבל אני יכול לייצג
זה כמספר שלם.

617
00:25:31,890 --> 00:25:32,750
זה בסדר גמור.

618
00:25:32,750 --> 00:25:35,450
>> וכך יש לו את כתובת
4 וערך של 5.

619
00:25:35,450 --> 00:25:38,080
ואז אמרתי מצביע כוכב int.

620
00:25:38,080 --> 00:25:40,070
אז זה סוג, הודעה שונה.

621
00:25:40,070 --> 00:25:43,220
מצביע כוכב Int שווה
הכתובת של x.

622
00:25:43,220 --> 00:25:46,425
אז מה הולך להיות הערך של PTR?

623
00:25:46,425 --> 00:25:47,710

624
00:25:47,710 --> 00:25:51,600
זה הולך להיות
כתובת של x, כאן למטה.

625
00:25:51,600 --> 00:25:54,190
אוקיי, אז הערך הוא הולך
להיות זהה לכתובת.

626
00:25:54,190 --> 00:25:56,130
זה המשימה לפעול אני עושה.

627
00:25:56,130 --> 00:25:59,380
ולאחר מכן ptr הוא הולך להיות
כתובת שלה, שמתבררת,

628
00:25:59,380 --> 00:26:02,050
במקרה זה, 8, בסדר?

629
00:26:02,050 --> 00:26:03,850

630
00:26:03,850 --> 00:26:05,900
>> ולאחר מכן אני יוצר עותק שלם חדש.

631
00:26:05,900 --> 00:26:08,790
ואני אומר עותק int שווה ללכת לשם.

632
00:26:08,790 --> 00:26:11,140
אז לך למה PTR מצביע.

633
00:26:11,140 --> 00:26:13,940
ובכן, מה יש לי PTR זה?

634
00:26:13,940 --> 00:26:14,740
יש PTR 0x04.

635
00:26:14,740 --> 00:26:16,060

636
00:26:16,060 --> 00:26:18,400
מה קורה אם אני מנסה ללכת לשם?

637
00:26:18,400 --> 00:26:23,650
אני תמצא את הבחור שיש לי
יש x כתובת ושכתובה 4.

638
00:26:23,650 --> 00:26:25,970
ומי שיש לי מתייחס לארבעה הוא x.

639
00:26:25,970 --> 00:26:26,950
האם זה הגיוני?

640
00:26:26,950 --> 00:26:28,295

641
00:26:28,295 --> 00:26:28,795
כן?

642
00:26:28,795 --> 00:26:32,060
>> תלמיד: במקרה זה, הוא
את המצביע בערימה?

643
00:26:32,060 --> 00:26:36,024
>> בינקי: במקרה זה,
it's-- שאלה טובה.

644
00:26:36,024 --> 00:26:38,690
אני לא באמת חושב על זה
בעת ביצוע את הכתובות הללו.

645
00:26:38,690 --> 00:26:42,570
אבל אם זה, כולו, כמו
אלה הם משתנים מקומיים,

646
00:26:42,570 --> 00:26:46,372
אז x הולך לחיות in-- הכל
הוא הולך לחיות בערימה.

647
00:26:46,372 --> 00:26:48,330
אז הכל הולך
להיות מצביע על מחסנית.

648
00:26:48,330 --> 00:26:49,360

649
00:26:49,360 --> 00:26:52,700
אתה מקבל רק לערימה כאשר
אתה מתחיל להשתמש malloc, נכון?

650
00:26:52,700 --> 00:26:59,430
>> אז אם אתה זוכר ערימה היא כל זמן
אתה קורא לפונקציה בתכנית שלך,

651
00:26:59,430 --> 00:27:02,800
כמו, עיקרי לדוגמא, או כל
תפקיד אחר, כמו printf.

652
00:27:02,800 --> 00:27:06,334
כל המשתנים המקומיים
הולך לקבל אותו במסגרת חבילה.

653
00:27:06,334 --> 00:27:08,500
והם הולכים לקבל
כמו נערם בערימה.

654
00:27:08,500 --> 00:27:09,930
זה מה שנקרא ערימה.

655
00:27:09,930 --> 00:27:12,200
וכל משתנים מקומיים אלה
הולכים להיות שם.

656
00:27:12,200 --> 00:27:14,940
וheap-- ואנחנו הולכים
לדבר יותר על זה later--

657
00:27:14,940 --> 00:27:19,050
הערימה היא שבו כל
באופן דינמי שהוקצה חיי זיכרון.

658
00:27:19,050 --> 00:27:20,270
מגניב?

659
00:27:20,270 --> 00:27:21,680
>> אנחנו הולכים לשקופית זו.

660
00:27:21,680 --> 00:27:22,800
כן?

661
00:27:22,800 --> 00:27:25,490
>> תלמיד: למה הוא לא int
להעתיק חוזר 0x04?

662
00:27:25,490 --> 00:27:27,870

663
00:27:27,870 --> 00:27:30,066
>> בינקי: למה לא int
להעתיק חוזר 0x04?

664
00:27:30,066 --> 00:27:32,450
>> תלמיד: למה לא כל כך [לא ברור]?

665
00:27:32,450 --> 00:27:35,530
>> בינקי: כי מה הוא ערך של PTR?

666
00:27:35,530 --> 00:27:37,394

667
00:27:37,394 --> 00:27:38,370
>> תלמיד: 0x04.

668
00:27:38,370 --> 00:27:38,960
>> בינקי: 0x04.

669
00:27:38,960 --> 00:27:40,910
מה קורה אם אתה הולך ל0x04?

670
00:27:40,910 --> 00:27:41,620
מה אתה מקבל?

671
00:27:41,620 --> 00:27:42,371
>> תלמיד: אה, בסדר.

672
00:27:42,371 --> 00:27:42,995
בינקי: אתה רואה?

673
00:27:42,995 --> 00:27:43,536
סטודנט: כן.

674
00:27:43,536 --> 00:27:44,890
בינקי: אז אתה מקבל 5.

675
00:27:44,890 --> 00:27:49,170
אז העותק הוא הולך להיות
5, אם זה נשמע הגיוני.

676
00:27:49,170 --> 00:27:49,809
כן?

677
00:27:49,809 --> 00:27:52,803
>> תלמיד: האם יש לנו gotten
5 בתיבת הערך [לא ברור]

678
00:27:52,803 --> 00:27:55,300
אם אנחנו שמים int להעתיק [לא ברור].

679
00:27:55,300 --> 00:27:56,710
>> בינקי: Int-- היינו, כן.

680
00:27:56,710 --> 00:27:59,080
שהיה עושה
פחות או יותר את אותו הדבר.

681
00:27:59,080 --> 00:28:02,080
אבל בדרך זו, אנו יכולים לעבור
להתייחס לפונקציות.

682
00:28:02,080 --> 00:28:05,050
וזה דבר מגניב
אנחנו הולכים לעשות עכשיו.

683
00:28:05,050 --> 00:28:06,770

684
00:28:06,770 --> 00:28:13,090
>> אז את התרגיל הזה תמיד עולה
on-- מאוד בדרך כלל מגיע על חידונים.

685
00:28:13,090 --> 00:28:15,870
אז זה ממש טוב כדי לנסות
לעשות דברים מסוג הזה בעצמך.

686
00:28:15,870 --> 00:28:21,210
אז תנסה לעקוב אחר מה כתובת
הוא ורוצה את הערכים של המשתנים

687
00:28:21,210 --> 00:28:22,620
הם בכל נקודה.

688
00:28:22,620 --> 00:28:24,370
אז זה בדיוק
מה אנחנו הולכים לעשות.

689
00:28:24,370 --> 00:28:26,988
הנה, יש לנו צעדים, אחד,
שתיים, שלוש, ארבעה, חמש.

690
00:28:26,988 --> 00:28:30,530
אחת, שתיים, שלוש, ארבעה, חמש.

691
00:28:30,530 --> 00:28:33,330
ואנחנו הולכים כדי לעקוב אחר
של הערכים של x ו.

692
00:28:33,330 --> 00:28:34,650

693
00:28:34,650 --> 00:28:40,530
>> אז מה זה עושה, אם זה
קוד מרכבה, שאנחנו מנסים לעשות עד חמש.

694
00:28:40,530 --> 00:28:43,610
אז אנחנו מנסים להשיג ב
משתנה ולשנות את הערך שלה ל -5.

695
00:28:43,610 --> 00:28:44,630

696
00:28:44,630 --> 00:28:49,900
וזכור האנלוגיה של בעל שלי
תיבה ומסירת התיבה למישהו?

697
00:28:49,900 --> 00:28:51,515
יש כל כך עיקרי התיבה הזה שנקרא x.

698
00:28:51,515 --> 00:28:52,570

699
00:28:52,570 --> 00:28:54,170
והוא מכיל את הערך 3.

700
00:28:54,170 --> 00:28:55,230

701
00:28:55,230 --> 00:28:57,455
ואני מנסה להעביר
תיבה זו לחמש.

702
00:28:57,455 --> 00:28:58,560

703
00:28:58,560 --> 00:29:01,510
>> ואני רוצה חמישה לשינוי
הערך של תיבה זו כדי 5.

704
00:29:01,510 --> 00:29:03,080

705
00:29:03,080 --> 00:29:05,120
ואז אני פשוט להדפיס את הערך של x.

706
00:29:05,120 --> 00:29:06,475

707
00:29:06,475 --> 00:29:08,850
זה מה שfunction-- שלי
זה מה שאני מנסה לעשות.

708
00:29:08,850 --> 00:29:12,450
אני רק מנסה לעדכן
הערך של x עד 5.

709
00:29:12,450 --> 00:29:13,512

710
00:29:13,512 --> 00:29:14,970
האם זה ברור מה הפונקציה עושה?

711
00:29:14,970 --> 00:29:16,210

712
00:29:16,210 --> 00:29:21,440
>> אוקיי, אז מה הולך להיות
ערכים של x וממש כאן,

713
00:29:21,440 --> 00:29:27,734
את השורה הראשונה, ממש לפני הראשון
line-- הייתי say-- של התכנית?

714
00:29:27,734 --> 00:29:28,940
>> תלמיד: כנראה אשפה.

715
00:29:28,940 --> 00:29:30,023
>> בינקי: רק דברים אשפה.

716
00:29:30,023 --> 00:29:32,590
אז אני פשוט לשים N /. אז
אנחנו לא באמת יודעים.

717
00:29:32,590 --> 00:29:37,400
כמו, אפילו לא קיימת עדיין,
כי אנחנו לא נקראים לחמש.

718
00:29:37,400 --> 00:29:38,980
Int לא הצהיר.

719
00:29:38,980 --> 00:29:40,030

720
00:29:40,030 --> 00:29:42,920
וx הולך להתקיים
כאן, אבל יש לנו לא ממש

721
00:29:42,920 --> 00:29:45,370
הוקצה כל ערך לזה, כל כך בסדר?

722
00:29:45,370 --> 00:29:46,570

723
00:29:46,570 --> 00:29:52,340
>> ואז, מה שהולך להיות
ערכים של x ובמספר שתיים?

724
00:29:52,340 --> 00:29:54,530

725
00:29:54,530 --> 00:29:55,410
>> תלמיד: [לא ברור].

726
00:29:55,410 --> 00:29:57,540
>> בינקי: אז x הולך להיות 3.

727
00:29:57,540 --> 00:29:59,650
זה קל, כי
אנחנו מקצים לו 3.

728
00:29:59,650 --> 00:30:03,500
ועדיין לא קיימת
כי רק מתגורר בחמישה.

729
00:30:03,500 --> 00:30:05,800
אז אני הולך יש לי 3 ושום דבר.

730
00:30:05,800 --> 00:30:08,590
או כמו זבל, מה,
לא מוגדר באמת.

731
00:30:08,590 --> 00:30:11,640

732
00:30:11,640 --> 00:30:13,140
ועכשיו, זה הקו החשוב.

733
00:30:13,140 --> 00:30:14,931
הנה, אנחנו הולכים
למעשה קורא לחמש.

734
00:30:14,931 --> 00:30:17,140

735
00:30:17,140 --> 00:30:18,680
ונזכור מה שאמרתי.

736
00:30:18,680 --> 00:30:20,240
אנחנו אף פעם לא עוברים בתיבה.

737
00:30:20,240 --> 00:30:23,110
אנחנו פשוט להעתיק את הערך של
התיבה לתיבה אחרת.

738
00:30:23,110 --> 00:30:27,000
זה כל מה שהמחשבים עושים, להעתיק
דברים ממקום אחד למשנהו.

739
00:30:27,000 --> 00:30:33,550
>> אז עד חמש, מה זה בעצם עושה
זה מעתיק את הערך של x ל.

740
00:30:33,550 --> 00:30:35,130
אז מה הולך להיות כאן?

741
00:30:35,130 --> 00:30:36,210
הערכים של x ו.

742
00:30:36,210 --> 00:30:38,670

743
00:30:38,670 --> 00:30:43,360
3 ו -3, אנחנו פשוט להעתיק
על זה מx ל.

744
00:30:43,360 --> 00:30:44,710

745
00:30:44,710 --> 00:30:45,320
מגניב.

746
00:30:45,320 --> 00:30:46,140
>> עכשיו אנחנו כאן.

747
00:30:46,140 --> 00:30:47,610

748
00:30:47,610 --> 00:30:49,430
ועכשיו אנחנו הולכים
לעדכן שווה 5.

749
00:30:49,430 --> 00:30:50,900

750
00:30:50,900 --> 00:30:53,070
מה הולך לקרות בקו ארבעה?

751
00:30:53,070 --> 00:30:55,120

752
00:30:55,120 --> 00:30:56,010
>> תלמיד: [לא ברור].

753
00:30:56,010 --> 00:30:59,685
>> בינקי: מתעדכן,
אבל x לא עודכן.

754
00:30:59,685 --> 00:31:02,050

755
00:31:02,050 --> 00:31:05,250
בגלל x עדיין מתגורר במרכזי, זה
בלוק שונה לגמרי מזיכרון.

756
00:31:05,250 --> 00:31:06,970
זה משתנה שונה.

757
00:31:06,970 --> 00:31:07,900
משתנה אחר.

758
00:31:07,900 --> 00:31:10,000
הם במקרה יש לי
אותו ערך, כי אני

759
00:31:10,000 --> 00:31:13,980
מועתק על הערך של x ל.

760
00:31:13,980 --> 00:31:20,070
אבל עכשיו כשאני עושה שווה 5, זה
לא ממש משפיע על x בכל דרך.

761
00:31:20,070 --> 00:31:21,450
זה החלק המסובך.

762
00:31:21,450 --> 00:31:23,380
האם זה הגיוני לכולם?

763
00:31:23,380 --> 00:31:24,093
כן?

764
00:31:24,093 --> 00:31:25,717
תלמיד: עוד שאלה אחת, יש לך 3.

765
00:31:25,717 --> 00:31:27,741
מדוע already-- הו, לא, זה 3.

766
00:31:27,741 --> 00:31:28,490
מצטער, לא חשוב.

767
00:31:28,490 --> 00:31:29,310
אני קורא 5.

768
00:31:29,310 --> 00:31:30,415
>> בינקי: כן, 3, 3.

769
00:31:30,415 --> 00:31:31,540
>> תלמיד: [לא ברור], כן.

770
00:31:31,540 --> 00:31:35,290
בינקי: ואז אנו מקצים 5 ל
, אבל לא ממש לשנות את x.

771
00:31:35,290 --> 00:31:36,369
טוב?

772
00:31:36,369 --> 00:31:36,910
סטודנט: כן.

773
00:31:36,910 --> 00:31:37,410
בינקי: כן?

774
00:31:37,410 --> 00:31:42,330
האם אתה יכול להסביר שוב איך
מועתק [לא ברור]?

775
00:31:42,330 --> 00:31:48,480
>> בינקי: בסדר, אז כאשר אתה קורא לחמש
של x, כך הקו הזה של קוד כאן.

776
00:31:48,480 --> 00:31:50,100

777
00:31:50,100 --> 00:31:52,340
חמש של x, מה הוא X?

778
00:31:52,340 --> 00:31:55,160

779
00:31:55,160 --> 00:31:58,340
x הוא 3 בדיוק בנקודה זו, נכון?

780
00:31:58,340 --> 00:32:03,320
אז אתה יכול פשוט לחשוב על לשים
3 בכאן ושוכחים על x.

781
00:32:03,320 --> 00:32:04,410
פשוט לשים 3 כאן.

782
00:32:04,410 --> 00:32:10,880
כמו, שאנחנו הולכים להעתיק את
ערך של x לint זה שם למעלה.

783
00:32:10,880 --> 00:32:12,310

784
00:32:12,310 --> 00:32:13,630
בסדר?

785
00:32:13,630 --> 00:32:14,780
>> אז הערך של x הוא 3.

786
00:32:14,780 --> 00:32:17,680
אנחנו הולכים להעתיק 3 מעל ל.

787
00:32:17,680 --> 00:32:20,040
וכל בלוק של אחר זה
זיכרון, משתנה אחר זה

788
00:32:20,040 --> 00:32:22,640
בשם יהיה לי 3, כמו גם.

789
00:32:22,640 --> 00:32:23,580
האם זה הגיוני?

790
00:32:23,580 --> 00:32:24,780

791
00:32:24,780 --> 00:32:25,794
כן?

792
00:32:25,794 --> 00:32:31,008
>> תלמיד: אם אתה נותן לחמישה כמו
יש לו כמספר שלם x במקום,

793
00:32:31,008 --> 00:32:32,910
היה שמתקנת את הכל?

794
00:32:32,910 --> 00:32:36,290
>> בינקי: אם זה integer-- לא,
שלא לתקן את הכל.

795
00:32:36,290 --> 00:32:37,590
כך שזו שאלה טובה מאוד.

796
00:32:37,590 --> 00:32:40,480
זה לא ממש משנה מה
אתה קורא כל המשתנים הללו.

797
00:32:40,480 --> 00:32:44,510
שוב, זה יהיה נושא של היקף,
בגלל שהם לא אותו הדבר x.

798
00:32:44,510 --> 00:32:46,526
הם לחלוטין
חללים שונים בזיכרון.

799
00:32:46,526 --> 00:32:47,400
תלמיד: [לא ברור].

800
00:32:47,400 --> 00:32:49,020
בינקי: אז זה לא ממש
משנה מה אתה קורא להם.

801
00:32:49,020 --> 00:32:50,480
זה לא לתקן את הדברים, בסדר?

802
00:32:50,480 --> 00:32:53,390

803
00:32:53,390 --> 00:32:54,430
עוד שאלות?

804
00:32:54,430 --> 00:32:55,762
כן?

805
00:32:55,762 --> 00:32:58,498
>> תלמיד: איך זה לחזור ל
מספר חמש [לא ברור]?

806
00:32:58,498 --> 00:32:59,661

807
00:32:59,661 --> 00:33:01,160
בינקי: בסדר, אנחנו לא עשינו את זה עדיין.

808
00:33:01,160 --> 00:33:03,432
בואו נלך למספר חמש, ולאחר מכן.

809
00:33:03,432 --> 00:33:04,650
>> תלמיד: [לא ברור]?

810
00:33:04,650 --> 00:33:05,565
>> בינקי: מה?

811
00:33:05,565 --> 00:33:08,179
>> תלמיד: האם יש לך תמורה בכלל?

812
00:33:08,179 --> 00:33:09,970
בינקי: אין לנו
תמורה, לא של עיקרי.

813
00:33:09,970 --> 00:33:12,940
אך חוזר ראשי 0 באופן אוטומטי
אם אתה לא מחזיר שום דבר.

814
00:33:12,940 --> 00:33:14,400

815
00:33:14,400 --> 00:33:15,188
כן?

816
00:33:15,188 --> 00:33:22,658
>> תלמיד: האם אתה יכול לעשות main-- או
אתה יכול לעשות עד חמש תמורה?

817
00:33:22,658 --> 00:33:24,170

818
00:33:24,170 --> 00:33:27,990
>> יש לנו יכול: בינקי
חמש לחזור, כן.

819
00:33:27,990 --> 00:33:32,527
אבל אז היינו x צריך להקצות
שווה ערך ההחזרה של עד חמש,

820
00:33:32,527 --> 00:33:34,360
אשר יהיה מעט
תכנית אחרת.

821
00:33:34,360 --> 00:33:35,440
זה יעבוד.

822
00:33:35,440 --> 00:33:38,730
אבל מה שאנחנו רוצים לעשות הוא מה שהוא
נקרא לשנות משהו במקום.

823
00:33:38,730 --> 00:33:41,690
אז אנחנו רוצים בעצם
לשנות תיבה ושלא לדאוג

824
00:33:41,690 --> 00:33:44,390
על זה שצריך לחזור
ערכים או כל דבר.

825
00:33:44,390 --> 00:33:44,890
בסדר?

826
00:33:44,890 --> 00:33:46,490

827
00:33:46,490 --> 00:33:50,150
>> זה בדיוק כמו פונקצית swap
דוד הראה בהרצאה, רק שאני

828
00:33:50,150 --> 00:33:51,740
התמודדות עם משתנה אחד בלבד.

829
00:33:51,740 --> 00:33:55,960
והוא השתמש בשני, כך int A ו- B ו
אז משתנה זמני ומה לא.

830
00:33:55,960 --> 00:33:57,020
בסדר?

831
00:33:57,020 --> 00:33:58,070
אז מה השורה האחרונה?

832
00:33:58,070 --> 00:34:04,400
לאחר חמש חזרות, זה
פשוט הולך להיעלם.

833
00:34:04,400 --> 00:34:06,120

834
00:34:06,120 --> 00:34:10,179
לא תהיה לנו יותר, ו
רק x עדיין ימשיך להתקיים.

835
00:34:10,179 --> 00:34:12,130
>> ונחש מה? x
לא לשנות את הערך שלו,

836
00:34:12,130 --> 00:34:15,520
אחרי הכל, בגלל שאנחנו
רק שינוי ערכו של.

837
00:34:15,520 --> 00:34:17,370
זו הסיבה שx היה 3 בכל.

838
00:34:17,370 --> 00:34:17,870
בסדר?

839
00:34:17,870 --> 00:34:20,195

840
00:34:20,195 --> 00:34:21,130
טוב.

841
00:34:21,130 --> 00:34:23,560
אז התכנית הזאת לא
להשיג את מה שרצינו.

842
00:34:23,560 --> 00:34:24,760
עכשיו בואו נתקן את זה.

843
00:34:24,760 --> 00:34:27,440
>> ותכנית התיקון היא שימוש במצביעים.

844
00:34:27,440 --> 00:34:32,300
מה שאנחנו עושים הוא שיש לנו שלוש
קווים שהם שונים.

845
00:34:32,300 --> 00:34:34,020
הראשונים הוא שאנחנו לא עוברים x.

846
00:34:34,020 --> 00:34:35,535
אנחנו עוברים את הכתובת של x.

847
00:34:35,535 --> 00:34:37,330

848
00:34:37,330 --> 00:34:40,876
אז במקום העתקה של
הערך של התיבה,

849
00:34:40,876 --> 00:34:42,500
אני עדיין הולך להעתיק משהו.

850
00:34:42,500 --> 00:34:45,380
אבל אני מעתיק מעל
הכתובת של התיבה.

851
00:34:45,380 --> 00:34:48,780
>> אז אם אני עובר את הכתובת של
שלה תיבת חמש, אז עד חמש

852
00:34:48,780 --> 00:34:51,560
תוכל למצוא את זה ב
זיכרון ולשנות את הערך שלו.

853
00:34:51,560 --> 00:34:53,980

854
00:34:53,980 --> 00:34:59,580
>> אז ולאחר מכן שם למעלה, יש לי
זה לא int יותר.

855
00:34:59,580 --> 00:35:00,882
הוא כוכב int.

856
00:35:00,882 --> 00:35:02,090
זה מצביע למספר שלם.

857
00:35:02,090 --> 00:35:03,790

858
00:35:03,790 --> 00:35:07,310
ואז, מכיוון שאני עובר
תעסוק כאן, ולאחר מכן מה שאני עושה

859
00:35:07,310 --> 00:35:10,530
לא שווה 5, משום ש
מחזיק את כתובת.

860
00:35:10,530 --> 00:35:16,710
אז מה שאני רוצה לעשות הוא ללכת לשם ו
לעדכן את התוכן של כתובת זו

861
00:35:16,710 --> 00:35:18,305
עם 5.

862
00:35:18,305 --> 00:35:21,130
>> אוקיי, אז בואו נעבור
כל קווים בזה אחר זה.

863
00:35:21,130 --> 00:35:22,410

864
00:35:22,410 --> 00:35:26,024
לכן, כאשר אני מתחיל כאן, אני
עדיין יש לי N /, N / A, N /

865
00:35:26,024 --> 00:35:28,440
לכל דבר בראשון
קו, כי יש לי לא ממש

866
00:35:28,440 --> 00:35:29,390
הכריז דברים עדיין.

867
00:35:29,390 --> 00:35:30,980

868
00:35:30,980 --> 00:35:35,110
ולאחר מכן בשורה שתיים, יש לי x שווה 3.

869
00:35:35,110 --> 00:35:38,020
כוכב int לא קיימת,
אותו דבר כמו קודם.

870
00:35:38,020 --> 00:35:39,160

871
00:35:39,160 --> 00:35:40,640
>> עכשיו זה נהיה מעניין.

872
00:35:40,640 --> 00:35:42,300
אז אני הולך לעבור.

873
00:35:42,300 --> 00:35:45,720
ונניח שאת הכתובת
של x הוא 12 בהקסדצימלי.

874
00:35:45,720 --> 00:35:46,880

875
00:35:46,880 --> 00:35:48,420
בואו פשוט מניחים שזה.

876
00:35:48,420 --> 00:35:49,221
אני המצאתי את זה.

877
00:35:49,221 --> 00:35:51,680

878
00:35:51,680 --> 00:35:53,500
אז מה אני עובר כאן הוא עד חמש.

879
00:35:53,500 --> 00:35:54,460
אני מעביר 12.

880
00:35:54,460 --> 00:35:56,390

881
00:35:56,390 --> 00:35:58,610
>> אז מה ערך יש ל?

882
00:35:58,610 --> 00:36:04,785

883
00:36:04,785 --> 00:36:06,210
>> תלמיד: [לא ברור].

884
00:36:06,210 --> 00:36:06,950
>> בינקי: מצטער?

885
00:36:06,950 --> 00:36:08,145
>> תלמיד: [לא ברור].

886
00:36:08,145 --> 00:36:10,520
בינקי: כן, כמו, לבואו
תניח שאנו נמצאים כאן, עכשיו.

887
00:36:10,520 --> 00:36:11,540

888
00:36:11,540 --> 00:36:12,040
אני מבקש.

889
00:36:12,040 --> 00:36:12,915
>> תלמיד: [לא ברור].

890
00:36:12,915 --> 00:36:13,590

891
00:36:13,590 --> 00:36:14,890
>> בינקי: זה כבר יזם.

892
00:36:14,890 --> 00:36:15,860
>> תלמיד: [לא ברור].

893
00:36:15,860 --> 00:36:17,985
בינקי: מפני שהעברנו
משהו לפונקציה.

894
00:36:17,985 --> 00:36:19,431

895
00:36:19,431 --> 00:36:19,930
כן?

896
00:36:19,930 --> 00:36:20,899
>> תלמיד: כתובת של x.

897
00:36:20,899 --> 00:36:22,690
בינקי: זה הולך ל
יש את הכתובת של x.

898
00:36:22,690 --> 00:36:25,800
ואת הכתובת של x היא 12, טובה.

899
00:36:25,800 --> 00:36:30,990
אז x הולך להיות 3, כי
אנו לא באמת השתנו x עדיין.

900
00:36:30,990 --> 00:36:36,700
ואז הוא הולך להיות 0x12, כך
הכתובת של x, כי זה

901
00:36:36,700 --> 00:36:38,840
מה שעברנו לחמש.

902
00:36:38,840 --> 00:36:40,940
>> ואז מה קורה
אם תנסו ללכת לשם?

903
00:36:40,940 --> 00:36:42,145
מה אנחנו הולכים למצוא?

904
00:36:42,145 --> 00:36:47,120
אז אם אתה מנסה להדפיס לככב,
אנחנו הולכים למעקב כתובת זו

905
00:36:47,120 --> 00:36:48,620
ולקבל את הערך בתוך.

906
00:36:48,620 --> 00:36:50,470
והערך הוא רק
אותו הערך שx

907
00:36:50,470 --> 00:36:53,980
יש כי זה
כתובת של x, שתהיה 3.

908
00:36:53,980 --> 00:36:55,440

909
00:36:55,440 --> 00:36:56,930
האם אנחנו טובים?

910
00:36:56,930 --> 00:36:59,990
>> אישור, ולאחר מכן עכשיו, אנחנו באמת הולכים לשם.

911
00:36:59,990 --> 00:37:05,510
ואנו מעדכנים את כל מה ש
הוא בכתובת זו 12.

912
00:37:05,510 --> 00:37:07,390
אנחנו עושים את זה 5.

913
00:37:07,390 --> 00:37:10,560
אז עכשיו הן X וכוכב הן 5.

914
00:37:10,560 --> 00:37:13,170

915
00:37:13,170 --> 00:37:13,680
>> מדוע זה כך?

916
00:37:13,680 --> 00:37:17,070
מכיוון שהכתובת של x היא 12.

917
00:37:17,070 --> 00:37:20,920
ויש גם 12 כערך שלו.

918
00:37:20,920 --> 00:37:23,780
אז אם אנו עוקבים אחר 12, אנחנו
רק הולך למצוא x.

919
00:37:23,780 --> 00:37:27,400
אז מה אנחנו עושים עם
כוכב הולך לקרות

920
00:37:27,400 --> 00:37:30,790
לx, כי מכיל
הכתובת של x.

921
00:37:30,790 --> 00:37:31,918

922
00:37:31,918 --> 00:37:32,418
בסדר?

923
00:37:32,418 --> 00:37:34,090

924
00:37:34,090 --> 00:37:37,750
>> ואת זה הוא כמו גופו של התיקון.

925
00:37:37,750 --> 00:37:41,500
אז עכשיו אנחנו יכולים,
מחמישה, בעצם

926
00:37:41,500 --> 00:37:43,840
זיכרון גישה שחי בעיקרי.

927
00:37:43,840 --> 00:37:47,980
אז הזיכרון הזה אינו מתגורר ל
חמש, כמו לפני, כתובת זו 12.

928
00:37:47,980 --> 00:37:50,980
ואנחנו היינו יכולים ללכת לשם
ולשנות את הערך שלה ל -5.

929
00:37:50,980 --> 00:37:53,990
>> ואז כשנחזור,
אנחנו שוכחים.

930
00:37:53,990 --> 00:37:55,720
אנחנו שוכחים את הכוכב.

931
00:37:55,720 --> 00:37:57,020
וx הוא עדיין חמש.

932
00:37:57,020 --> 00:37:58,327

933
00:37:58,327 --> 00:38:00,160
אז אם אתם רוצים
ליישם פונקצית swap,

934
00:38:00,160 --> 00:38:05,010
היית עושה בדיוק את אותו הדבר רק,
מלבד אתה צריך int כוכבים כאן,

935
00:38:05,010 --> 00:38:06,140
וכן הלאה וכן הלאה.

936
00:38:06,140 --> 00:38:06,976
בסדר?

937
00:38:06,976 --> 00:38:07,475
האם אנחנו טובים?

938
00:38:07,475 --> 00:38:09,860

939
00:38:09,860 --> 00:38:10,610
מגניב.

940
00:38:10,610 --> 00:38:12,410
>> אז מצביע חשבון.

941
00:38:12,410 --> 00:38:13,960
זהו נושא מעט מסובך.

942
00:38:13,960 --> 00:38:16,554
אז מתברר ש
מצביעים הם רק מספרים שלמים.

943
00:38:16,554 --> 00:38:17,970
אתה יכול לחשוב עליהם כמספרים שלמים.

944
00:38:17,970 --> 00:38:21,080
כי בזיכרון, יש לך כמו
זיכרון כתובת אפס, אחת, שתיים, שלוש,

945
00:38:21,080 --> 00:38:21,900
ארבעה, חמש.

946
00:38:21,900 --> 00:38:23,900
אז אנחנו יכולים לסכם כתובות זיכרון.

947
00:38:23,900 --> 00:38:27,230
>> וזה בדרך כלל מה שאתה עושה כש
אתה ובמערך, למשל.

948
00:38:27,230 --> 00:38:30,540
מערך הוא בדיוק כמו רציף
בלוק של זיכרון, של המון תווים,

949
00:38:30,540 --> 00:38:31,840
לדוגמא, הרבה ints.

950
00:38:31,840 --> 00:38:34,420
אז אם אתה רוצה ללכת ל
שני int או int השלישי,

951
00:38:34,420 --> 00:38:37,830
רק אתה יכול לסכם משהו לראשון
כתובת, ואתה הולך להגיע לשם.

952
00:38:37,830 --> 00:38:39,620
אז זה ממש שימושי בשביל זה.

953
00:38:39,620 --> 00:38:41,850
>> והדבר כדי לשמור על
בראש, אם כי, הוא

954
00:38:41,850 --> 00:38:45,140
כי זה לא רק אוהב
חשבון נורמלי במובן

955
00:38:45,140 --> 00:38:50,304
כי אם אתה עם התמודדות, אומר,
כוכב int, ואתה מוסיף 1 לזה,

956
00:38:50,304 --> 00:38:52,220
אז אתה לא הולך
להוסיף 1 לכתובת,

957
00:38:52,220 --> 00:38:53,950
אתה הולך להוסיף 4 לכתובת.

958
00:38:53,950 --> 00:38:55,030

959
00:38:55,030 --> 00:38:56,670
בגלל int הוא 4 בתים.

960
00:38:56,670 --> 00:38:57,720

961
00:38:57,720 --> 00:38:59,540
>> אז זה בדיוק כמו
הליכה על מערך.

962
00:38:59,540 --> 00:39:05,260
אם יש לנו מערך של הרבה ints ו
אז אנחנו מנסים ללכת לשנייה אחת,

963
00:39:05,260 --> 00:39:08,790
זה בעצם רק סיכום
כתובת של הראשון בתוספת 1.

964
00:39:08,790 --> 00:39:10,040

965
00:39:10,040 --> 00:39:13,425
אבל זה לא be-- רק נניח
כי הכתובת של הראשונה היא 4.

966
00:39:13,425 --> 00:39:14,560

967
00:39:14,560 --> 00:39:16,250
כאן, במקרה זה.

968
00:39:16,250 --> 00:39:19,780

969
00:39:19,780 --> 00:39:22,850
ואם נסכם, אז זה
זה מה שקורה.

970
00:39:22,850 --> 00:39:23,530
יש לנו int.

971
00:39:23,530 --> 00:39:25,640
Int x שווה 5.

972
00:39:25,640 --> 00:39:26,950
יש X ערך 5.

973
00:39:26,950 --> 00:39:31,240
ונאתחל את מצביע זה, int
y כוכב int y שווה לכתובת של x.

974
00:39:31,240 --> 00:39:33,660
>> הבה נניח את הכתובת של x היא 4.

975
00:39:33,660 --> 00:39:36,960
מה הולך לקרות
עכשיו, אם אני מסכם להוסיף 1 לy?

976
00:39:36,960 --> 00:39:39,110

977
00:39:39,110 --> 00:39:44,790
זה הולך בעצם
סכום 4 ולא רק 1.

978
00:39:44,790 --> 00:39:50,920
אז אני מוסיף 1, אבל זה בעצם
הוסיף 4, משום שהמחשב של חכם.

979
00:39:50,920 --> 00:39:55,275
אז זה הולך להוסיף בפועל על ידי i פעמים
גודלו של הסוג של המצביע.

980
00:39:55,275 --> 00:39:56,340

981
00:39:56,340 --> 00:39:56,840
בסדר?

982
00:39:56,840 --> 00:39:58,030

983
00:39:58,030 --> 00:40:02,440
>> אז אם זה היה char, למשל,
אם זה היה y כוכב char,

984
00:40:02,440 --> 00:40:07,141
ואם הוסיפו 1 אז היית זה
להיות 5, כי char הוא ארוך בייט 1.

985
00:40:07,141 --> 00:40:07,640
טוב?

986
00:40:07,640 --> 00:40:10,560

987
00:40:10,560 --> 00:40:13,190
>> ולבסוף, הגענו ל
מצביעים ומערכים.

988
00:40:13,190 --> 00:40:16,451
מתברר שבכל פעם
יש לך עסק עם מערך,

989
00:40:16,451 --> 00:40:18,075
אתה בעצם מתמודד עם מצביע.

990
00:40:18,075 --> 00:40:19,720

991
00:40:19,720 --> 00:40:24,777
הסיבה הרעיונית נחמדה מאוד ל
זה הוא שמערכים הם גדולים מאוד.

992
00:40:24,777 --> 00:40:27,360
אז זוכר שאמרתי ש
בכל פעם שאתה עובר דברים מסביב,

993
00:40:27,360 --> 00:40:29,097
אתה מעתיק הכל.

994
00:40:29,097 --> 00:40:31,180
אז אם יש לך מערך
זה ממש, ממש גדול,

995
00:40:31,180 --> 00:40:32,990
אתה לא באמת רוצה
להעתיק הכל בכל פעם

996
00:40:32,990 --> 00:40:35,710
אתה עובר אותו סביב למשנהו
פונקציה, כי זה פשוט

997
00:40:35,710 --> 00:40:37,190
כמויות עצומות של עבודה.

998
00:40:37,190 --> 00:40:39,710
אז מה שאתה עושה הוא רק האחרון
את הכתובת של הבית הראשון.

999
00:40:39,710 --> 00:40:40,969

1000
00:40:40,969 --> 00:40:44,010
ואז הפונקציה תהיה גישה
לכל האלמנטים במערך ש.

1001
00:40:44,010 --> 00:40:48,670
אז עבר את המערך על ידי הכתובת שלו,
כך את הכתובת של הבית הראשון.

1002
00:40:48,670 --> 00:40:53,010
>> אז אם אנו מצהירים int
מערך 3, כאן, אנחנו יודעים

1003
00:40:53,010 --> 00:40:57,470
כיצד לגשת לאלמנט הראשון
באמצעות סימון הסוגר.

1004
00:40:57,470 --> 00:41:02,410
אם אתה זוכר את התושבת
סימון, תושבת מערך 0 שווה 1.

1005
00:41:02,410 --> 00:41:06,330
ובכן, זה יהיה בדיוק
אותו דבר כמו פשוט ללכת לשם ולשים 1.

1006
00:41:06,330 --> 00:41:07,370

1007
00:41:07,370 --> 00:41:09,110
אישור, זה בדיוק אותו הדבר.

1008
00:41:09,110 --> 00:41:13,010
אז סימון הסוגר כאן
יהיה זהה לקו הזה.

1009
00:41:13,010 --> 00:41:18,600
>> ונחש מה סימון הסוגר
לתושבת מערך 1 יהיה?

1010
00:41:18,600 --> 00:41:20,440
זה פשוט יהיה אותו הדבר כמו זה.

1011
00:41:20,440 --> 00:41:22,500
אז להוסיף אחד למערך.

1012
00:41:22,500 --> 00:41:24,370
מהלך אחד לאורך בזיכרון.

1013
00:41:24,370 --> 00:41:26,310
ללכת לשם, ולשים 2.

1014
00:41:26,310 --> 00:41:28,050

1015
00:41:28,050 --> 00:41:28,579
בסדר?

1016
00:41:28,579 --> 00:41:29,870
והקו הזה אותו דבר.

1017
00:41:29,870 --> 00:41:34,860
אנחנו רוצים ללכת לשלישיים
תיבה, כך מערך בתוספת 2.

1018
00:41:34,860 --> 00:41:37,465
ללכת לשם, ולשים 3.

1019
00:41:37,465 --> 00:41:39,340
אז בזיכרון, מה ש
הולך לקרות הוא שאנחנו

1020
00:41:39,340 --> 00:41:44,400
הולך להיות 1, 2, ו -3 כ
שלושה אלמנטים של מערך זה.

1021
00:41:44,400 --> 00:41:46,970
>> היינו יכול לעשות את זה באמצעות
סימון התושבת המוכר שלנו.

1022
00:41:46,970 --> 00:41:49,410
אני רק רוצה שבחורים לדעת
שהם אותו הדבר.

1023
00:41:49,410 --> 00:41:50,530

1024
00:41:50,530 --> 00:41:53,010
אישור, שאלות על זה?

1025
00:41:53,010 --> 00:41:56,115

1026
00:41:56,115 --> 00:41:56,615
נחמד.

1027
00:41:56,615 --> 00:41:57,990

1028
00:41:57,990 --> 00:41:59,880
עכשיו, אני הולך למסור
זה מעל לחנה,

1029
00:41:59,880 --> 00:42:00,330
>> חנה: יש, איי-האו.

1030
00:42:00,330 --> 00:42:02,246
>> בינקי: מדבר על
זיכרון ודברים מאמר.

1031
00:42:02,246 --> 00:42:06,554
[מחיאות כפות]

1032
00:42:06,554 --> 00:42:10,150
>> חנה: היי, מגניב, כך שאנחנו
הולך לדבר קצת יותר

1033
00:42:10,150 --> 00:42:13,090
על זיכרון, שאנחנו פשוט
התייחס שימוש במצביעים.

1034
00:42:13,090 --> 00:42:16,060
אז יש שני חלקים עיקריים של
זיכרון שבה אנו עוסקים.

1035
00:42:16,060 --> 00:42:18,830
יש לנו הערימה, שבו גדל
בתחתית, והערימה, ש

1036
00:42:18,830 --> 00:42:20,600
יורד מלמעלה.

1037
00:42:20,600 --> 00:42:24,690
והערימה הולכת להחזיק
כל המשתנים שלנו.

1038
00:42:24,690 --> 00:42:28,860
אז כל שיחות לפונקציה מקבלת
מסגרת משלה קטנה בערימה.

1039
00:42:28,860 --> 00:42:32,160
אז כפי שגייב שהוזכר קודם לכן, אם
לקרוא את הפונקציה שוב ושוב,

1040
00:42:32,160 --> 00:42:34,180
אנחנו הולכים למחסנית
דברים על הערימה.

1041
00:42:34,180 --> 00:42:35,220

1042
00:42:35,220 --> 00:42:38,570
>> ובאופן דומה, הערימה,
אשר מתחילה בראש

1043
00:42:38,570 --> 00:42:42,660
הוא הולך להחזיק בכל הזיכרון
שאנחנו דינמי להקצות.

1044
00:42:42,660 --> 00:42:45,110
וכן, ככל שבאופן דינמי
להקצות זיכרון,

1045
00:42:45,110 --> 00:42:47,580
זה יבוא לכיוון החלק התחתון.

1046
00:42:47,580 --> 00:42:51,340
דברים בני זוג להיות מודעים כאשר
אנחנו משתמשים במחסנית והערימה,

1047
00:42:51,340 --> 00:42:55,200
עם הערימה, אם יש לנו יותר מדי
many-- בואו say-- שיחות רקורסיבית,

1048
00:42:55,200 --> 00:42:58,392
ואנחנו קוראים לפונקציה שוב,
ושוב, ושוב, ושוב,

1049
00:42:58,392 --> 00:43:00,350
וזה לערום את,
לערום את, לערום את.

1050
00:43:00,350 --> 00:43:01,570
וזה הולך לקרוס לתוך הערימה.

1051
00:43:01,570 --> 00:43:03,040
אנחנו הולכים נגמרים של זיכרון.

1052
00:43:03,040 --> 00:43:05,100
זה הולך לגרום ל
בעיה למחשב.

1053
00:43:05,100 --> 00:43:06,770
וזה נקרא הצפת המחסנית.

1054
00:43:06,770 --> 00:43:09,728
אז זה בהחלט משהו שאתה
צריך להיות מודע ומנסה להימנע.

1055
00:43:09,728 --> 00:43:10,228

1056
00:43:10,228 --> 00:43:14,050
והערימה, צריכה לזכור
לא להדליף בטעות זיכרון.

1057
00:43:14,050 --> 00:43:17,950
כל פעם שאתה משתמש malloc, לא
תשכח לשחרר זיכרון ש.

1058
00:43:17,950 --> 00:43:20,040
אחרת, זה יהיה רק
להיות על הערימה מבוזבזת,

1059
00:43:20,040 --> 00:43:23,230
והמחשב לא יודע ש
זה חופשי לשימוש זיכרון ש.

1060
00:43:23,230 --> 00:43:25,810
אז אלה הם כמה דברים
להיות זהיר מאוד עם כש

1061
00:43:25,810 --> 00:43:28,580
עם יש לך עסק
המחסנית והערימה.

1062
00:43:28,580 --> 00:43:30,412
שאלות עם זה?

1063
00:43:30,412 --> 00:43:31,304
מדהים.

1064
00:43:31,304 --> 00:43:31,900
>> אישור, מגניב.

1065
00:43:31,900 --> 00:43:32,940

1066
00:43:32,940 --> 00:43:36,810
אז מסוג זה יש את אותו
רעיון כהצפת מחסנית, שבו

1067
00:43:36,810 --> 00:43:39,850
אנחנו הולכים מעבר ל
גבולות של מה זיכרון

1068
00:43:39,850 --> 00:43:41,960
הוא שאנחנו אמורים להיות מסוגלים להשתמש.

1069
00:43:41,960 --> 00:43:45,077
אז קח, למשל, חיץ, או שאתה
רק יכל לחשוב על זה כעל מערך.

1070
00:43:45,077 --> 00:43:47,660
ואנחנו אמרו, בסדר, אנחנו הולכים
ליצור מערך קטן ונחמד.

1071
00:43:47,660 --> 00:43:49,140
זה הולך להיות מחרוזת.

1072
00:43:49,140 --> 00:43:50,630
או שזה הולך לאחסון תווים.

1073
00:43:50,630 --> 00:43:51,720
וזה רק הולך להגיד שלום.

1074
00:43:51,720 --> 00:43:52,678
וזה לא מוגדר.

1075
00:43:52,678 --> 00:43:53,990
זֶה הַכֹּל.

1076
00:43:53,990 --> 00:43:58,240
>> אבל אם היינו מישהו רע ורציתי
לעשות משהו רע עם המערך הזה, מה ש

1077
00:43:58,240 --> 00:44:02,310
אני יכול לעשות הוא לנסות לכתוב
עבר את קצה החוט.

1078
00:44:02,310 --> 00:44:04,490
וכפי שתראה, אם
אני כותב מספיק רחוק,

1079
00:44:04,490 --> 00:44:06,980
אני ממש יכול להשפיע
כתובת השולח.

1080
00:44:06,980 --> 00:44:09,530
ואם אני מתחיל להשפיע
כתובת השולח,

1081
00:44:09,530 --> 00:44:11,730
אני משפיע על איך התוכנה פועלת למעשה.

1082
00:44:11,730 --> 00:44:15,900
ובמקום לחזור, אתה
יודע, מחרוזת שמחה כמו שלום, אני

1083
00:44:15,900 --> 00:44:19,460
יכול לעשות משהו רע, כמו ללכת ל
במקום אחר במחשב שלך, עדיין

1084
00:44:19,460 --> 00:44:22,146
זיכרון, לשנות אותו,
כל מה שאני רוצה לעשות.

1085
00:44:22,146 --> 00:44:25,020
אז זה מה שזה היה נראה כמו
הוא אם אני פשוט סוג של מילאתי ​​אותה

1086
00:44:25,020 --> 00:44:27,400
עם ערך אקראי אשפה,
במקרה זה, רק.

1087
00:44:27,400 --> 00:44:30,490
ואז כשאני באמת
הגעתי לכתובת בזיכרון,

1088
00:44:30,490 --> 00:44:33,740
התחלתי למלא אותו במשהו
שעשה מה שרציתי לעשות את זה.

1089
00:44:33,740 --> 00:44:34,952

1090
00:44:34,952 --> 00:44:36,410
שאלות עם הצפת מאגר?

1091
00:44:36,410 --> 00:44:38,450

1092
00:44:38,450 --> 00:44:40,730
נכון מדהים, עף
מתחת לזה.

1093
00:44:40,730 --> 00:44:43,530
>> אוקיי, אז דברנו הרבה
על מצביע עם גייב.

1094
00:44:43,530 --> 00:44:45,790
איך אנחנו באמת מקבלים מצביע?

1095
00:44:45,790 --> 00:44:48,070
איך אנחנו מקבלים את הכתובת בזיכרון?

1096
00:44:48,070 --> 00:44:51,040
ובכן, אנחנו יכולים להשתמש בזה נחמד
malloc קריאה לפונקציה, ש

1097
00:44:51,040 --> 00:44:53,370
הוא הולך לקבל
חתיכה קטנה של זיכרון,

1098
00:44:53,370 --> 00:44:55,480
במיוחד ב
ערימה, כפי שדנו,

1099
00:44:55,480 --> 00:44:59,780
וזה הולך להחזיר לך
מצביע לכתובת שבזיכרון.

1100
00:44:59,780 --> 00:45:01,950
ואת הטענה שאנו
צריך לתת לmalloc

1101
00:45:01,950 --> 00:45:04,280
הוא כמה מקום בזיכרון שאנחנו רוצים.

1102
00:45:04,280 --> 00:45:06,100
>> אז אתה יכול לראות את הגודל בבתים.

1103
00:45:06,100 --> 00:45:08,670
נניח, לדוגמא, או
למעשה, בדוגמא זו,

1104
00:45:08,670 --> 00:45:12,040
אנו מקצים מספיק
חלל במשך 10 מספרים שלמים.

1105
00:45:12,040 --> 00:45:15,640
אז כנראה מה שאנחנו הולכים רוצים
לשים כאן הוא מערך של 10 מספרים שלמים.

1106
00:45:15,640 --> 00:45:19,641
אז אנחנו נותנים לו גודל של ints, ש
מה שלמדנו היה בתים כמה?

1107
00:45:19,641 --> 00:45:20,140
תלמיד: 4.

1108
00:45:20,140 --> 00:45:22,920
חנה: 4, יפה, ואנחנו
רוצה 10 של אלה בשורה,

1109
00:45:22,920 --> 00:45:28,050
כך שיש לנו מספיק מקום ל
לאחסן את כל 10 המספרים השלמים, במקרה זה.

1110
00:45:28,050 --> 00:45:31,290
משהו סופר חשוב,
כל פעם שאתה קורא malloc,

1111
00:45:31,290 --> 00:45:32,880
אתה צריך לבדוק לnull.

1112
00:45:32,880 --> 00:45:37,310
אם אתה לא לבדוק null, גם,
malloc אם הוא פועל מתוך שטח

1113
00:45:37,310 --> 00:45:40,400
וכבר לא יכול לתת לך כל
יותר זיכרון, זה יחזיר null.

1114
00:45:40,400 --> 00:45:42,060

1115
00:45:42,060 --> 00:45:45,630
אז אם אתה לא בודק,
malloc עשוי להחזיר null.

1116
00:45:45,630 --> 00:45:51,265
ואז אם אנחנו מנסים
dereference מצביע null,

1117
00:45:51,265 --> 00:45:54,960
אנחנו הולכים לקבל באשמת פילוח,
שנדברנו עליו כרגע.

1118
00:45:54,960 --> 00:45:56,150

1119
00:45:56,150 --> 00:45:56,650
מדהים.

1120
00:45:56,650 --> 00:45:58,300
>> אישור, שאלות עם malloc?

1121
00:45:58,300 --> 00:46:00,044

1122
00:46:00,044 --> 00:46:00,544
כן?

1123
00:46:00,544 --> 00:46:05,460
>> תלמיד: האם בדיקת null
[לא ברור] לא עושה את זה בחידון?

1124
00:46:05,460 --> 00:46:08,100
>> חנה: בטח, השאלה הייתה
האם זה עניין בחידון,

1125
00:46:08,100 --> 00:46:10,420
אתה מקבל נקודות מאם
אתה לא לבדוק null?

1126
00:46:10,420 --> 00:46:12,794
כן, אתה תקבל נקודות מ
אם אתה לא לבדוק null.

1127
00:46:12,794 --> 00:46:16,030
כל פעם שאתה קורא malloc, הן ב
חידון וpsets שלך ובחיים אמיתיים,

1128
00:46:16,030 --> 00:46:17,155
אתה צריך לבדוק לnull.

1129
00:46:17,155 --> 00:46:18,330
שאלה טובה.

1130
00:46:18,330 --> 00:46:19,689
>> גייב: מה אם אני לא חופשי?

1131
00:46:19,689 --> 00:46:21,730
חנה: גייב רוצה לדעת
מה אם אנחנו לא חופשיים.

1132
00:46:21,730 --> 00:46:25,030
אז תהיה לנו
דליפת זיכרון בערימה שלנו.

1133
00:46:25,030 --> 00:46:26,140
יש עוד שאלות?

1134
00:46:26,140 --> 00:46:27,550
כן?

1135
00:46:27,550 --> 00:46:30,120
>> תלמיד: האם you-- לעבור על
הצפת מאגר אמיתי מהיר שוב?

1136
00:46:30,120 --> 00:46:30,530
>> חנה: בטח.

1137
00:46:30,530 --> 00:46:33,071
השאלה הייתה שאנחנו יכולים לעבור על
הצפת מאגר באמת מהירה.

1138
00:46:33,071 --> 00:46:35,050
בואו נחזור לשקופיות אלה.

1139
00:46:35,050 --> 00:46:37,430
אז חיץ, אתה יכול פשוט
חושב על זה כעל מערך, נכון?

1140
00:46:37,430 --> 00:46:39,360
יש לך קצת מקום בזיכרון.

1141
00:46:39,360 --> 00:46:43,580
וכאשר אנו יוצרים המערך ראשון שלנו,
אנחנו יודעים מערכים תיקנו גודל,

1142
00:46:43,580 --> 00:46:45,470
או שיש החיץ שלנו בגודל קבוע.

1143
00:46:45,470 --> 00:46:51,360
>> אז בואו נגיד שבמקרה זה, יש לנו רק
מספיק מקום כדי לכתוב את מחרוזת שלום.

1144
00:46:51,360 --> 00:46:57,340
אם נלך האחרון שקשר, אם אנחנו הולכים האחרונים
מה המערך שלנו אמר שזה יכול להחזיק,

1145
00:46:57,340 --> 00:46:59,780
אנחנו באמת יכולים להתחיל
כתיבה לזיכרון

1146
00:46:59,780 --> 00:47:01,780
שהמחשב אינו
רוצה לכתוב ל.

1147
00:47:01,780 --> 00:47:02,810

1148
00:47:02,810 --> 00:47:05,580
ובאופן ספציפי, אם פגעו
משהו כמו חזרה

1149
00:47:05,580 --> 00:47:08,700
כתובת של הפונקציה, אשר,
כמו כל פיסת זיכרון אחרת,

1150
00:47:08,700 --> 00:47:11,420
רק אי שם בך
מחשב, אתה באמת יכול

1151
00:47:11,420 --> 00:47:14,080
לשנות את זה ולהתחיל לעשות דברים רעים.

1152
00:47:14,080 --> 00:47:15,272
לענות על השאלה שלך?

1153
00:47:15,272 --> 00:47:16,230
מדהים, כל דבר אחר?

1154
00:47:16,230 --> 00:47:17,466
כן?

1155
00:47:17,466 --> 00:47:21,948
>> תלמיד: אז מחסנית [לא ברור], ש
אמר ללכת מלמטה הולך למעלה.

1156
00:47:21,948 --> 00:47:25,434
בטווח מחסנית, עושה
הזיכרון הולך מ, כמו,

1157
00:47:25,434 --> 00:47:27,230
הראש מטה הנוגע לכל הפסקה?

1158
00:47:27,230 --> 00:47:28,646

1159
00:47:28,646 --> 00:47:32,100
>> חנה: איך לעשות you--
לדחות את רוב על זה.

1160
00:47:32,100 --> 00:47:35,370

1161
00:47:35,370 --> 00:47:38,213
>> ROB: זה יגדל באותו
כיוון כמו הערימה גדל.

1162
00:47:38,213 --> 00:47:38,712
חנה: אישור.

1163
00:47:38,712 --> 00:47:40,967
רוב: אז אני מתבלבל.

1164
00:47:40,967 --> 00:47:42,331
זה הולך להיות הפשטה.

1165
00:47:42,331 --> 00:47:42,831
חנה: אישור.

1166
00:47:42,831 --> 00:47:44,000
ROB: זה נכון.

1167
00:47:44,000 --> 00:47:49,420
אז אם הערימה גדלה
עד, אז generally-- זה

1168
00:47:49,420 --> 00:47:52,380
לא חייב להיות כך.
אבל אתה יכול להכריז x int.

1169
00:47:52,380 --> 00:47:54,120
אז אתה מצהיר y int.

1170
00:47:54,120 --> 00:47:57,300
אז int x בדרך כלל להיות
נמוך יותר במחסנית מאשר y int.

1171
00:47:57,300 --> 00:47:59,300
אבל זה פשוט עובדה.

1172
00:47:59,300 --> 00:48:02,410
שלא כמו דבר זרע חשוב.

1173
00:48:02,410 --> 00:48:06,800
>> רוב: אז השאלה שוב רק הייתה
מה קורה כל מסגרת מצטברת.

1174
00:48:06,800 --> 00:48:08,960
אז כל פונקציה מקבלת
חתיכה קטנה של הערימה.

1175
00:48:08,960 --> 00:48:13,030
וכמו שאתה הולך למעלה, בתוך ש
חתיכה קטנה, בתוך מסגרת ש,

1176
00:48:13,030 --> 00:48:16,710
אנחנו אומרים שמשתנים
בתוך המסגרת שגם לעלות.

1177
00:48:16,710 --> 00:48:17,473
שאלה?

1178
00:48:17,473 --> 00:48:18,688
>> ROB: רק כדי להיות על מיקרופון.

1179
00:48:18,688 --> 00:48:19,396
חנה: הו, כן.

1180
00:48:19,396 --> 00:48:20,440
ROB: אני אדבר אליך.

1181
00:48:20,440 --> 00:48:21,410
חנה: הו, כן, בסדר.

1182
00:48:21,410 --> 00:48:24,150
ROB: היוצא מן הכלל הוא
עבור מערכים וstructs,

1183
00:48:24,150 --> 00:48:27,470
שבו מערכים, נמוכים
מדד במערך,

1184
00:48:27,470 --> 00:48:29,930
ובstructs ב גבוה
שדה בstructs

1185
00:48:29,930 --> 00:48:35,040
מובטחים להיות נמוכות בכתובות
מ ערך מאוחר יותר במערך.

1186
00:48:35,040 --> 00:48:36,720
אז אלה הם מובטח.

1187
00:48:36,720 --> 00:48:40,310
אבל כל משתנים מסוימים בתוך,
כמו x int וint y בתוך פונקציה,

1188
00:48:40,310 --> 00:48:43,030
אין קשר הכרחי
בין הכתובות שלהם.

1189
00:48:43,030 --> 00:48:44,882

1190
00:48:44,882 --> 00:48:46,340
חנה: שאלה נוספת לכאן?

1191
00:48:46,340 --> 00:48:51,620
תלמיד: אז במאגר
זרימה, רק גלישת חוצץ

1192
00:48:51,620 --> 00:48:54,980
קרה רק כשאתה
יש, כמו, שהוקצה

1193
00:48:54,980 --> 00:49:01,056
סכום של מערך
כי אז הוא גדול יותר?

1194
00:49:01,056 --> 00:49:03,230
כמו, אתה יכול?

1195
00:49:03,230 --> 00:49:05,435
אז אם אתה שואל ל
משהו מuser--

1196
00:49:05,435 --> 00:49:06,018
>> חנה: ממ-הממ.

1197
00:49:06,018 --> 00:49:08,600
תלמיד: הם יכולים בכוח
לתת לך משהו בחזרה

1198
00:49:08,600 --> 00:49:11,777
זה גדול יותר מכל מה ש
שהוקצית להם?

1199
00:49:11,777 --> 00:49:13,610
חנה: בטח, כל כך
השאלה הייתה בעצם,

1200
00:49:13,610 --> 00:49:16,217
יכול המשתמש לתת לך
יותר ממה שאתה מבקש?

1201
00:49:16,217 --> 00:49:16,800
סטודנט: כן.

1202
00:49:16,800 --> 00:49:18,480
חנה: ובכן, אתה יכול למנוע
המשתמש מלעשות את זה.

1203
00:49:18,480 --> 00:49:21,350
אפשר לומר באופן ספציפי לא
תן לי יותר ממספר x על ידי בתים

1204
00:49:21,350 --> 00:49:24,330
נתתי לכם רק מקום למספר x
בתים, x מספר התווים.

1205
00:49:24,330 --> 00:49:25,700
אז זה משהו שאתה רוצה למנוע.

1206
00:49:25,700 --> 00:49:26,199
כן?

1207
00:49:26,199 --> 00:49:30,270
מה ההבדל בין
הצפת מחסנית וגלישת חוצץ?

1208
00:49:30,270 --> 00:49:32,140
>> חנה: בסדר, אז הערימה
overflow-- הו, מה

1209
00:49:32,140 --> 00:49:34,790
ההבדל בין הערימה
גלישה וגלישת מאגר?

1210
00:49:34,790 --> 00:49:37,581
אז אנחנו רוצים לחשוב על הצפת מחסנית
קורה כאשר אנחנו בעצם

1211
00:49:37,581 --> 00:49:39,530
לערום את הקריאות לפונקציות אלה.

1212
00:49:39,530 --> 00:49:42,991
בואו נגיד שיש לך פונקציה רקורסיבית,
כי אנחנו יודעים שכל פעם שאתה

1213
00:49:42,991 --> 00:49:45,240
לקרוא לפונקציה, זה מקבל
מסגרת משלה בערימה.

1214
00:49:45,240 --> 00:49:47,950
>> אז אנחנו מחסנית גבוהה מדי, ו
אז אנחנו מתחילים לעלות על גדותיו.

1215
00:49:47,950 --> 00:49:50,530
ואנו משתמשים בזיכרון רב מדי, ו
אנחנו לא השאירו שום מקום.

1216
00:49:50,530 --> 00:49:51,590
אנחנו מקבלים שגיאה ש.

1217
00:49:51,590 --> 00:49:53,930
>> הצפת המאגר נמצאת בתכנית.

1218
00:49:53,930 --> 00:49:57,180
אנחנו רוצים אולי לא בהכרח
נגמר זיכרון באותה הדרך

1219
00:49:57,180 --> 00:50:00,080
שאולי אם אנחנו לערום
עד קריאות לפונקציות רבות כל כך,

1220
00:50:00,080 --> 00:50:04,540
אבל אנחנו כותבים עבר הזיכרון
כי אנחנו יודעים שאנחנו יכולים להשתמש.

1221
00:50:04,540 --> 00:50:06,170
וזה מאפשר לנו לעשות דברים רעים.

1222
00:50:06,170 --> 00:50:08,060

1223
00:50:08,060 --> 00:50:08,560
כן?

1224
00:50:08,560 --> 00:50:10,950
>> ROB: כן, ייתכן שתרצה
רק כדי לחזור על זה,

1225
00:50:10,950 --> 00:50:12,699
אבל אתה גם יכול לחשוב
של הצפת מחסנית

1226
00:50:12,699 --> 00:50:15,374
כמו כמו סוג מסוים
של הצפת מאגר.

1227
00:50:15,374 --> 00:50:17,665
או שאתה רק חושב עליך
מחסנית כחיץ גדול באמת.

1228
00:50:17,665 --> 00:50:20,724
ואז כשאתה עולה על גדותיו אתה ערימה,
זה כמו סוג של הצפת מאגר.

1229
00:50:20,724 --> 00:50:23,390
אבל הצפת מחסנית היא רק
מונח מסוים משמש בעת הערימה

1230
00:50:23,390 --> 00:50:24,310
עצמו עולה על גדותיו.

1231
00:50:24,310 --> 00:50:27,500
>> חנה: ימין, כך ל
לחזור לוידאו,

1232
00:50:27,500 --> 00:50:31,756
זה שאתה יכול לחשוב על הצפת מחסנית כ
סוג מסוים של הצפת מאגר.

1233
00:50:31,756 --> 00:50:33,040
מגניב?

1234
00:50:33,040 --> 00:50:34,562
עוד שאלות לפני שאנחנו הולכים על?

1235
00:50:34,562 --> 00:50:35,380

1236
00:50:35,380 --> 00:50:35,880
מדהים.

1237
00:50:35,880 --> 00:50:37,130

1238
00:50:37,130 --> 00:50:39,727
>> אישור, מגניב, אז בואו נדבר על
כמה הודעות שגיאה נפוצות.

1239
00:50:39,727 --> 00:50:42,060
זה משהו שיש
הופיע בבחנים מרובים,

1240
00:50:42,060 --> 00:50:44,740
כך משהו ששווה
לוקח מבט שני על.

1241
00:50:44,740 --> 00:50:46,860
אני בטוח שכבר נתקלתי ב
לפחות חלק מאלה

1242
00:50:46,860 --> 00:50:48,690
כמו שאתה עושה את הבעיה שלך קובעת.

1243
00:50:48,690 --> 00:50:50,980
כדי לוודא שאתה יכול לדבר
עליהם בחידון.

1244
00:50:50,980 --> 00:50:52,990
>> אז הראשון הוא
אשמת פילוח.

1245
00:50:52,990 --> 00:50:55,250
וזה כולנו זמן
מנסה לגשת לזיכרון

1246
00:50:55,250 --> 00:50:57,130
כי לנו לא מרשימים לגישה.

1247
00:50:57,130 --> 00:51:00,280
אז אתם מוזמנים ראיתם את זה,
לדוגמא, בפריצה.

1248
00:51:00,280 --> 00:51:03,390
אם לזהות התנגשות
אחזיר null, ואז אתה

1249
00:51:03,390 --> 00:51:05,500
ניסיתי לעשות משהו
עם שהערך ריק,

1250
00:51:05,500 --> 00:51:08,147
המחשב ייתן לי
אתה אשמת פילוח.

1251
00:51:08,147 --> 00:51:10,730
אז אחת, דבר חשוב ל
לעשות כדי לנסות למנוע את זה

1252
00:51:10,730 --> 00:51:12,000
תמיד לבדוק null.

1253
00:51:12,000 --> 00:51:13,300

1254
00:51:13,300 --> 00:51:16,180
>> כמו כן, ייתכן שראה
הצהרה מפורשת של פונקציה.

1255
00:51:16,180 --> 00:51:18,370
אז זה מה שקורה
כאשר אליסון הראה לך

1256
00:51:18,370 --> 00:51:20,150
איך אנחנו עושים את אב טיפוס, נכון?

1257
00:51:20,150 --> 00:51:23,440
אז בואו נגיד שיש לנו כמה
פונקציה שאנו מגדירים.

1258
00:51:23,440 --> 00:51:24,440
נניח קובייה.

1259
00:51:24,440 --> 00:51:27,120
וזה הולך בתחתית
של הפונקציה שלנו, תחת עיקרי.

1260
00:51:27,120 --> 00:51:35,205
>> אם אנחנו שוכחים לספר לי המחשב על
קובייה, כאשר עיקרי מנסה להתקשר קובייה,

1261
00:51:35,205 --> 00:51:36,830
המחשב יהיה, כמו, אוי אלוהים שלי.

1262
00:51:36,830 --> 00:51:38,300
אין לי מושג מה זה אומר.

1263
00:51:38,300 --> 00:51:39,760
אני לא יודע מה לעשות, כאן.

1264
00:51:39,760 --> 00:51:41,594
אז אב הטיפוס אומר אל תדאגו.

1265
00:51:41,594 --> 00:51:42,510
אני הולך לספר לכם.

1266
00:51:42,510 --> 00:51:43,132
>> זה יבוא.

1267
00:51:43,132 --> 00:51:43,840
לא צועק עליי.

1268
00:51:43,840 --> 00:51:46,697
אל תיתן לי משתמע
הכרזה על הפונקציה.

1269
00:51:46,697 --> 00:51:49,280
אז אם אתה מקבל שגיאה זו, אחד
דבר שאתה הולך רוצה לעשות

1270
00:51:49,280 --> 00:51:50,821
הוא לוודא שיש לך אב הטיפוס שלך.

1271
00:51:50,821 --> 00:51:52,320

1272
00:51:52,320 --> 00:51:53,230
בסדר?

1273
00:51:53,230 --> 00:51:55,680
>> ואחרון אחרון חביב,
מזהה לא מוצהר

1274
00:51:55,680 --> 00:52:00,570
הוא למעשה כאשר אתה מנסה להשתמש ב
משתנה שלא הוכרז.

1275
00:52:00,570 --> 00:52:03,449
אז פתאום אתה מתחיל
אומר כמו n פלוס פלוס.

1276
00:52:03,449 --> 00:52:04,740
והמחשב אומר מה n?

1277
00:52:04,740 --> 00:52:06,660
אתה אף פעם לא אמר לי n היה דבר.

1278
00:52:06,660 --> 00:52:10,930
>> אז דבר אחד אתה צריך לוודא שאתה
עשיתי הוא לומר למחשב מה הוא n.

1279
00:52:10,930 --> 00:52:13,320
כך למשל, n יכול להיות מספר שלם.

1280
00:52:13,320 --> 00:52:14,999
ולאחר מכן תוכל להימנע משגיאה זו.

1281
00:52:14,999 --> 00:52:16,290
כל שאלות על שגיאות נפוצות?

1282
00:52:16,290 --> 00:52:17,260
כן?

1283
00:52:17,260 --> 00:52:19,344
>> תלמיד: למשתמע
הצהרה של פונקציה,

1284
00:52:19,344 --> 00:52:22,343
זה יכול גם להיות שאתה הושמט אחד
של הספריות שהיית אמורים

1285
00:52:22,343 --> 00:52:24,400
לכולל, ולא אב-הטיפוס?

1286
00:52:24,400 --> 00:52:26,359
>> חנה: ימין, כך
השאלה הייתה, האם הייתה יכול

1287
00:52:26,359 --> 00:52:28,650
גם מקבל את הודעת שגיאה אם
שכח לכלול ספרייה.

1288
00:52:28,650 --> 00:52:29,085
>> סטודנט: כן.

1289
00:52:29,085 --> 00:52:30,876
>> חנה: בהחלט,
כי באותו אופן

1290
00:52:30,876 --> 00:52:33,540
כי אנחנו רוצים לשים את אבות הטיפוס שלנו
לפני תפקידו העיקרי,

1291
00:52:33,540 --> 00:52:37,717
אם יש לנו ספרייה, אלה הולכים
בעצם לכלול את אבות הטיפוס,

1292
00:52:37,717 --> 00:52:39,425
כולל הגדרות
של הפונקציות.

1293
00:52:39,425 --> 00:52:40,585
שאלה גדולה.

1294
00:52:40,585 --> 00:52:43,230
>> תלמיד: לפילוח
פגם, היה שגם

1295
00:52:43,230 --> 00:52:47,350
יקרה אם, כמו, ניסיתי
לגשת למשתנה,

1296
00:52:47,350 --> 00:52:51,947
כמו, ב[ לא ברור] שונה
ממה שהוכרז ב?

1297
00:52:51,947 --> 00:52:54,030
חנה: בטח, כך גם אנחנו
תקבל שגיאה סגמנטציה

1298
00:52:54,030 --> 00:52:56,270
אם ניסינו לגשת
משתנה מחוץ לתחום?

1299
00:52:56,270 --> 00:52:57,104
היה שאלה?

1300
00:52:57,104 --> 00:52:57,645
סטודנט: כן.

1301
00:52:57,645 --> 00:52:58,430
חנה: יפה.

1302
00:52:58,430 --> 00:53:01,840
אז כנראה, אתה הולך לקבל
שגיאה מזהה מוצהרת במקום.

1303
00:53:01,840 --> 00:53:04,006
אז זה רק הולך להגיד
אני לא יודע מה זה.

1304
00:53:04,006 --> 00:53:04,920

1305
00:53:04,920 --> 00:53:05,920
מגניב, כל דבר אחר?

1306
00:53:05,920 --> 00:53:07,744

1307
00:53:07,744 --> 00:53:08,980
כן, בסדר, יפה.

1308
00:53:08,980 --> 00:53:10,330

1309
00:53:10,330 --> 00:53:12,400
>> כל righty, כך רקורסיה.

1310
00:53:12,400 --> 00:53:15,160
לכן הזכרתי כמה פעמים
שאולי אנחנו מקבלים הצפת מחסנית

1311
00:53:15,160 --> 00:53:17,919
בגלל שאנחנו קוראים
כל כך הרבה פעמים פונקציה רקורסיבית.

1312
00:53:17,919 --> 00:53:20,210
אנחנו מקבלים את כל ערימה אלה
מסגרות, בלה, בלה, בלה.

1313
00:53:20,210 --> 00:53:22,420
מה גם היא פונקציה רקורסיבית?

1314
00:53:22,420 --> 00:53:25,680
ובכן, פונקציה רקורסיבית היא
כל פונקציה שקוראת לעצמו.

1315
00:53:25,680 --> 00:53:26,820

1316
00:53:26,820 --> 00:53:30,160
>> כמה דברים שכדאי להיות מודעים כאשר אתה
מיישמים פונקציה רקורסיבית,

1317
00:53:30,160 --> 00:53:31,940
אל תשכחו לכלול מקרה בסיס.

1318
00:53:31,940 --> 00:53:34,010
מקרה בסיס הוא
נקודה שבה אנחנו בסופו.

1319
00:53:34,010 --> 00:53:38,740
כך, למשל, אם אנחנו קידוד,
, אומרים, פיבונאצ'י באופן רקורסיבי,

1320
00:53:38,740 --> 00:53:43,210
אנחנו רוצים לוודא שכאשר אנחנו מקבלים
לאו מספר פיבונאצ'י הראשון 0,

1321
00:53:43,210 --> 00:53:46,220
יש שני מספרים אלה מקרים אלה,
כי אלה אינם תלויים

1322
00:53:46,220 --> 00:53:47,700
על הדברים שבאו לפני.

1323
00:53:47,700 --> 00:53:48,990
אלה שיש להם ערכים.

1324
00:53:48,990 --> 00:53:51,270

1325
00:53:51,270 --> 00:53:55,320
>> יתרונות מסוימים לרקורסיה, שבו הוא
שאלה שראינו בחידוני העבר.

1326
00:53:55,320 --> 00:53:57,930
הם יכולים להוביל ליותר
קוד תמציתי, אלגנטי.

1327
00:53:57,930 --> 00:54:00,510
והרבה פונקציות,
הרבה אלגוריתמים שונים,

1328
00:54:00,510 --> 00:54:02,350
למעשה להשאיל את עצמם ברקורסיה.

1329
00:54:02,350 --> 00:54:05,510
ההגדרה שלהם עשויה להיות
רקורסיבית בפני עצמו.

1330
00:54:05,510 --> 00:54:06,980
אז פיבונאצ'י הוא אחד.

1331
00:54:06,980 --> 00:54:07,860
עצרת היא אחד.

1332
00:54:07,860 --> 00:54:10,480
מיון מיזוג כלומר one-- כל
דברים שאתה יכול להסתכל ב.

1333
00:54:10,480 --> 00:54:12,650

1334
00:54:12,650 --> 00:54:13,460
אישור, כל שאלות?

1335
00:54:13,460 --> 00:54:13,960
כן?

1336
00:54:13,960 --> 00:54:15,644

1337
00:54:15,644 --> 00:54:19,612
>> תלמיד: האם מקרה פינה
בדומה למקרה בסיס?

1338
00:54:19,612 --> 00:54:22,590
או הוא כי עבור חלק אחר
סוג של [לא ברור]?

1339
00:54:22,590 --> 00:54:25,170
>> חנה: בטח, כל כך
מקרה פינה הוא any-- כך

1340
00:54:25,170 --> 00:54:27,580
הוא מקרה פינה זהה למקרה בסיס?

1341
00:54:27,580 --> 00:54:32,825
מקרה פינה הוא כל דבר ש
קוד עשוי להתנהג באופן קצת שונה.

1342
00:54:32,825 --> 00:54:34,450

1343
00:54:34,450 --> 00:54:38,610
מקרה בסיס קשור סוג של, ב
שהם כמו מקרים מסוימים

1344
00:54:38,610 --> 00:54:40,240
כי אתה רוצה להסתכל.

1345
00:54:40,240 --> 00:54:43,240
אבל הרעיון של מקרה בסיס הוא ש
אתה רוצה פונקציה רקורסיבית שלך

1346
00:54:43,240 --> 00:54:44,870
להפסיק בשלב מסוים.

1347
00:54:44,870 --> 00:54:46,490
זה לא יכול להמשיך לקרוא את עצמו לנצח.

1348
00:54:46,490 --> 00:54:47,781
זה צריך להפסיק בשלב מסוים.

1349
00:54:47,781 --> 00:54:49,340

1350
00:54:49,340 --> 00:54:53,460
>> ROB: כן, לעתים קרובות, במקרי הבסיס שלך
יכול להיות דוגמאות של בסיסי פינה.

1351
00:54:53,460 --> 00:54:55,876
>> חנה: ימין, מגניב, משהו?

1352
00:54:55,876 --> 00:54:58,732
>> תלמיד: האם אתה יכול להסביר
מבסס קצת יותר?

1353
00:54:58,732 --> 00:55:01,600
אני לא ממש הבין
מקרי בסיס [לא ברור].

1354
00:55:01,600 --> 00:55:02,676
>> חנה: במקרי בסיס?

1355
00:55:02,676 --> 00:55:03,140
>> תלמיד: מקרי בסיס, כן.

1356
00:55:03,140 --> 00:55:03,770
>> חנה: אה, כן, בטוח.

1357
00:55:03,770 --> 00:55:04,270
בואו נראה.

1358
00:55:04,270 --> 00:55:05,480
האם יש לנו גיר לכאן?

1359
00:55:05,480 --> 00:55:06,690

1360
00:55:06,690 --> 00:55:07,320
כן, אנחנו עושים.

1361
00:55:07,320 --> 00:55:09,530
אוקיי, אז באמת במהירות, אני יהיה
אנסה לכתוב גדול מספיק

1362
00:55:09,530 --> 00:55:11,320
כך שאתה יכול לראות על המסך.

1363
00:55:11,320 --> 00:55:13,490
בואו נדבר על, באמת
במהירות, פיבונאצ'י.

1364
00:55:13,490 --> 00:55:15,550
אז אני אתן לך את רצף פיבונאצ'י.

1365
00:55:15,550 --> 00:55:17,090
אתה יכול להסתכל למעלה ההגדרה.

1366
00:55:17,090 --> 00:55:26,050
>> בעיקרו של דבר, כל מספר ברצף
הוא הסכום של שני המספרים הקודמים.

1367
00:55:26,050 --> 00:55:29,720
אוקיי, אז הדרך שאני
רק תיארתי פיבונאצ'י,

1368
00:55:29,720 --> 00:55:31,530
היה אפשר לשמוע את רקורסיה, נכון?

1369
00:55:31,530 --> 00:55:35,280
כשאמרתי כל מספר הוא
סכום של שני המספרים הקודמים,

1370
00:55:35,280 --> 00:55:36,420
נוכל לומר על אישור.

1371
00:55:36,420 --> 00:55:38,570
ובכן, פיבונאצ'י המי יודע כמה
number-- אז בואו

1372
00:55:38,570 --> 00:55:42,260
אומר שיש לנו בפונקציה זו
נקרא לבלף fib-- של n

1373
00:55:42,260 --> 00:55:48,260
הולך להיות שווה ללבלף
של n מינוס 1 plus-- מצטער,

1374
00:55:48,260 --> 00:55:51,240
אנחנו נעבור לשורה הבאה
על לבלף here-- של n מינוס 2.

1375
00:55:51,240 --> 00:55:52,790

1376
00:55:52,790 --> 00:55:56,790
>> אוקיי, אז זה עובד נהדר אם אתה
מסתכל על, למשל, אפס, אחד,

1377
00:55:56,790 --> 00:55:59,410
שתיים, שלוש, ארבעה,
מספר פיבונאצ'י החמישי,

1378
00:55:59,410 --> 00:56:03,561
שבו אתה יכול להגיד ש
5 הוא שווים ל 2 ועוד 3.

1379
00:56:03,561 --> 00:56:05,060
אבל מה אם אתה בהתחלה?

1380
00:56:05,060 --> 00:56:07,184
מה אם אתה רק פוגע
שני ערכים הראשונים אלה?

1381
00:56:07,184 --> 00:56:08,470

1382
00:56:08,470 --> 00:56:11,330
>> כדי לקבל 1 זה, אתה לא יכול
אומר להוסיף את שני הקודמים,

1383
00:56:11,330 --> 00:56:13,930
כי אפס כי and-- אני לא יודע.

1384
00:56:13,930 --> 00:56:15,390
אז בשלב מסוים, אנחנו צריכים להפסיק.

1385
00:56:15,390 --> 00:56:21,250
בשלב מסוים, אנחנו צריכים לומר כי אלה
שני יש לי ההגדרות שלהם פשוט.

1386
00:56:21,250 --> 00:56:23,890
מספר 0 פיבונאצ'י הוא 0.

1387
00:56:23,890 --> 00:56:26,115
ומספר פיבונאצ'י הראשון הוא 1.

1388
00:56:26,115 --> 00:56:34,120
>> אז ככה אני יכול קוד זה, אני
הייתי אומר שאם n הוא פחות משני,

1389
00:56:34,120 --> 00:56:35,130
אז פשוט לחזור n.

1390
00:56:35,130 --> 00:56:36,494
וזה יהיה מקרה הבסיס שלי.

1391
00:56:36,494 --> 00:56:38,660
ככה אני יודע להפסיק
עם פונקציה רקורסיבית.

1392
00:56:38,660 --> 00:56:40,640

1393
00:56:40,640 --> 00:56:41,410
האם זה ברור?

1394
00:56:41,410 --> 00:56:41,940
מדהים.

1395
00:56:41,940 --> 00:56:43,260
כל דבר ברקורסיה אחר?

1396
00:56:43,260 --> 00:56:44,890

1397
00:56:44,890 --> 00:56:45,930
יפה.

1398
00:56:45,930 --> 00:56:48,750
>> בואו מהר לדבר על
חיפוש ופעמים סוג לרוץ.

1399
00:56:48,750 --> 00:56:52,660
ואז אני אתן כמה דיווין
זמן לדבר על קידוד דוגמאות.

1400
00:56:52,660 --> 00:56:56,490
אז הנה החיפוש העיקרי ו
מיני שאתם צריכים לדעת על.

1401
00:56:56,490 --> 00:56:59,500
Guarantee-- אני לא יכול להבטיח,
בגלל שלא ראיתי quiz--

1402
00:56:59,500 --> 00:57:01,940
אבל זה עולה חידון
לאחר החידון התפטר לאחר.

1403
00:57:01,940 --> 00:57:04,050
אז בהחלט להשתמש תרשים זה.

1404
00:57:04,050 --> 00:57:05,682
כמו, לקחת תרשים זה.

1405
00:57:05,682 --> 00:57:06,890
שים את זה על-גבי הגיליון לרמות שלך.

1406
00:57:06,890 --> 00:57:07,931
אתה תהיה אדם מאושר.

1407
00:57:07,931 --> 00:57:09,010

1408
00:57:09,010 --> 00:57:12,590
>> זה אומר לנו לרוץ פעמים בכל
אלגוריתמים מיון וחיפוש.

1409
00:57:12,590 --> 00:57:14,020

1410
00:57:14,020 --> 00:57:18,850
אז חיפוש ליניארי, אתה יכול לראות ריצה
זמן, ואותו דבר עם חיפוש בינארי.

1411
00:57:18,850 --> 00:57:21,490
ללכת על מה שאלגוריתמים אלה
לעשות, את הרעיון הכללי.

1412
00:57:21,490 --> 00:57:24,220
תראה כמה פסאודו קוד,
אם לא קוד עצמו.

1413
00:57:24,220 --> 00:57:25,610

1414
00:57:25,610 --> 00:57:30,380
>> אתה תראה שיש לו מיון הבועות עליון
כרוך במקרה הגרוע ביותר של n בריבוע.

1415
00:57:30,380 --> 00:57:31,490

1416
00:57:31,490 --> 00:57:34,680
אז אם המערך שלנו היה לגמרי
לאחור לפני שאנחנו רוצים למיין את זה,

1417
00:57:34,680 --> 00:57:37,090
הייתי אומר שזה
עומד לנקוט צעדי n בריבוע.

1418
00:57:37,090 --> 00:57:38,160

1419
00:57:38,160 --> 00:57:41,730
אבל במקרה הטוב ביותר, ולכן
גבול תחתון למקרה הטוב ביותר

1420
00:57:41,730 --> 00:57:44,300
הולך להיות אם זה
כבר מסודרים בצורה מושלמת.

1421
00:57:44,300 --> 00:57:46,671
ואז כל מה שאנחנו צריכים לעשות הוא
לבדוק שזה מסודרים.

1422
00:57:46,671 --> 00:57:47,921
האם יש שאלה כאן?

1423
00:57:47,921 --> 00:57:49,805
>> תלמיד: מתי
אתה רוצה להשתמש בסוג?

1424
00:57:49,805 --> 00:57:50,747
הסוג.

1425
00:57:50,747 --> 00:57:52,160
אני פשוט סקרן.

1426
00:57:52,160 --> 00:57:53,510
>> חנה: כאשר היית
רוצה להשתמש במיון בחירה?

1427
00:57:53,510 --> 00:57:54,010
זה אחד?

1428
00:57:54,010 --> 00:57:55,705
אחד זה n בריבוע בשני המקרים?

1429
00:57:55,705 --> 00:57:56,860
>> תלמיד: [לא ברור].

1430
00:57:56,860 --> 00:57:58,151
>> חנה: אז זה שונה מאוד.

1431
00:57:58,151 --> 00:58:00,760
אם יש לך ספציפי
דרישות עבור התכנית שלך,

1432
00:58:00,760 --> 00:58:04,887
כמו דברים כמו אם רק אמר
ליישם sorry-- search--

1433
00:58:04,887 --> 00:58:06,720
ליישם סוג, שתצליח
כנראה רוצה ללכת

1434
00:58:06,720 --> 00:58:09,950
לאחד מאלה ש
יש מקרה הטוב ביותר של n,

1435
00:58:09,950 --> 00:58:12,410
או גבול תחתון במקרה הטוב של n.

1436
00:58:12,410 --> 00:58:14,790
אבל ייתכן שהיו
דברים מסוימים כמו, למשל,

1437
00:58:14,790 --> 00:58:16,767
חילופים באמת
יקר מסיבה כלשהי.

1438
00:58:16,767 --> 00:58:18,850
אז היית רוצה לעשות
מיון בועות, כי אתה

1439
00:58:18,850 --> 00:58:20,641
צריך לעשות כל כך הרבה
חילופים, דברים כאלה.

1440
00:58:20,641 --> 00:58:21,710

1441
00:58:21,710 --> 00:58:23,098
כל כן other--?

1442
00:58:23,098 --> 00:58:25,488
>> תלמיד: האם זה יהיה [לא ברור]
לומר ש[ לא ברור]?

1443
00:58:25,488 --> 00:58:30,077

1444
00:58:30,077 --> 00:58:31,910
חנה: זה דבר אחד
שאגיד לך

1445
00:58:31,910 --> 00:58:33,670
אם אתה מסתכל על היישום.

1446
00:58:33,670 --> 00:58:35,850
הדרך אני למעשה
לחשוב למה זה n

1447
00:58:35,850 --> 00:58:40,840
בריבוע הוא שאנחנו צריכים לרוץ
באמצעות המערך של n האורך שלנו,

1448
00:58:40,840 --> 00:58:42,765
בכל פעם שעושה ברוב, n חילופים.

1449
00:58:42,765 --> 00:58:43,980

1450
00:58:43,980 --> 00:58:46,220
ואנחנו צריכים לעשות את תהליך n פעמים זה.

1451
00:58:46,220 --> 00:58:51,130
>> לכן, כאשר יש לך לעשות ברוב, n
עסקות החלף ועבור n עובר המערך,

1452
00:58:51,130 --> 00:58:52,380
יש הולך להיות בריבוע n.

1453
00:58:52,380 --> 00:58:55,480
אבל כן, זו תתגלה
דרך כפול הזה ללולאה,

1454
00:58:55,480 --> 00:58:59,428
כמו השאלה או asked--
מקונן על לולאה, אני צריך לומר.

1455
00:58:59,428 --> 00:59:00,890
בסדר?

1456
00:59:00,890 --> 00:59:03,375
>> ולאחר מכן למזג סוג, ש
הוא מהסוג שהמהיר ביותר כיום,

1457
00:59:03,375 --> 00:59:07,560
או שאנחנו כבר כיסינו בCS50,
יודע שהאלגוריתם העיקרי הוא

1458
00:59:07,560 --> 00:59:10,150
הרעיון הזה של פריצה ל
חתיכות מיון ולאחר מכן

1459
00:59:10,150 --> 00:59:11,980
מיזוג יחד פיסות מסודרים אלה.

1460
00:59:11,980 --> 00:59:14,170
ויקבל אותנו להיכנס n להתחבר n.

1461
00:59:14,170 --> 00:59:17,110
כל שאלות על חיפושים ו
מיני לפני שאני עובר על זה?

1462
00:59:17,110 --> 00:59:19,840

1463
00:59:19,840 --> 00:59:21,040
בואו נראה.

1464
00:59:21,040 --> 00:59:21,800
>> אה, רשימות מקושרות.

1465
00:59:21,800 --> 00:59:23,210
מצטער, יש לי נושא אחד יותר.

1466
00:59:23,210 --> 00:59:25,000
אישור, מדהים, רשימות מקושרות.

1467
00:59:25,000 --> 00:59:27,900
בעיה עם המערכים,
יש להם גודל קבוע.

1468
00:59:27,900 --> 00:59:30,634
אז אם אתה לא יודע עד כמה גדול
הקלט שלך הולך להיות,

1469
00:59:30,634 --> 00:59:32,050
אתה לא רוצה ליצור מערך.

1470
00:59:32,050 --> 00:59:34,080
כי אם אנו יוצרים
מערך שהוא קטן מדי,

1471
00:59:34,080 --> 00:59:35,930
אנו עלולים להיתקל בגלישת מאגר.

1472
00:59:35,930 --> 00:59:38,890
>> אז במקום, אנחנו יכולים לעשות משהו
עם רשימות מקושרות, ש

1473
00:59:38,890 --> 00:59:44,280
מאפשר לנו יש באופן דינמי
מבנה נתונים בגודל

1474
00:59:44,280 --> 00:59:48,970
שיאפשר לנו לאחסן
סכום גמיש יותר של נתונים.

1475
00:59:48,970 --> 00:59:54,030
אז בתוך כל צומת בנו
מקושר רשימה, יש לנו שתי חתיכות.

1476
00:59:54,030 --> 00:59:56,820
יש לנו את הערך האמיתי שהוא מאחסן.

1477
00:59:56,820 --> 00:59:59,530
אז זה בדיוק הדבר שהיית
רואה במערך, לדוגמא.

1478
00:59:59,530 --> 01:00:04,600
ואז אנחנו גם לעקוב אחר
מצביע לדבר הבא בזיכרון.

1479
01:00:04,600 --> 01:00:06,430
>> בניגוד למערכים, ש
אנחנו יודעים את כל הולכים

1480
01:00:06,430 --> 01:00:10,890
לbe-- אלמנטים במערך כל אחד
ברציפות בmemory-- קשורה

1481
01:00:10,890 --> 01:00:13,300
רשימות יכולות להיות בכל מקום בזיכרון.

1482
01:00:13,300 --> 01:00:14,590
הם מקומות שרירותיים.

1483
01:00:14,590 --> 01:00:16,410
אז אם היינו
ללכת דווקא מוצא אותם, אנחנו

1484
01:00:16,410 --> 01:00:19,770
צריך לעקוב אחר
הדבר הבא ברשימה שלנו.

1485
01:00:19,770 --> 01:00:22,840
>> ואז כדי לדעת
שם רשימה שבכללותו היא,

1486
01:00:22,840 --> 01:00:26,276
כל מה שאנחנו צריכים לעקוב אחר הוא
האלמנט הראשון ברשימה המקושרת שלנו.

1487
01:00:26,276 --> 01:00:27,900
וכי יהיה לאפשר לנו ללכת עד הסוף.

1488
01:00:27,900 --> 01:00:31,020

1489
01:00:31,020 --> 01:00:33,070
>> אז ככה אתה יכול להגדיר מצב.

1490
01:00:33,070 --> 01:00:36,160
זוהי הזדמנות נהדרת
לנצל structs.

1491
01:00:36,160 --> 01:00:39,660
כי יש לך את הרעיון הזה, גם,
לצומת נתון, יש לי שתי חתיכות.

1492
01:00:39,660 --> 01:00:41,770
יש לי את הערך האמיתי עצמו.

1493
01:00:41,770 --> 01:00:45,610
ואז יש לי מצביע ל
האלמנט הבא ברשימה המקושרת.

1494
01:00:45,610 --> 01:00:49,150
אז אתה רואה, יש לנו n שלם,
שהוא הולך להיות הערך הממשי,

1495
01:00:49,150 --> 01:00:53,150
ולאחר מכן מצביע ל
צומת, בשם הבא.

1496
01:00:53,150 --> 01:00:56,431
אז זה הולך להיות הבא
אלמנט ברשימה המקושרת שלנו.

1497
01:00:56,431 --> 01:00:56,972
סטודנט: כן?

1498
01:00:56,972 --> 01:01:01,920
האם יש לך כדי לציין ש
הכוכב הוא כמו struct?

1499
01:01:01,920 --> 01:01:05,620
>> חנה: כן, כך זה מאז
כמעט כמו סוג של,

1500
01:01:05,620 --> 01:01:07,980
זה נראה כמו רקורסיבית
הגדרה בנו ש

1501
01:01:07,980 --> 01:01:12,080
צריך לדעת מה היא צומת
בתוך למציאת צומת.

1502
01:01:12,080 --> 01:01:14,450
מאז שהיא עושה לא ממש
יודע מה צומת היא לגמרי

1503
01:01:14,450 --> 01:01:17,283
עד שנגיע לסוף זה--
ואחרי זה אנחנו יכולים רק לקרוא לזה

1504
01:01:17,283 --> 01:01:21,935
node-- בתוך הגדרה זו,
אנחנו צריכים לקרוא לזה צומת struct.

1505
01:01:21,935 --> 01:01:22,560
שאלה גדולה.

1506
01:01:22,560 --> 01:01:23,580

1507
01:01:23,580 --> 01:01:25,214
כל דבר אחר?

1508
01:01:25,214 --> 01:01:26,198
כן?

1509
01:01:26,198 --> 01:01:29,150
>> תלמיד: למה אנחנו
יש לי לומר צומת פעמיים?

1510
01:01:29,150 --> 01:01:33,578
משום שכאשר היינו ב[ לא ברור]
אנחנו פשוט צריכים לעשות את זה בנקודה-פסיק,

1511
01:01:33,578 --> 01:01:37,352
אבל עכשיו אנחנו צריכים למצוא ש
צומת struct? [לא ברור].

1512
01:01:37,352 --> 01:01:39,060
חנה: אז אני מאמין
בדוגמא האחרונה,

1513
01:01:39,060 --> 01:01:42,110
אנחנו פשוט יצירת בכל עת ש
רציתי להשתמש בתלמיד לאחר ש,

1514
01:01:42,110 --> 01:01:46,430
הייתי צריך להשתמש struct node--
אני sorry-- תלמיד struct.

1515
01:01:46,430 --> 01:01:51,575
זה אפשר לנו, לאחר מעשה, רק
צומת שימוש להוסיף סוג חדש, בעצם.

1516
01:01:51,575 --> 01:01:53,324

1517
01:01:53,324 --> 01:01:53,990
כי תחושה? איפור

1518
01:01:53,990 --> 01:01:54,984

1519
01:01:54,984 --> 01:01:57,150
אז היינו צריך לחזור ו
מסתכל על הקוד לפני.

1520
01:01:57,150 --> 01:01:59,025
אבל אני מניח ש
לא השתמש בtypedef.

1521
01:01:59,025 --> 01:02:02,050
ושאלנו את השאלה,
למה אנחנו צריכים להשתמש typedef?

1522
01:02:02,050 --> 01:02:05,540
Typedef מאפשר לנו להימנע מ
המילה struct בתחילת.

1523
01:02:05,540 --> 01:02:06,221
כן?

1524
01:02:06,221 --> 01:02:08,095
תלמיד: איזה סוג של
תתחלנה שאלות

1525
01:02:08,095 --> 01:02:10,400
במונחים במונחים של
צמתים ורשימות מקושרות?

1526
01:02:10,400 --> 01:02:15,110
>> חנה: אז דבר אחד שאנחנו יכולים לומר כמה
ייתכן שתחפש את דרך רשימה מקושרת?

1527
01:02:15,110 --> 01:02:16,930
אישור, כי זה
קצת יותר מסובך

1528
01:02:16,930 --> 01:02:18,520
מאשר אם אנחנו מחפשים
באמצעות מערך.

1529
01:02:18,520 --> 01:02:21,472
אנחנו רק יכולים להסתכל באלמנט אפס,
אלמנט אחד, אלמנט שני, בלה, בלה,

1530
01:02:21,472 --> 01:02:21,972
בלה.

1531
01:02:21,972 --> 01:02:22,629

1532
01:02:22,629 --> 01:02:24,420
אם ברצוננו לחפש
באמצעות רשימה מקושרת,

1533
01:02:24,420 --> 01:02:27,229
היינו באמת צריך לעקוב
המבוך הקטן הזה של מצביעים.

1534
01:02:27,229 --> 01:02:29,270
אז בואו באמת ללכת
באמצעות זה ממש מהר.

1535
01:02:29,270 --> 01:02:30,460

1536
01:02:30,460 --> 01:02:32,860
מה אנחנו יכולים לעשות ב
להזמין to-- נניח ש

1537
01:02:32,860 --> 01:02:35,430
רוצה רק כדי לבצע איטרציות ב
הרשימה המקושרת לחלוטין שלנו.

1538
01:02:35,430 --> 01:02:37,450
היינו מתחיל בראש.

1539
01:02:37,450 --> 01:02:39,890
ולאחר מכן על מנת
לעבור לפריט הבא,

1540
01:02:39,890 --> 01:02:43,680
במקום רק להגדיל כל על ידי אחד
כמו שאולי בעובר מערך,

1541
01:02:43,680 --> 01:02:45,720
אנחנו באמת הולכים ל
בצע את המצביע הבא,

1542
01:02:45,720 --> 01:02:48,360
כדי שנוכל למצוא בי ב
זיכרון האלמנט הבא הוא.

1543
01:02:48,360 --> 01:02:49,357

1544
01:02:49,357 --> 01:02:51,690
אז אני יודע שזה לא מספיק ל
לקחת את כל זה ברגע זה ממש,

1545
01:02:51,690 --> 01:02:52,650
אבל יהיה לך את השקפים האלה.

1546
01:02:52,650 --> 01:02:54,730
אז אתה יכול לעבור
זה קצת יותר לאט.

1547
01:02:54,730 --> 01:02:56,890
אבל בעצם, מה שאנחנו רוצים
לעשות הוא לעקוב מצביעים אלה

1548
01:02:56,890 --> 01:02:58,550
דרך השלמות של הרשימה המקושרת.

1549
01:02:58,550 --> 01:03:00,258
אז זו שאלה
ייתכן שתתבקש.

1550
01:03:00,258 --> 01:03:01,920

1551
01:03:01,920 --> 01:03:03,980
>> משהו להבחין ב
הכנסה, נניח

1552
01:03:03,980 --> 01:03:07,925
אנחנו רוצים לשים אלמנט חדש
בחלק הקדמי של הרשימה המקושרת שלנו.

1553
01:03:07,925 --> 01:03:10,800
אנחנו צריכים להיות זהירים מאוד
על הסדר שבו אנו

1554
01:03:10,800 --> 01:03:12,760
מחדש את המצביעים.

1555
01:03:12,760 --> 01:03:15,230
כי בואו נגיד שאני רק אמרתי על אישור.

1556
01:03:15,230 --> 01:03:18,930
להפוך את הצבע ועד ראש האלמנט חדש זה.

1557
01:03:18,930 --> 01:03:23,550
פשוט לעשות את זה מצביע על 1 ואז, יש לנו
בעצם איבד את שאר הרשימה שלנו,

1558
01:03:23,550 --> 01:03:25,860
כי אני לא זוכר 2 שבו חיי.

1559
01:03:25,860 --> 01:03:27,730
>> אז אנחנו צריכים לעשות ב
סדר מאוד ספציפי.

1560
01:03:27,730 --> 01:03:31,500
ראשית, אנחנו עושים חדשים
נקודת אלמנט לראש.

1561
01:03:31,500 --> 01:03:33,970
ואז להפוך את הראש
להצביע על הגורם החדש.

1562
01:03:33,970 --> 01:03:38,455
אז בואו נראה מה שנראה כמו
עם arrows-- סתם ככה.

1563
01:03:38,455 --> 01:03:42,080
אז יש לך ראשון החדש
נקודת אלמנט לראש הישן.

1564
01:03:42,080 --> 01:03:45,990
ועכשיו, יש לנו את הראש
מצביע על האלמנט הראשון החדש.

1565
01:03:45,990 --> 01:03:47,187
שאלות עם זה?

1566
01:03:47,187 --> 01:03:49,870

1567
01:03:49,870 --> 01:03:54,350
>> אישור הנה כמה קוד שוב, משהו
להסתכל על קצת מאוחר יותר.

1568
01:03:54,350 --> 01:03:58,630
ועכשיו אני אהפוך אותו לדווין
לGDB וקצת תרגול

1569
01:03:58,630 --> 01:03:59,480
קידוד על נייר.

1570
01:03:59,480 --> 01:04:00,597

1571
01:04:00,597 --> 01:04:01,096
יפה.

1572
01:04:01,096 --> 01:04:01,810
>> ROB: ורוב.

1573
01:04:01,810 --> 01:04:02,360
>> חנה: אה, דווין ורוב.

1574
01:04:02,360 --> 01:04:03,055
אני מצטער.

1575
01:04:03,055 --> 01:04:03,596
>> תלמיד: וו!

1576
01:04:03,596 --> 01:04:08,140

1577
01:04:08,140 --> 01:04:09,110
>> ROB: תודה.

1578
01:04:09,110 --> 01:04:11,209
>> דווין: אתה רוצה לומר
הכל ממש מהר?

1579
01:04:11,209 --> 01:04:11,875
ROB: כן, כן.

1580
01:04:11,875 --> 01:04:12,845
דווין: ברגע שאני מעלה.

1581
01:04:12,845 --> 01:04:16,240

1582
01:04:16,240 --> 01:04:19,520
אישור, ואילו רוב מעמיד
מיקרופון ב, אז מה GDB?

1583
01:04:19,520 --> 01:04:23,945
כולם צריך לראות את GDB ב
כיתה וגם בשעתי עבודה.

1584
01:04:23,945 --> 01:04:25,070
ואתה צריך להיות שימוש בו.

1585
01:04:25,070 --> 01:04:25,750
אז מה הוא GDB?

1586
01:04:25,750 --> 01:04:28,030

1587
01:04:28,030 --> 01:04:28,850
אף אחד?

1588
01:04:28,850 --> 01:04:29,540
>> תלמיד: זה הבאגים.

1589
01:04:29,540 --> 01:04:30,250
>> דווין: זה הבאגים.

1590
01:04:30,250 --> 01:04:31,624
ומה זה מאפשר לך לעשות?

1591
01:04:31,624 --> 01:04:33,064
כמו, למה אנחנו אוהבים GDB?

1592
01:04:33,064 --> 01:04:34,480
תלמיד: כדי להאט את התכנית.

1593
01:04:34,480 --> 01:04:36,740
דווין: ימין, כך שאתה יכול ללכת
דרכו אוהב קצב אנושי.

1594
01:04:36,740 --> 01:04:38,490
ואז מה הם כמה
פקודות שאתה יכול לעשות?

1595
01:04:38,490 --> 01:04:40,407
ובכן, הפסקה היא כנראה
הפקודה. האהובה עליך

1596
01:04:40,407 --> 01:04:43,240
מכיוון שזה מאפשר לך לשבור את
תכנית ולמעשה לעבור את זה

1597
01:04:43,240 --> 01:04:44,280
שורה אחרת שורה.

1598
01:04:44,280 --> 01:04:46,500
>> הפעלה מאפשרת לך להפעיל אותו.

1599
01:04:46,500 --> 01:04:48,210
בשלב הבא, כמו לפסוע דרך.

1600
01:04:48,210 --> 01:04:49,820
מה בין הבא וצעד?

1601
01:04:49,820 --> 01:04:52,190

1602
01:04:52,190 --> 01:04:53,190
חכה, אומר זאת בקול.

1603
01:04:53,190 --> 01:04:54,060
זה היה נכון.

1604
01:04:54,060 --> 01:04:55,280
>> תלמיד: [לא ברור].

1605
01:04:55,280 --> 01:04:56,190
>> דווין: כן, מדהים.

1606
01:04:56,190 --> 01:04:59,210
אז כמו, הצעד הבא, ואם you're--
נניח שיש לך פונקציה שאתה

1607
01:04:59,210 --> 01:04:59,950
להגדיר.

1608
01:04:59,950 --> 01:05:03,350
נניח שחלקם בפונקציה העיקרית שלך,
ואתה רק פוגע הבא, הבא,

1609
01:05:03,350 --> 01:05:03,850
הבא.

1610
01:05:03,850 --> 01:05:05,910
אתה באמת הולך
תפעיל פונקציה ש,

1611
01:05:05,910 --> 01:05:07,285
אבל אתה הולך לקפוץ על זה.

1612
01:05:07,285 --> 01:05:09,711
אם אתה מכה את הצעד, או
של או מה, אתה

1613
01:05:09,711 --> 01:05:11,460
הולך לקפוץ למעשה
לפונקציה ש,

1614
01:05:11,460 --> 01:05:14,110
ואז אתה יכול להכות הבא
כדי לראות את השיחות השונות

1615
01:05:14,110 --> 01:05:16,170
בתוך פונקציה מסוימת.

1616
01:05:16,170 --> 01:05:16,670
כן?

1617
01:05:16,670 --> 01:05:18,670
>> תלמיד: האם יש דרך
לקפוץ, כמו, לסגת?

1618
01:05:18,670 --> 01:05:20,750
דווין: סיום, כן,
לסיים עם לקפוץ לך.

1619
01:05:20,750 --> 01:05:22,570
כך שזה הולך לסיים ש
פונקציה, ואז אתה

1620
01:05:22,570 --> 01:05:24,153
הולך להיות שוב בעיקרי, לדוגמא.

1621
01:05:24,153 --> 01:05:25,250

1622
01:05:25,250 --> 01:05:27,370
הדפסה תהיה להדפיס את זה פעם אחת.

1623
01:05:27,370 --> 01:05:29,381
משהו שאני תמיד משתמש בה הוא תצוגה.

1624
01:05:29,381 --> 01:05:31,880
תצוגה להדפיס אותו
בכל השלמות כל הזמן

1625
01:05:31,880 --> 01:05:32,470
התכנית שלך.

1626
01:05:32,470 --> 01:05:33,810
>> לדוגמא, אם אתה
ללולאה, ואתה

1627
01:05:33,810 --> 01:05:37,018
רוצה לראות איך משהו משתנה,
ואתה לא רוצה, כמו, כל הזמן

1628
01:05:37,018 --> 01:05:38,940
לעשות כמו הדפסה,
הדפסה, הדפסה, תצוגה

1629
01:05:38,940 --> 01:05:43,230
יציג משתנה ש
ברציפות, בכל פעם שאתה מכה הבא.

1630
01:05:43,230 --> 01:05:44,310
ולהמשיך.

1631
01:05:44,310 --> 01:05:45,905
אז GBD, זה GDB.

1632
01:05:45,905 --> 01:05:47,160

1633
01:05:47,160 --> 01:05:49,180
>> תלמיד: מה אחד
שם [לא ברור] לך?

1634
01:05:49,180 --> 01:05:50,150

1635
01:05:50,150 --> 01:05:50,900
דווין: מה זה?

1636
01:05:50,900 --> 01:05:52,310

1637
01:05:52,310 --> 01:05:54,390
>> תלמיד: מה the--
המשתנים המקומיים.

1638
01:05:54,390 --> 01:05:55,364

1639
01:05:55,364 --> 01:05:57,780
רוב: יש משהו בעצם
כמו המקומיים או משהו.

1640
01:05:57,780 --> 01:05:58,140
אני can't--

1641
01:05:58,140 --> 01:05:59,930
>> דווין: זה יכול להיות
משהו כזה, כן.

1642
01:05:59,930 --> 01:06:00,830
>> חנה: בהמקומיים?

1643
01:06:00,830 --> 01:06:01,510
>> דווין: זהו זה.

1644
01:06:01,510 --> 01:06:02,134
זה אחד.

1645
01:06:02,134 --> 01:06:03,040
ROB: יפה.

1646
01:06:03,040 --> 01:06:04,030
>> דווין: כן.

1647
01:06:04,030 --> 01:06:06,010
>> תלמיד: מה להמשיך לעשות?

1648
01:06:06,010 --> 01:06:08,010
>> דווין: זה continues-- כך שזה רק
הולך להמשיך את התוכניות שלך.

1649
01:06:08,010 --> 01:06:09,843
אז אם אתה לשבור ולהכות
תמשיך, זה הולך

1650
01:06:09,843 --> 01:06:13,119
רק להפעיל את התכנית כי עד
הוא פוגע שהפסקה שוב.

1651
01:06:13,119 --> 01:06:14,910
כך למשל, אם אתה
פרץ בפונקציה,

1652
01:06:14,910 --> 01:06:16,720
ואתה הולך לעשות כמו ל
לולאה או משהו כזה,

1653
01:06:16,720 --> 01:06:19,869
ואתה מכה תמשיך, זה הולך
להמשיך ולחזור לזה הפסקה.

1654
01:06:19,869 --> 01:06:22,660
או שאין הפסקה, זה הולך
להמשיך ולסיים את התכנית.

1655
01:06:22,660 --> 01:06:25,000
>> רוב: אז בדיוק כמו תחנות המנוהלות
בנקודת העצירה הראשונה

1656
01:06:25,000 --> 01:06:27,010
אתה מכה, אם לאחר מכן
פגעת להמשיך, זה יהיה לשמור

1657
01:06:27,010 --> 01:06:28,070
הולך עד שזה נקודת העצירה הבאה.

1658
01:06:28,070 --> 01:06:30,111
ולאחר מכן להמשיך ילך
לנקודת העצירה הבאה.

1659
01:06:30,111 --> 01:06:31,264

1660
01:06:31,264 --> 01:06:32,680
דווין: כל שאלות אחרות על GDB?

1661
01:06:32,680 --> 01:06:33,577

1662
01:06:33,577 --> 01:06:35,410
אז אני חושב בעבר,
אנחנו כבר שאלנו אותך מה

1663
01:06:35,410 --> 01:06:37,690
GDB הוא ולתת
דוגמא של כמה דברים שאתה

1664
01:06:37,690 --> 01:06:40,770
יכול לעשות עם GDB, כך
פשוט אמיתי, אבל כן.

1665
01:06:40,770 --> 01:06:42,280
הנה לך.

1666
01:06:42,280 --> 01:06:43,250
וצומת?

1667
01:06:43,250 --> 01:06:49,571
>> ROB: כן, כך שכיוון זה היה?

1668
01:06:49,571 --> 01:06:50,851

1669
01:06:50,851 --> 01:06:51,726
תלמיד: זה היה זה.

1670
01:06:51,726 --> 01:06:52,160
דווין: המתן.

1671
01:06:52,160 --> 01:06:52,270
ROB: הבחור הזה?

1672
01:06:52,270 --> 01:06:52,936
דווין: אחד ש.

1673
01:06:52,936 --> 01:06:54,660
ROB: הבחור הזה, אה, אני לא מבין.

1674
01:06:54,660 --> 01:06:56,940
אז לא היינו ברורים
על מה the-- אני לא

1675
01:06:56,940 --> 01:06:58,680
יודע מי זה was-- אבל השאלה.

1676
01:06:58,680 --> 01:07:01,180
אנחנו לא יודעים בדיוק מה אתה
שואלים אותו על זה, כל כך פשוט

1677
01:07:01,180 --> 01:07:04,800
להבהיר משהו.

1678
01:07:04,800 --> 01:07:07,750
אז קודם כל, כמו שאמרתי קודם,
typedef אתה תמיד משתמש רק

1679
01:07:07,750 --> 01:07:09,305
ליצור כינוי לסוג.

1680
01:07:09,305 --> 01:07:13,420
אז כאן, הכינוי שאנחנו
יצירה היא לצומת struct מסוג זה.

1681
01:07:13,420 --> 01:07:18,070
>> התעלמות צומת אז קודם כל, זה ב
typedef, כך זה struct צומת מתולתל

1682
01:07:18,070 --> 01:07:21,060
לייצב עד מתולתל הבא
סד הוא סוג צומת struct.

1683
01:07:21,060 --> 01:07:23,470
ואנחנו צריכים צומת ש
שם למעלה, כי אנחנו

1684
01:07:23,470 --> 01:07:25,190
צריך להפנות צומת כאן.

1685
01:07:25,190 --> 01:07:29,380
אז עם סוג זה של struct רקורסיבית,
אתה צריך לתת את זה struct שם,

1686
01:07:29,380 --> 01:07:31,340
או שאתה לא יכול
אומר צומת struct כאן.

1687
01:07:31,340 --> 01:07:33,340
בעוד שבעבר עם תלמיד
כאשר אנו מקלידים, אני חושב,

1688
01:07:33,340 --> 01:07:35,423
לא היה לנו לומר
תלמיד שם למעלה, כי אנחנו

1689
01:07:35,423 --> 01:07:40,370
לא צריך להגיד struct
סטודנט בתוך struct עצמו.

1690
01:07:40,370 --> 01:07:43,730
אז זה רקורסיבית ש
מכריח אותנו לומר צומת שם.

1691
01:07:43,730 --> 01:07:46,610
>> צומת זו היא רק שם אנחנו
נותן צומת לtypedef.

1692
01:07:46,610 --> 01:07:48,520
אז הצומת שאינה
זהה לצומת.

1693
01:07:48,520 --> 01:07:51,567
אבל צומת struct זה
אותו דבר כמו שצומת struct.

1694
01:07:51,567 --> 01:07:54,150
דווין: אז בכל פעם שאתה קורא,
כמו, צומת בפונקציה העיקרית שלך,

1695
01:07:54,150 --> 01:07:55,350
אתה לא הולך ל
יש לי לומר צומת struct.

1696
01:07:55,350 --> 01:07:58,360
אתה פשוט יכול להגיד צומת, משום ש
צומת היא different-- היא בעצם

1697
01:07:58,360 --> 01:07:59,440
אתה אומר, בסדר.

1698
01:07:59,440 --> 01:08:01,490
במקום שיש לקרוא
צומת struct בקוד שלי,

1699
01:08:01,490 --> 01:08:04,050
אני רק רוצה לשנות את זה
כצומת כדי להפוך אותו קל יותר.

1700
01:08:04,050 --> 01:08:06,800
>> רוב: אם אתה תמיד
להשתמש typedef, אז זה

1701
01:08:06,800 --> 01:08:11,240
הוא רק המקום שאתה הולך יש לי
להכריז על משתנה עם צומת struct

1702
01:08:11,240 --> 01:08:11,740
כוכב, כן.

1703
01:08:11,740 --> 01:08:14,650

1704
01:08:14,650 --> 01:08:20,801
>> דווין: אוקיי, אז את החלק האחרון
קשה ללמד because--

1705
01:08:20,801 --> 01:08:22,185

1706
01:08:22,185 --> 01:08:22,685
ROB: מה?

1707
01:08:22,685 --> 01:08:24,098

1708
01:08:24,098 --> 01:08:25,649
>> דווין: כי זה קידוד על נייר.

1709
01:08:25,649 --> 01:08:28,689
אז בכל שנה יש לנו
קוד על שאלות נייר.

1710
01:08:28,689 --> 01:08:32,510
אז אני חושב ששנה שעברה, 12 מתוך
80 נקודות היו קוד על נייר.

1711
01:08:32,510 --> 01:08:36,720
שנה לפני כן, 10 מתוך 80,
שנה לפני כן, 20 מתוך 100,

1712
01:08:36,720 --> 01:08:37,939
כך לא מעט מאלה.

1713
01:08:37,939 --> 01:08:40,970
אז אתה הולך צריך להיות מסוגל
קוד פונקציות אלה ביד.

1714
01:08:40,970 --> 01:08:45,340
>> אז חשבתי שאולי כדאי ללכת דרך
כמה מהם ולראות איך אנשים עושים,

1715
01:08:45,340 --> 01:08:47,340
סוג של ללכת דרך
אותם לאט לאט עם אנשים.

1716
01:08:47,340 --> 01:08:48,790

1717
01:08:48,790 --> 01:08:52,420
אז בדרך כלל, וstrlen
atoi היה מאוד פופולרי.

1718
01:08:52,420 --> 01:08:55,670
בשנה שעברה, אני חושב שהייתי לנו
GetPositiveInt וRandomInt.

1719
01:08:55,670 --> 01:08:58,591
אבל pow, כך כוח, גם
אחד חיובי מדי.

1720
01:08:58,591 --> 01:09:00,965
בואו פשוט לעבור אולי
אחד או שניים מהם יחד.

1721
01:09:00,965 --> 01:09:02,510

1722
01:09:02,510 --> 01:09:03,729
מה שאנשים רוצים לראות?

1723
01:09:03,729 --> 01:09:05,037

1724
01:09:05,037 --> 01:09:05,767
>> תלמיד: atoi.

1725
01:09:05,767 --> 01:09:06,350
סטודנט: כן.

1726
01:09:06,350 --> 01:09:06,859
דווין: atoi?

1727
01:09:06,859 --> 01:09:07,800
תלמיד: [לא ברור].

1728
01:09:07,800 --> 01:09:09,682
דווין: אישור, אני הולך
כדי לעשות את זה על הלוח.

1729
01:09:09,682 --> 01:09:11,765
האם יש לך העדפה
אם אני עושה את זה פה או שם?

1730
01:09:11,765 --> 01:09:13,580

1731
01:09:13,580 --> 01:09:14,550
יש, גייב אומר שיש.

1732
01:09:14,550 --> 01:09:16,729

1733
01:09:16,729 --> 01:09:19,580
>> ROB: וזה מחשבות כלליות
על שאלות אלה קידוד.

1734
01:09:19,580 --> 01:09:21,705
נסה לכתוב משהו.

1735
01:09:21,705 --> 01:09:22,580
אל תשאיר אותו ריק.

1736
01:09:22,580 --> 01:09:23,080
>> דווין: כן.

1737
01:09:23,080 --> 01:09:25,520
רוב: אם אתה יכול להשיג
לחזור נכון סוג,

1738
01:09:25,520 --> 01:09:27,090
או אולי אנחנו יכולים לתת לזה
אתה, אבל אם אתה יכול, כמו,

1739
01:09:27,090 --> 01:09:30,256
לכתוב את חתימת הפונקציה הכללית,
אם אתה יכול להשיג נכון מקרי הבסיס,

1740
01:09:30,256 --> 01:09:32,244
או מקרי פינה, או
לזכור המחאה על null,

1741
01:09:32,244 --> 01:09:34,160
כל עוד יש לך כמה
דברים, אז אולי

1742
01:09:34,160 --> 01:09:35,880
יכול לתת לך כמה
מצביע לבעיה.

1743
01:09:35,880 --> 01:09:36,810
רק אל תשאיר אותו ריק.

1744
01:09:36,810 --> 01:09:38,560
>> דווין: כן, ואם אתה
רק לחלוטין

1745
01:09:38,560 --> 01:09:40,580
מבולבל על איך
למעשה תהפוך לקוד.

1746
01:09:40,580 --> 01:09:43,140
אם אתה כותב פסאודו קוד,
זה די טוב מדי.

1747
01:09:43,140 --> 01:09:46,390
אז זה כמו, זה שאלה שש נקודות,
ואתה כותב פסאודו קוד הנכון,

1748
01:09:46,390 --> 01:09:47,858
תקבל לפחות שתי נקודות.

1749
01:09:47,858 --> 01:09:49,149
אז לא רק להשאיר אותם ריק.

1750
01:09:49,149 --> 01:09:50,279
נסה לשים משהו.

1751
01:09:50,279 --> 01:09:51,770
>> ROB: זה צריך להיות
פסאודו קוד נכון, אם כי.

1752
01:09:51,770 --> 01:09:52,270
>> דווין: כן.

1753
01:09:52,270 --> 01:09:55,381
רוב: אז אנחנו בדרך כלל פחות
להקל עם באגים בפסאודו קוד.

1754
01:09:55,381 --> 01:09:57,130
דווין: אוקיי, אז אתם
רציתי לראות atoi.

1755
01:09:57,130 --> 01:09:58,480

1756
01:09:58,480 --> 01:10:02,820
אוקיי, אז רק אמת--
אז מה שאתה רוצה לעשות

1757
01:10:02,820 --> 01:10:04,969
הוא שאתה הולך להיות
נתן איזה מספר.

1758
01:10:04,969 --> 01:10:07,010
אך מספר זה אינו
הולך להיות int, נכון?

1759
01:10:07,010 --> 01:10:08,574
מה זה הולך להיות?

1760
01:10:08,574 --> 01:10:09,480
>> תלמיד: [לא ברור].

1761
01:10:09,480 --> 01:10:11,146
>> דווין: זה הולך להיות מחרוזת, נכון?

1762
01:10:11,146 --> 01:10:13,160
אז אם היו ניתן לך
string-- בואו say--

1763
01:10:13,160 --> 01:10:15,228
>> רוב: אני צריך למשוך את עורך?

1764
01:10:15,228 --> 01:10:16,200
אני יכול למשוך up--

1765
01:10:16,200 --> 01:10:16,800
>> דווין: אה, אתה רוצה לעשות את זה on--

1766
01:10:16,800 --> 01:10:17,420
>> ROB: האם אתה מעדיף את הלוח?

1767
01:10:17,420 --> 01:10:18,800
>> דווין: מה אתה רוצה לעשות?

1768
01:10:18,800 --> 01:10:19,900
אני מתכוון, אתה רוצה לעשות את זה ביד?

1769
01:10:19,900 --> 01:10:21,460
או שאתה רוצה לעשות את זה על ידי מחשב?

1770
01:10:21,460 --> 01:10:22,180
>> ROB: לעשות את זה ביד.

1771
01:10:22,180 --> 01:10:22,805
>> דווין: [צוחק]

1772
01:10:22,805 --> 01:10:23,950
ROB: לעשות את זה ביד.

1773
01:10:23,950 --> 01:10:25,469
>> דווין: אוקיי, אז זה הולך להיות atoi.

1774
01:10:25,469 --> 01:10:27,760
אז מה it-- אני מתכוון, אנחנו
כנראה לתת לך את זה.

1775
01:10:27,760 --> 01:10:29,106
אבל מה שזה הולך לחזור?

1776
01:10:29,106 --> 01:10:29,452
>> תלמיד: Int.

1777
01:10:29,452 --> 01:10:31,076
>> דווין: זה הולך לחזור int, נכון?

1778
01:10:31,076 --> 01:10:33,772
אז-- אני לא רוצה לעשות את זה שם.

1779
01:10:33,772 --> 01:10:34,510
אני אעשה את זה כאן.

1780
01:10:34,510 --> 01:10:36,596
>> ROB: אתה יכול למשוך אותה למטה
ולאחר מכן דחף על זה.

1781
01:10:36,596 --> 01:10:38,500

1782
01:10:38,500 --> 01:10:40,385
>> דווין: כן.

1783
01:10:40,385 --> 01:10:43,880
[צוחק] שינוי משחק.

1784
01:10:43,880 --> 01:10:50,950
אוקיי, אז זה הולך להיות atoi int,
ומה זה הולך לקחת?

1785
01:10:50,950 --> 01:10:52,180

1786
01:10:52,180 --> 01:10:57,780
כוכב char, כל כך פשוט
מחרוזת, כוכב ים, כמו ש.

1787
01:10:57,780 --> 01:10:59,240
>> ROB: כוכב נחמד, נחמד.

1788
01:10:59,240 --> 01:11:02,582

1789
01:11:02,582 --> 01:11:04,040
דווין: זה לא יכול להיות שם, על אישור.

1790
01:11:04,040 --> 01:11:04,540
ROB: כן.

1791
01:11:04,540 --> 01:11:06,670
דווין: אוקיי, אז הראשון
דבר שאתה רוצה do-- אני

1792
01:11:06,670 --> 01:11:08,490
לא יודע אם מישהו נראה
בsolutions-- בפועל

1793
01:11:08,490 --> 01:11:10,150
אבל מה אתה הולך
לרוצה לעשות הוא שאתה

1794
01:11:10,150 --> 01:11:11,570
הולך רוצה יש לי
לולאה, כי אתה

1795
01:11:11,570 --> 01:11:14,100
הולך רוצה בעצם
צעד דרך מחרוזת זו.

1796
01:11:14,100 --> 01:11:18,880
אז helpful-- אז נניח
אנחנו הולכים ללולאה,

1797
01:11:18,880 --> 01:11:22,270
ואנחנו הולכים כדי לעבור
כל אלמנט של המחרוזת.

1798
01:11:22,270 --> 01:11:23,470
כמה זמן זה?

1799
01:11:23,470 --> 01:11:26,464
כמה פעמים אנחנו הולכים
ללחזר שללולאה?

1800
01:11:26,464 --> 01:11:27,130
תלמיד: Sterln?

1801
01:11:27,130 --> 01:11:27,963
דווין: Sterln, כן.

1802
01:11:27,963 --> 01:11:29,350

1803
01:11:29,350 --> 01:11:41,294
אז בואו נגיד שאורך int שווה sterln של.

1804
01:11:41,294 --> 01:11:44,240

1805
01:11:44,240 --> 01:11:48,740
וסתם סקרן, למה זה תמיד סוג
של טוב יותר לעשות את זה בחוץ של לולאות?

1806
01:11:48,740 --> 01:11:52,277
כמו, למה זה טוב יותר לקרוא ל
פונקציה זו מחוץ ללולאה?

1807
01:11:52,277 --> 01:11:53,360
רק שפיות מהירה לבדוק?

1808
01:11:53,360 --> 01:11:55,810

1809
01:11:55,810 --> 01:11:56,311
כן?

1810
01:11:56,311 --> 01:11:58,268
תלמיד: אז אתה לא
צריך להמשיך לבדוק את זה.

1811
01:11:58,268 --> 01:11:59,400
אתה יכול פשוט [לא ברור].

1812
01:11:59,400 --> 01:12:01,560
>> דווין: בדיוק, אז כן,
בדיוק מה שהיא אמרה.

1813
01:12:01,560 --> 01:12:03,101
אז אנחנו לא צריכים להמשיך לבדוק את זה.

1814
01:12:03,101 --> 01:12:05,690
כך למשל, אם אני מתקשר
פונקציה זו בתוך לולאה,

1815
01:12:05,690 --> 01:12:08,050
אז אני הולך להמשיך לקרוא
פונקציה זו מספר רב של פעמים.

1816
01:12:08,050 --> 01:12:10,080
וזה הולך להקטין
היעילות של התכנית שלך.

1817
01:12:10,080 --> 01:12:12,370
אז זה תמיד שימושי
להכריז עליה מבחוץ.

1818
01:12:12,370 --> 01:12:14,370
>> ROB: זה אמר, ב
כל הבעיות הללו,

1819
01:12:14,370 --> 01:12:17,940
פחות או יותר כל עוד אתה מקבל
פתרון עובד, אתה מקבל קרדיט מלא.

1820
01:12:17,940 --> 01:12:20,820
אז אל תדאגו אם העיצוב שלך
הוא ממש זוועתי.

1821
01:12:20,820 --> 01:12:22,120

1822
01:12:22,120 --> 01:12:25,230
זה יכול לגרום לנו נסער
קריאת הקוד שלך.

1823
01:12:25,230 --> 01:12:28,160
אבל כל עוד זה עובד,
תקבל את הנקודות.

1824
01:12:28,160 --> 01:12:29,302
>> דווין: כן.

1825
01:12:29,302 --> 01:12:31,260
אוקיי, אז אחר כך אני הולך ל
להכריז כמה משתנים.

1826
01:12:31,260 --> 01:12:33,900
זה רק הולך לקרוא לסכום int.

1827
01:12:33,900 --> 01:12:37,031
ואני הולך להגדיר את זה
שווה לאפס, כמו ש.

1828
01:12:37,031 --> 01:12:38,780
וזה רק הולך
להיות מציין מיקום.

1829
01:12:38,780 --> 01:12:40,960
אז זה הולך להיות
מה שאני הולך לחזור.

1830
01:12:40,960 --> 01:12:43,730
אז אני הולך לסופו של דבר
לחזור סכום מתוך תכנית זו.

1831
01:12:43,730 --> 01:12:44,980
אז יש לי שני המשתנים הללו.

1832
01:12:44,980 --> 01:12:45,563
יש לי אורך.

1833
01:12:45,563 --> 01:12:46,500
יש לי סכום.

1834
01:12:46,500 --> 01:12:48,290
ועכשיו בואו נקפוץ למחרוזת שלנו.

1835
01:12:48,290 --> 01:12:49,510
>> כך מאפשר לנו ללולאה.

1836
01:12:49,510 --> 01:13:06,520
אז ארבעה אני int שווה 0 w, ואילו
אני הוא פחות ממה שאורך פלוס פלוס.

1837
01:13:06,520 --> 01:13:07,150
וnow--

1838
01:13:07,150 --> 01:13:10,920

1839
01:13:10,920 --> 01:13:11,420
ROB: נחמד.

1840
01:13:11,420 --> 01:13:14,030
דווין: אישור, ועכשיו כאן
מגיע הבשר של הקוד שלנו.

1841
01:13:14,030 --> 01:13:17,380
אז אתה באמת יכול לעשות
הקו הזה בעצם באחד.

1842
01:13:17,380 --> 01:13:20,702
אז האם יש למישהו רעיון
של מה שאנחנו הולכים לעשות עכשיו?

1843
01:13:20,702 --> 01:13:23,680

1844
01:13:23,680 --> 01:13:25,380
אוקיי, אז זה בסדר.

1845
01:13:25,380 --> 01:13:35,860
אז אנחנו עושים לומר סכום equals--
תן לי לגרור את סכום over-- זה

1846
01:13:35,860 --> 01:13:50,010
שווה סכום פעמים 10 plus-- אנחנו
הולך לקחת לי של מינוס אחד

1847
01:13:50,010 --> 01:13:54,787
ציטוט 0 אחד לעשות, כמו ש.

1848
01:13:54,787 --> 01:13:55,620
רוב: מאוד אינטואיטיבי.

1849
01:13:55,620 --> 01:13:56,980

1850
01:13:56,980 --> 01:13:57,880
>> דווין: מחצבתו.

1851
01:13:57,880 --> 01:14:01,438
אוקיי, אז someone-- לי את זה, יש לי את זה.

1852
01:14:01,438 --> 01:14:03,680

1853
01:14:03,680 --> 01:14:06,960
אוקיי, אז זה ברור עולה.

1854
01:14:06,960 --> 01:14:08,320

1855
01:14:08,320 --> 01:14:09,450
מה זה אומר?

1856
01:14:09,450 --> 01:14:12,120
אז האם מישהו יודע מה זה אומר?

1857
01:14:12,120 --> 01:14:13,826
האם כל אחד יכול לראות את זה?

1858
01:14:13,826 --> 01:14:16,088
לא, אף אחד לא יכול לראות את זה, OK.

1859
01:14:16,088 --> 01:14:17,390

1860
01:14:17,390 --> 01:14:18,340
אני הולך to--

1861
01:14:18,340 --> 01:14:20,506
>> רוב: אני הולך לכתוב
נוסחה בדיוק כאן.

1862
01:14:20,506 --> 01:14:23,140
דווין: אישור, רוב הולך לעשות את זה
במחשב, וזה כיף.

1863
01:14:23,140 --> 01:14:26,889

1864
01:14:26,889 --> 01:14:27,514
רוב: הו אלוהים שלי.

1865
01:14:27,514 --> 01:14:34,340

1866
01:14:34,340 --> 01:14:35,010
או שאני לא.

1867
01:14:35,010 --> 01:14:36,288

1868
01:14:36,288 --> 01:14:36,954
דווין: Stand by.

1869
01:14:36,954 --> 01:14:42,300

1870
01:14:42,300 --> 01:14:44,260
תלמיד: יש לי שאלה.

1871
01:14:44,260 --> 01:14:45,348
דווין: כן, בטוח.

1872
01:14:45,348 --> 01:14:46,223
תלמיד: [לא ברור]?

1873
01:14:46,223 --> 01:14:52,529

1874
01:14:52,529 --> 01:14:54,570
דווין: אוקיי, אז זה באמת,
כמו, רק באופן כללי,

1875
01:14:54,570 --> 01:14:56,710
אם היית לשים, כמו,
בint הצהרה זו

1876
01:14:56,710 --> 01:14:59,770
אני שווה אורך 0 פסיק
שווה sterln, that--

1877
01:14:59,770 --> 01:15:01,200
>> תלמיד: [לא ברור].

1878
01:15:01,200 --> 01:15:03,585
>> דווין: זה בסדר, כי that--

1879
01:15:03,585 --> 01:15:05,543
תלמיד: למה אתה
אפילו צריך להשתמש באורך?

1880
01:15:05,543 --> 01:15:08,620
למה אנחנו לא יכולים פשוט [לא ברורים] sterln
של, כמו כל הזמן [לא ברור]?

1881
01:15:08,620 --> 01:15:09,460
>> דווין: אתה מתכוון כאן?

1882
01:15:09,460 --> 01:15:10,001
>> סטודנט: כן.

1883
01:15:10,001 --> 01:15:12,630
דווין: כי כל
הפעם לריצות לולאה,

1884
01:15:12,630 --> 01:15:14,295
זה הולך להעריך את המצב הזה.

1885
01:15:14,295 --> 01:15:14,920
תלמיד: העכבר.

1886
01:15:14,920 --> 01:15:16,836
דווין: ואם יש לך
sterln שם, אז זה

1887
01:15:16,836 --> 01:15:19,510
תצטרך לקרוא למעשה
פונקציה שכל פעם אחת.

1888
01:15:19,510 --> 01:15:21,090
אז במקום רק
השוואתה לint,

1889
01:15:21,090 --> 01:15:23,548
אתה הולך להיות קורא
פונקציה ולאחר מכן השוואתה

1890
01:15:23,548 --> 01:15:24,510
לערך ההחזרה.

1891
01:15:24,510 --> 01:15:25,860
כן, אז זה רק, כן.

1892
01:15:25,860 --> 01:15:28,860

1893
01:15:28,860 --> 01:15:30,770
>> נחמד, בסדר, אז עכשיו כולם יכול לראות את זה.

1894
01:15:30,770 --> 01:15:33,400
מה does-- זה כמו, זה זה.

1895
01:15:33,400 --> 01:15:34,580
זה הריבה, ממש כאן.

1896
01:15:34,580 --> 01:15:37,030

1897
01:15:37,030 --> 01:15:37,930
מה זה אומר?

1898
01:15:37,930 --> 01:15:39,250

1899
01:15:39,250 --> 01:15:39,970
מה אני עושה?

1900
01:15:39,970 --> 01:15:41,890

1901
01:15:41,890 --> 01:15:42,880
כן, רעיון?

1902
01:15:42,880 --> 01:15:43,482
כן?

1903
01:15:43,482 --> 01:15:45,692
>> תלמיד: ובכן, ולכן כאשר
אתה נכנסים מערך,

1904
01:15:45,692 --> 01:15:47,525
אתה הולך להיות יוצא
משמאל לימין,

1905
01:15:47,525 --> 01:15:51,786
אז אתה הולך להיות הולך ב
עשרוני מלמטה [לא ברור].

1906
01:15:51,786 --> 01:15:52,410
דווין: בדיוק.

1907
01:15:52,410 --> 01:15:55,063
תלמיד: אז כל אחד
אתה צריך להכפיל

1908
01:15:55,063 --> 01:15:59,490
מה שראית כערך int על ידי
הפעם שאתה מקבל לעבור כי למעלה מ.

1909
01:15:59,490 --> 01:16:01,590
>> דווין: מושלם, מושלם,
כך למשל, בואו

1910
01:16:01,590 --> 01:16:05,376
נגיד שנתתי לי you-- אני
הולך לכתוב כאן.

1911
01:16:05,376 --> 01:16:06,480
לא, אני לא.

1912
01:16:06,480 --> 01:16:08,640
אני הולך לכתוב כאן.

1913
01:16:08,640 --> 01:16:12,080
בואו נגיד שאני נתתי לך 76, נכון?

1914
01:16:12,080 --> 01:16:13,380
בואו נגיד שאני אתן לך 76.

1915
01:16:13,380 --> 01:16:15,360
זה מחרוזת מלכתחילה, בסדר?

1916
01:16:15,360 --> 01:16:16,840
>> כך שאורך הוא מה?

1917
01:16:16,840 --> 01:16:18,060

1918
01:16:18,060 --> 01:16:19,060
2, נכון?

1919
01:16:19,060 --> 01:16:20,290
סכום הוא 0.

1920
01:16:20,290 --> 01:16:21,600
אז אנחנו קופצים בנו ללולאה.

1921
01:16:21,600 --> 01:16:24,187
אישור, הגרסה הראשונה של
זה, מה זה הולך להיות?

1922
01:16:24,187 --> 01:16:25,270
זה הולך להיות סכום הוא 0.

1923
01:16:25,270 --> 01:16:27,180
אז תסכם פעמים 10 0.

1924
01:16:27,180 --> 01:16:28,500
זה חסר משמעות.

1925
01:16:28,500 --> 01:16:29,880
אז מה זה עושה?

1926
01:16:29,880 --> 01:16:30,845

1927
01:16:30,845 --> 01:16:31,720
תלמיד: [לא ברור].

1928
01:16:31,720 --> 01:16:33,110

1929
01:16:33,110 --> 01:16:37,430
>> דווין: זה הולך להפוך את זה
תו למספר שלם, נכון?

1930
01:16:37,430 --> 01:16:42,160
זה כמו סוג של עם שלך
בעיה set-- light-- זה

1931
01:16:42,160 --> 01:16:44,170
זה כמו סוג של עם
בעיה מוגדרת VISIONEER.

1932
01:16:44,170 --> 01:16:45,980
עם ערכי ASCII יש לך עסק.

1933
01:16:45,980 --> 01:16:48,520
אז אם אני נותן לך, כמו,
שבע, אבל זה אופי,

1934
01:16:48,520 --> 01:16:50,965
ואתה רוצה לדעת,
אישור, מה שספרה הוא ש?

1935
01:16:50,965 --> 01:16:53,540

1936
01:16:53,540 --> 01:16:54,910
כן, אתה יכול, כן.

1937
01:16:54,910 --> 01:16:55,900
אז מה ספרה זה?

1938
01:16:55,900 --> 01:16:59,550
אתה יכול להחסיר 0 ממנו, אבל אתה
צריך להחסיר 0, האופי.

1939
01:16:59,550 --> 01:17:01,425
>> ושבו חלק מאנשים
לקבל הכשילו את, הם

1940
01:17:01,425 --> 01:17:04,260
כמו, אישור, גם לעשות, אני צריך לדעת
ערכי ASCII לחידון זה?

1941
01:17:04,260 --> 01:17:06,218
לא, אתה בהחלט לא
צריך לדעת ASCII

1942
01:17:06,218 --> 01:17:09,520
ערכים של, כמו, באותיות קטנות
, אותיות רישיות, אפס.

1943
01:17:09,520 --> 01:17:12,060
>> ROB: אין סיבה לאי
לשים את זה בגיליון לרמות.

1944
01:17:12,060 --> 01:17:14,226
>> דווין: לעשות בהחלט לא
לבזבז השטח שלך עם זה.

1945
01:17:14,226 --> 01:17:18,090
אתה יכול literally-- רק במקום
לומר 48, כמו ימין למעלה

1946
01:17:18,090 --> 01:17:24,630
יש, כי הוא שווה ערך ל
אומר אחד, גרש אחד,

1947
01:17:24,630 --> 01:17:27,680
כמו ש, בדיוק אותו הדבר.

1948
01:17:27,680 --> 01:17:34,106
>> ROB: אתה כמעט יכול לחשוב
על זה כif-- אלוהים, אני צריך,

1949
01:17:34,106 --> 01:17:37,490
oops-- כמעט שאתה יכול לחשוב על זה
כאילו יש לנו משהו כמו חשיש ש

1950
01:17:37,490 --> 01:17:39,755
להגדיר 0 48.

1951
01:17:39,755 --> 01:17:41,320

1952
01:17:41,320 --> 01:17:42,030
זה לא יעבוד.

1953
01:17:42,030 --> 01:17:45,502
אבל תחשוב על זה כעל ציטוט אחד 0
ציטוט אחד, ועבור כל הדמויות.

1954
01:17:45,502 --> 01:17:47,960
תחשוב על זה כקבוע ש
מייצג שערך ASCII.

1955
01:17:47,960 --> 01:17:49,080
>> דווין: כן.

1956
01:17:49,080 --> 01:17:52,820
אוקיי, אז בפעם הראשונה דרך, כל כך
עם 76-- כך בפעם הראשונה דרך,

1957
01:17:52,820 --> 01:17:57,260
זה רק האופי
7 מינוס האופי 0,

1958
01:17:57,260 --> 01:18:00,420
ואלו הם שבעה
integers-- גם, אלה

1959
01:18:00,420 --> 01:18:04,030
הם אחד משבעה חללים
אחר בתרשים ASCII או משהו כזה.

1960
01:18:04,030 --> 01:18:06,770
אז זה הולך לחזור int של 7.

1961
01:18:06,770 --> 01:18:08,720
אז עכשיו, סכום שווה 7.

1962
01:18:08,720 --> 01:18:10,830
>> בסדר, ובכן, בואו לקפוץ
לזה ללולאה שוב.

1963
01:18:10,830 --> 01:18:13,010
אוקיי, עכשיו זה סכום פעמים 10.

1964
01:18:13,010 --> 01:18:15,800
אז אתה ביעילות
נע 7 משמאל.

1965
01:18:15,800 --> 01:18:17,542
האם זה הגיוני?

1966
01:18:17,542 --> 01:18:19,250
אתה ביעילות
להעביר אותו לצד השמאל.

1967
01:18:19,250 --> 01:18:21,790
>> ואז אתה add-- זה
הולך להיות 6 מינוס 0.

1968
01:18:21,790 --> 01:18:22,650
זה 6.

1969
01:18:22,650 --> 01:18:24,752
אז זה הולך להיות 70 בתוספת 6.

1970
01:18:24,752 --> 01:18:25,996
76, זה המספר שלך.

1971
01:18:25,996 --> 01:18:28,370
אז בלי קשר למה מספר
שנתתי לך, זה לאט פשוט

1972
01:18:28,370 --> 01:18:31,610
הולך להעביר את הערכים הגדולים יותר
גורם, 1 בצד השמאל של 10

1973
01:18:31,610 --> 01:18:35,525
בכל פעם בלולאה,
ולאחר מכן להוסיף במידת צורך.

1974
01:18:35,525 --> 01:18:37,350

1975
01:18:37,350 --> 01:18:37,865
>> בגב?

1976
01:18:37,865 --> 01:18:40,240
תלמיד: אנחנו לא צריכים לעשות
כל בדיקה בתכנית?

1977
01:18:40,240 --> 01:18:41,580

1978
01:18:41,580 --> 01:18:44,302
>> ROB: עד כה כמו בדיקה
הולך לתכנית,

1979
01:18:44,302 --> 01:18:46,510
היינו אומר לך די
הרבה מה שאתה צריך לבדוק.

1980
01:18:46,510 --> 01:18:48,670
אם אנחנו לא אומרים לך
שום דבר, אז בדרך כלל

1981
01:18:48,670 --> 01:18:50,320
תניח שאתה צריך לבדוק את רוב הדברים.

1982
01:18:50,320 --> 01:18:54,772
כמו שאתה יכול, רק כדי להיות בטוח, אתה
כנראה צריך לבדוק היי, הוא null של?

1983
01:18:54,772 --> 01:18:56,230
ואז אין לי מושג מה לחזור.

1984
01:18:56,230 --> 01:18:58,814
אבל היינו אומר לך
דברים מהסוג הזה.

1985
01:18:58,814 --> 01:18:59,480
0, אני לא יודע.

1986
01:18:59,480 --> 01:19:02,786
>> דווין: ולמה אתה רוצה
לחזור ולבדוק אם זה שווה null?

1987
01:19:02,786 --> 01:19:03,660
תלמיד: [לא ברור].

1988
01:19:03,660 --> 01:19:04,880
דווין: בגלל כוכב char.

1989
01:19:04,880 --> 01:19:05,510
זה מצביע.

1990
01:19:05,510 --> 01:19:09,240
אז מקובל לחלוטין
הצהרה, שאני יכול לומר, אישור,

1991
01:19:09,240 --> 01:19:11,917
של שווה null, כי זה
יכול להיות מצביע null.

1992
01:19:11,917 --> 01:19:14,250
אז בכל פעם שיש לך עצות
בדרך שלך בכך,

1993
01:19:14,250 --> 01:19:15,420
אתה כנראה צריך לבדוק.

1994
01:19:15,420 --> 01:19:18,461
כי אם אתה לא לבדוק את זה, ו
אז אתה ואז ללכת לך ללולאה,

1995
01:19:18,461 --> 01:19:20,100
ואתה doing-- "זוז.

1996
01:19:20,100 --> 01:19:21,980

1997
01:19:21,980 --> 01:19:22,920
"זוז.

1998
01:19:22,920 --> 01:19:23,860
>> ROB: מצטער, זה הכל.

1999
01:19:23,860 --> 01:19:25,860
>> דווין: וכך, כמו, אם
זה null, ואז אתה

2000
01:19:25,860 --> 01:19:28,267
לעשות את מה ששגיאה, זה
אתה הולך לקבל?

2001
01:19:28,267 --> 01:19:29,850
תלמיד: אתה הולך לקבל באשמת קבוצה.

2002
01:19:29,850 --> 01:19:31,250
דווין: אתה הולך להקים
פגם, תקין, בגלל שאתה

2003
01:19:31,250 --> 01:19:32,616
מנסה מדד לnull.

2004
01:19:32,616 --> 01:19:35,240
אז אתה הולך לנסות מדד
לזיכרון שאינה בבעלותכם.

2005
01:19:35,240 --> 01:19:39,550
אז זה, אם זה הוא ריק, ו
אתה עושה את זה, שתצליח מחזור.

2006
01:19:39,550 --> 01:19:43,656
>> ROB: אני גם חושב על הבחינה שב
שאלנו את השאלה הזאת, אנו אומרים לכם

2007
01:19:43,656 --> 01:19:45,655
כי אתה פשוט יכול להניח
זה מספר חיובי.

2008
01:19:45,655 --> 01:19:48,270
בגלל atoi צפוי גם
כדי להתמודד עם מספרים שליליים,

2009
01:19:48,270 --> 01:19:49,686
כך היית צריך מקרה מיוחד.

2010
01:19:49,686 --> 01:19:53,080
היי, היא הדמות הראשונה
מקף, ובמקרה זה, אישור,

2011
01:19:53,080 --> 01:19:54,839
עכשיו זה מספר שלם שלילי.

2012
01:19:54,839 --> 01:19:56,380
אנו אגיד לך דברים כאלה.

2013
01:19:56,380 --> 01:19:58,005
אנו אגיד לך מה שאתה צריך לטפל.

2014
01:19:58,005 --> 01:19:59,310
דווין: כן.

2015
01:19:59,310 --> 01:20:02,530
אז אני בטוח שיש אנשים שאולי have--
אם אתה התחיל להסתכל על מבחנים ישנים,

2016
01:20:02,530 --> 01:20:03,900
ראית sterln.

2017
01:20:03,900 --> 01:20:05,120
זה אחד פופולרי.

2018
01:20:05,120 --> 01:20:09,790
ואני חושב בsterln, היה לך ל
לעשות בדיקה זו לnull, התמורה

2019
01:20:09,790 --> 01:20:10,950
0 או משהו כזה.

2020
01:20:10,950 --> 01:20:11,940
כלומר, את צריך לבדוק לnull.

2021
01:20:11,940 --> 01:20:14,230
ואם לא, ש
היה מצביע את על החידון.

2022
01:20:14,230 --> 01:20:16,750

2023
01:20:16,750 --> 01:20:19,500
אז בכל מקרה, עושה כולם
מרגיש בסדר עם atoi?

2024
01:20:19,500 --> 01:20:21,112

2025
01:20:21,112 --> 01:20:22,820
האם מישהו רוצה
ללכת על חלקים שוב?

2026
01:20:22,820 --> 01:20:23,815

2027
01:20:23,815 --> 01:20:25,565
רוב: אה, כן, אני חושב ש
אנחנו גם נגיד לך לך

2028
01:20:25,565 --> 01:20:28,565
ניתן להניח את כל מה שis-- ש
הם למעשה הזנת מספר,

2029
01:20:28,565 --> 01:20:32,821
כי אתה לא צריך לדאוג,
כמו, מכתבים להיות במחרוזת, כך.

2030
01:20:32,821 --> 01:20:33,320
דווין: כן.

2031
01:20:33,320 --> 01:20:33,922
כן?

2032
01:20:33,922 --> 01:20:35,713
תלמיד: האם אתה יכול ללכת
על עוד פעם אחת כש

2033
01:20:35,713 --> 01:20:37,860
אתה משתמש במירכאות כפולות וציטוט אחד?

2034
01:20:37,860 --> 01:20:41,290
>> דווין: בטח, כל כך במרכאות כפולות, מאוד
פשוט, הוא במרכאות כפולות הן מחרוזות.

2035
01:20:41,290 --> 01:20:43,370
אז אם אתה להכפיל ציטוט
שום דבר, זה מחרוזת.

2036
01:20:43,370 --> 01:20:48,270
אז, כמו, אם היה לי זה 0 לכאן,
ועשיתי את זה, זה חוט.

2037
01:20:48,270 --> 01:20:50,060
זה כבר לא אופי.

2038
01:20:50,060 --> 01:20:54,816
אז אני לא יכול למצוא ערך זה בASCII שלי
תרשים, כי זה מחרוזת, כן.

2039
01:20:54,816 --> 01:20:57,770

2040
01:20:57,770 --> 01:20:59,480
>> אישור, כל שאלות אחרות?

2041
01:20:59,480 --> 01:21:00,405
כן?

2042
01:21:00,405 --> 01:21:02,345
>> תלמיד: אז יש לך
כבר ענה על זה,

2043
01:21:02,345 --> 01:21:05,255
אבל כמו, כאשר אנחנו בעצם
כותב את זה בחידון,

2044
01:21:05,255 --> 01:21:08,165
אתה רוצה אותנו לכתוב ב
חתכים [לא ברור] אפסים?

2045
01:21:08,165 --> 01:21:11,041

2046
01:21:11,041 --> 01:21:11,540
דווין: מס '

2047
01:21:11,540 --> 01:21:13,800
השאלה הייתה צריך אותך
לשים קו נטוי דרך האפסים

2048
01:21:13,800 --> 01:21:14,890
כדי לציין אם הם אפסים?

2049
01:21:14,890 --> 01:21:15,890
לא, אנחנו להבין את זה.

2050
01:21:15,890 --> 01:21:16,940

2051
01:21:16,940 --> 01:21:19,530
כן, תודה, הם טובים.

2052
01:21:19,530 --> 01:21:20,860
אישור, כל דבר אחר?

2053
01:21:20,860 --> 01:21:25,060
האם מישהו רוצה to-- אז אני חושב ש
אנחנו פגשנו קצת לאורך זמן.

2054
01:21:25,060 --> 01:21:27,305
האם אתה רוצה לראות עוד אחד, או?

2055
01:21:27,305 --> 01:21:28,096
תלמיד: RandomInt.

2056
01:21:28,096 --> 01:21:29,230

2057
01:21:29,230 --> 01:21:30,750
>> דווין: RandomInt, אישור, בדיוק.

2058
01:21:30,750 --> 01:21:32,975
אז בואו נעשה RandomInt.

2059
01:21:32,975 --> 01:21:34,395

2060
01:21:34,395 --> 01:21:35,270
אני אעשה את זה כאן.

2061
01:21:35,270 --> 01:21:36,770

2062
01:21:36,770 --> 01:21:39,210
אז RandomInt הוא למעשה הרבה יותר פשוט.

2063
01:21:39,210 --> 01:21:43,578
אני חושב שatoi הוא כנראה הכי קשה אחד
שאנחנו כבר ביקשנו בשנים הקודמות.

2064
01:21:43,578 --> 01:21:44,453
תלמיד: [לא ברור].

2065
01:21:44,453 --> 01:21:46,660

2066
01:21:46,660 --> 01:21:47,161
>> דווין: מה?

2067
01:21:47,161 --> 01:21:49,493
רוב: אני רואה אם ​​זה סוג
לצפייה של מכאן.

2068
01:21:49,493 --> 01:21:50,040
דווין: האם זה?

2069
01:21:50,040 --> 01:21:52,500
רוב: אני לא חושב שזה going-- אני חושב ש
זה הולך לרוץ בצד הימין.

2070
01:21:52,500 --> 01:21:53,791
דווין: אוקיי, אז אני אעשה את זה.

2071
01:21:53,791 --> 01:21:56,250
ואז אתה פשוט לשים את זה על המסך.

2072
01:21:56,250 --> 01:21:57,150
>> ROB: בסדר.

2073
01:21:57,150 --> 01:21:58,190
>> דווין: אתה רוצה להיות הסופר שלי?

2074
01:21:58,190 --> 01:21:58,600
>> ROB: כן.

2075
01:21:58,600 --> 01:21:59,100
>> דווין: נחמד.

2076
01:21:59,100 --> 01:22:01,210

2077
01:22:01,210 --> 01:22:02,727
אישור, אני יכול למחוק את זה?

2078
01:22:02,727 --> 01:22:04,188
>> סטודנט: כן.

2079
01:22:04,188 --> 01:22:05,162
>> דווין: זה כל כך קשה.

2080
01:22:05,162 --> 01:22:10,032

2081
01:22:10,032 --> 01:22:12,062
(שירה) אתה עושה
מה שאתה עושה.

2082
01:22:12,062 --> 01:22:14,454
ועושה את מה שאתה עושה לא.

2083
01:22:14,454 --> 01:22:14,954
בְּסֵדֶר.

2084
01:22:14,954 --> 01:22:19,790

2085
01:22:19,790 --> 01:22:22,930
>> אישור, אם אני זוכר נכון, ב
חידון RandomInt היה כמו,

2086
01:22:22,930 --> 01:22:26,190
בסדר, אני הולך לתת לך שני
מספרים, כמו וb.

2087
01:22:26,190 --> 01:22:30,380
ואני רוצה שתיתן לי
RandomInt בין המספרים האלה.

2088
01:22:30,380 --> 01:22:33,440
אז RandomInt הולך
לקחת שני אחר מספרים

2089
01:22:33,440 --> 01:22:41,690
כך RandomInt-- וזה
הולך להחזיר int.

2090
01:22:41,690 --> 01:22:42,930
>> אז מה ערך ההחזרה?

2091
01:22:42,930 --> 01:22:44,151
אני רק אמרתי לך.

2092
01:22:44,151 --> 01:22:44,650
Int, נכון?

2093
01:22:44,650 --> 01:22:46,400

2094
01:22:46,400 --> 01:22:49,260
כמו זה, ואז זה
הולך לקחת שני ints.

2095
01:22:49,260 --> 01:22:56,301
כך שזה הולך לקחת int
וint b, כמו ש.

2096
01:22:56,301 --> 01:22:58,217
אז מה הוא RandomInt
הולך לעשות הוא שזה הולך

2097
01:22:58,217 --> 01:23:02,440
לחזור כמה ערך אקראי
בין שני ערכים אלה.

2098
01:23:02,440 --> 01:23:05,140
אז זה הולך להיות גדול
מ, פחות מ b.

2099
01:23:05,140 --> 01:23:09,020
אז אני חושב שאתה כנראה יכול להניח ש
הוא קטן יותר משני הערכים.

2100
01:23:09,020 --> 01:23:12,210
אז עם אם יש לנו עסק
אקראית, מה פונקציה

2101
01:23:12,210 --> 01:23:14,825
יש לנו ראינו ש
נותן לנו דברים אקראיים?

2102
01:23:14,825 --> 01:23:15,450
תלמיד: Drand.

2103
01:23:15,450 --> 01:23:16,506
דווין: Drand, בדיוק.

2104
01:23:16,506 --> 01:23:18,630
אז אתה הולך כנראה
רוצה להשתמש drand שלך.

2105
01:23:18,630 --> 01:23:19,940

2106
01:23:19,940 --> 01:23:29,160
אז אתה יכול לומר אקראי int, ואנו
רק אומר את זה שווה 0 עכשיו.

2107
01:23:29,160 --> 01:23:30,170

2108
01:23:30,170 --> 01:23:38,690
והם אנחנו הולכים להגיד,
אישור, שווים אקראיים drand 48.

2109
01:23:38,690 --> 01:23:39,747

2110
01:23:39,747 --> 01:23:40,830
ומה משמעות של זה יחזור?

2111
01:23:40,830 --> 01:23:43,742
מה פונקציה זו נותנת לך?

2112
01:23:43,742 --> 01:23:45,610
>> תלמיד: בין 0 ל -1.

2113
01:23:45,610 --> 01:23:47,870
>> דווין: כן, בין 0 ל -1.

2114
01:23:47,870 --> 01:23:48,890
אז זה הולך be--

2115
01:23:48,890 --> 01:23:51,070
>> ROB: וזה is-- אני חושב ש
היינו אומר לך את זה.

2116
01:23:51,070 --> 01:23:52,670
כמו, אתה יכול להשתמש בdrand 48.

2117
01:23:52,670 --> 01:23:54,350
אתה יכול לאמת את זה בבחינה האחרונה.

2118
01:23:54,350 --> 01:23:56,720
אבל אנחנו כנראה היינו אומרים לך
ניתן להשתמש drand 48, ש

2119
01:23:56,720 --> 01:23:58,790
חוזר לצוף בין 0 ל -1.

2120
01:23:58,790 --> 01:24:00,830
>> דווין: כן, כן, אני
די בטוח בבחינה

2121
01:24:00,830 --> 01:24:03,860
זה אומר שכנראה לא
רוצה להשתמש drand, כן.

2122
01:24:03,860 --> 01:24:07,041
כך שזה הולך לחזור
ערך כלשהו בין 0 ל -1.

2123
01:24:07,041 --> 01:24:08,790
ואז מה אתה
הולך רוצה לעשות?

2124
01:24:08,790 --> 01:24:16,360
ובכן, אתה רוצה להכפיל by--
לחכות, אני חושב שזה ככה, מצטער.

2125
01:24:16,360 --> 01:24:18,018
אני פשוט אעשה את זה.

2126
01:24:18,018 --> 01:24:19,410
אֲנִי לֹא יוֹדֵעַ.

2127
01:24:19,410 --> 01:24:22,240
>> אז ב מינוס.

2128
01:24:22,240 --> 01:24:23,310

2129
01:24:23,310 --> 01:24:24,490
אז למה ב מינוס?

2130
01:24:24,490 --> 01:24:26,110

2131
01:24:26,110 --> 01:24:30,490
אז בואו נגיד שdrand נותן לך בחזרה
אישור int--, אני פשוט אעשה את השאר,

2132
01:24:30,490 --> 01:24:33,380
כך בתוספת.

2133
01:24:33,380 --> 01:24:36,130
אז מה does-- y הוא ב מינוס.

2134
01:24:36,130 --> 01:24:40,670
אז בואו נגיד שdrand שנותן לך בחזרה
הערך המרבי שהוא יכול לנסוע

2135
01:24:40,670 --> 01:24:41,410
לתת לך.

2136
01:24:41,410 --> 01:24:42,409
מה שהולך להיות?

2137
01:24:42,409 --> 01:24:43,010
תלמיד: 1.

2138
01:24:43,010 --> 01:24:44,430
>> דווין: 1, נכון?

2139
01:24:44,430 --> 01:24:47,880
אז אם זה 1, ואתה
הכפלתו ב מינוס,

2140
01:24:47,880 --> 01:24:50,110
טוב, זה פשוט
הבדל בין א 'מינוס

2141
01:24:50,110 --> 01:24:52,870
ואם לאחר מכן להוסיף ש
חזרה ל, זה מה?

2142
01:24:52,870 --> 01:24:54,290

2143
01:24:54,290 --> 01:24:55,180
זה בעצם b.

2144
01:24:55,180 --> 01:24:56,435

2145
01:24:56,435 --> 01:24:57,310
האם זה הגיוני?

2146
01:24:57,310 --> 01:24:57,851
>> סטודנט: כן.

2147
01:24:57,851 --> 01:24:59,480

2148
01:24:59,480 --> 01:25:02,170
>> דווין: אז אם זה המקסימום
מעריך אולי זה יכול להיות,

2149
01:25:02,170 --> 01:25:03,175
זה הולך להיות 1.

2150
01:25:03,175 --> 01:25:04,122

2151
01:25:04,122 --> 01:25:06,330
ואז זה פשוט
הבדל בין שתיים.

2152
01:25:06,330 --> 01:25:11,410
הוסף על, אז זה
הולך לחזור אקראי.

2153
01:25:11,410 --> 01:25:15,000

2154
01:25:15,000 --> 01:25:18,620
ובמקרה הפינה ש
drand נותן לך בחזרה 1,

2155
01:25:18,620 --> 01:25:20,970
אקראי פשוט תהיה ביעילות להיות ב'.

2156
01:25:20,970 --> 01:25:22,700
אבל זה המקסימום שהוא יכול להיות.

2157
01:25:22,700 --> 01:25:27,420
אז אם זה הולך להיות פחות מ
ש, אז בואו נגיד ש כמו 0.9,

2158
01:25:27,420 --> 01:25:31,080
אז מינוס ב 0.9 פעמים
הולך להיות פחות

2159
01:25:31,080 --> 01:25:33,230
מההפרש בין מינוס b.

2160
01:25:33,230 --> 01:25:35,830
>> ואז אם אתה מוסיף ש
ל, אז הערך ש

2161
01:25:35,830 --> 01:25:38,986
הולך להיות גדול יותר מאשר, כי
אתה מוסיף משהו על זה,

2162
01:25:38,986 --> 01:25:40,360
אבל זה הולך להיות פחות מ b.

2163
01:25:40,360 --> 01:25:41,430

2164
01:25:41,430 --> 01:25:44,420
אז אתה הולך לקבל אקראי
מספר, כי את קוראת drand.

2165
01:25:44,420 --> 01:25:48,000
והראנד ש, שהמספר האקראי הוא
הולך להיות איפשהו באמצע

2166
01:25:48,000 --> 01:25:49,342
וb.

2167
01:25:49,342 --> 01:25:50,780
האם זה הגיוני?

2168
01:25:50,780 --> 01:25:52,990
>> ROB: רק כדי לשים את זה
מספרים קונקרטיים, כך

2169
01:25:52,990 --> 01:25:55,450
נניח שאנו רוצים לקחת
מספר אקראי בין 7 ו -10.

2170
01:25:55,450 --> 01:25:56,960
אז מינוס b הוא הטווח שלנו.

2171
01:25:56,960 --> 01:26:00,150
אז יש מגוון של שלוש
מספרים שאנחנו רוצים לבחור.

2172
01:26:00,150 --> 01:26:03,290
ולאחר מכן הכפלה
שבין 0 ל -1 1,

2173
01:26:03,290 --> 01:26:07,430
אם כי אז נותן לנו some--
נניח שנותנת לנו 1.5.

2174
01:26:07,430 --> 01:26:10,670
>> אז 1.5, אנחנו רוצים ללכת 7-10.

2175
01:26:10,670 --> 01:26:14,470
אז 1.5 בתוספת 7 מביא אותנו
בחזרה ל7-10 הטווח שלנו.

2176
01:26:14,470 --> 01:26:17,580
ואז אנחנו לאחסן אותו בתוך
מספר שלם, כך שזה מקוצץ ל -8.

2177
01:26:17,580 --> 01:26:18,790
ואז אנחנו פשוט לחזור כי.

2178
01:26:18,790 --> 01:26:21,310
אז מינוס b הוא הטווח שלנו.

2179
01:26:21,310 --> 01:26:25,770
משמרות אותו למספרים
שאנחנו רוצים בטווח ש.

2180
01:26:25,770 --> 01:26:30,540
אז בין 7 ו -10, ולאחר מכן אנו
יכול להחזיר את מה שאנחנו בסופו של דבר עם.

2181
01:26:30,540 --> 01:26:32,684
>> דווין: כן, נחמד.

2182
01:26:32,684 --> 01:26:34,470
>> ROB: תודה לך.

2183
01:26:34,470 --> 01:26:35,628
>> דווין: כן, מה קורה?

2184
01:26:35,628 --> 01:26:39,746
>> תלמיד: האם אנחנו מפעילים אותו לכל סוג של
שגיאות ASCII כאשר we're-- אם drand הוא

2185
01:26:39,746 --> 01:26:40,996
חוזר לצוף [לא ברור].

2186
01:26:40,996 --> 01:26:42,470

2187
01:26:42,470 --> 01:26:45,360
>> רוב: אז בדיוק כמו רוב אמר,
כי אקראי הוא לא int,

2188
01:26:45,360 --> 01:26:47,080
כך drand יהיה לצוף.

2189
01:26:47,080 --> 01:26:48,470
אז ואז זה מכפיל את.

2190
01:26:48,470 --> 01:26:50,507
ואתה יכול לקבל איזו
סוג של מספרים לצוף.

2191
01:26:50,507 --> 01:26:51,840
ואז זה הולך לחתוך.

2192
01:26:51,840 --> 01:26:52,339
>> תלמיד: אישור.

2193
01:26:52,339 --> 01:26:53,019
דווין: כן.

2194
01:26:53,019 --> 01:26:56,060
רוב: ואם מהדר היה להזהיר
לך על, כמו, אובדן של דיוק,

2195
01:26:56,060 --> 01:26:58,986
רק זרקתי int ב
שם, ואז זה טוב.

2196
01:26:58,986 --> 01:27:00,398

2197
01:27:00,398 --> 01:27:00,898
דווין: כן?

2198
01:27:00,898 --> 01:27:02,332

2199
01:27:02,332 --> 01:27:04,722
>> תלמיד: האם יש לו
הסתברות זהה מקבל,

2200
01:27:04,722 --> 01:27:06,156
כמו, B או [לא ברור]?

2201
01:27:06,156 --> 01:27:08,080

2202
01:27:08,080 --> 01:27:10,980
>> רוב: אז is-- אני בעצם
wondering-- הוא RandomInt הניח כי

2203
01:27:10,980 --> 01:27:14,362
להיות מספר מפחות מ b?

2204
01:27:14,362 --> 01:27:16,820
כמו, אם זה בין 7 ו
10, מה הן האפשרויות?

2205
01:27:16,820 --> 01:27:18,454
7, 8, ו -9, או 7, 8, 9, 10?

2206
01:27:18,454 --> 01:27:19,120
דווין: אני שוכח.

2207
01:27:19,120 --> 01:27:19,880
על set-- הבעיה

2208
01:27:19,880 --> 01:27:20,570
>> רוב: אני חושב שזה 7, 8, 9.

2209
01:27:20,570 --> 01:27:22,785
>> דווין: זה דווקא אומר אחד של
כולל ואחד של בלעדי.

2210
01:27:22,785 --> 01:27:23,110
>> ROB: כן.

2211
01:27:23,110 --> 01:27:23,670
>> דווין: אבל אני don't-- אני not--

2212
01:27:23,670 --> 01:27:25,878
>> רוב: אז אני חושב שאלו הוא
לא נכלל, ובמקרה זה,

2213
01:27:25,878 --> 01:27:28,152
יש שווה
הסתברות של 7, 8, ו -9.

2214
01:27:28,152 --> 01:27:29,360
אין הסתברות של 10.

2215
01:27:29,360 --> 01:27:31,770

2216
01:27:31,770 --> 01:27:32,270
דווין: כן?

2217
01:27:32,270 --> 01:27:33,395
תלמיד: יש לי שאלה.

2218
01:27:33,395 --> 01:27:38,090
אנחנו רוצים להגדיר פונקציה
חוזר לא ערך אחד, אבל מערך.

2219
01:27:38,090 --> 01:27:41,020
אז מה יהיה
תחביר לחזור אחרי?

2220
01:27:41,020 --> 01:27:44,604
>> דווין: אוקיי, אז אז אתה
would-- לאחר חזרה?

2221
01:27:44,604 --> 01:27:47,020
אז בואו נגיד שאתה הכריז
מערך איפשהו שם למעלה.

2222
01:27:47,020 --> 01:27:49,708
אז היית לחזור רק
שמו של המערך.

2223
01:27:49,708 --> 01:27:50,676
>> תלמיד: בסדר, תודה.

2224
01:27:50,676 --> 01:27:51,718
לאחר מכן פשוט לחזור עם a--

2225
01:27:51,718 --> 01:27:52,759
דווין: אה רגע, כל כך מצטער.

2226
01:27:52,759 --> 01:27:54,620
השאלה הייתה איך
אתה להחזיר מערך.

2227
01:27:54,620 --> 01:27:56,170
>> ROB: למרות שזה לא יכול
יוכרז מערך

2228
01:27:56,170 --> 01:27:57,260
על הערימה או משהו כזה.

2229
01:27:57,260 --> 01:27:59,510
זה היה צריך להיות משהו
malloced, כי malloc

2230
01:27:59,510 --> 01:28:01,610
איך אתה מקבל סביב
הקצאת זיכרון אוטומטית.

2231
01:28:01,610 --> 01:28:02,109
>> דווין: כן.

2232
01:28:02,109 --> 01:28:03,433

2233
01:28:03,433 --> 01:28:04,933
רוב: איך אתה מקבל סביב היקף מקומי.

2234
01:28:04,933 --> 01:28:09,670

2235
01:28:09,670 --> 01:28:11,550
>> דווין: אבל שהיית
רק לחזור name--

2236
01:28:11,550 --> 01:28:17,890
>> תלמיד: זה [לא ברור] לא אחד
ערך, למשל, שני מספרים, כך

2237
01:28:17,890 --> 01:28:18,390
[לא ברור].

2238
01:28:18,390 --> 01:28:19,590
>> דווין: אתה לא יכול להחזיר את המספר מרובה.

2239
01:28:19,590 --> 01:28:20,850
אתה לא יכול, כמו, return--

2240
01:28:20,850 --> 01:28:23,630
>> תלמיד: אני דיברתי על החזרת
מערך או משהו כזה.

2241
01:28:23,630 --> 01:28:26,050
>> דווין: כן, אז השאלה היא
אני יכול לחזור ערכים מרובים.

2242
01:28:26,050 --> 01:28:27,460
אתה לא יכול להחזיר ערכים מרובים.

2243
01:28:27,460 --> 01:28:30,270
אתה לא יכול, כמו, לחזור לאחר מכן
לחזור ב או משהו כזה.

2244
01:28:30,270 --> 01:28:32,710
כי אחרי שאתה חוזר, אתה
לחזור מהפונקציה.

2245
01:28:32,710 --> 01:28:35,790
ואז הפונקציה נעשה, ו
כמו רוב אמר, הוא בערימה.

2246
01:28:35,790 --> 01:28:38,260
>> אז כל זיכרון שרק מקבל
חזר למחשב.

2247
01:28:38,260 --> 01:28:40,025
שוכח מה שהיה, בעצם.

2248
01:28:40,025 --> 01:28:41,480

2249
01:28:41,480 --> 01:28:44,430
אז אם אתה רוצה לחזור מרובה
ערכים, אתה צריך להחזיר מערך,

2250
01:28:44,430 --> 01:28:45,971
והדרך בה אתה עושה את זה היא mallocing.

2251
01:28:45,971 --> 01:28:48,780
ואז היית חוזר x כמו ש.

2252
01:28:48,780 --> 01:28:50,280
בעיקרון, אתה פשוט תחזיר את השם.

2253
01:28:50,280 --> 01:28:51,620
וכאשר אתה חוזר
משהו כזה, אתה

2254
01:28:51,620 --> 01:28:53,200
לא ממש חוזר הערך.

2255
01:28:53,200 --> 01:28:55,430
>> אז בואו נגיד שאתה מאוחסן
הערכים במערך.

2256
01:28:55,430 --> 01:28:57,910
אתה לא באמת
חוזר את הערכים האלה.

2257
01:28:57,910 --> 01:29:01,515
כמו, אם אחזור int, אני
באמת חוזר עותקים של הערכים.

2258
01:29:01,515 --> 01:29:02,017

2259
01:29:02,017 --> 01:29:03,850
אבל אם הייתי צריך לחזור
משהו כזה,

2260
01:29:03,850 --> 01:29:06,450
אני מחזיר התייחסות
לערכים אלו.

2261
01:29:06,450 --> 01:29:09,090
אז, אני חוזר בעצם,
כתובת זיכרון לערכים.

2262
01:29:09,090 --> 01:29:10,079
האם זה הגיוני?

2263
01:29:10,079 --> 01:29:10,620
סטודנט: כן.

2264
01:29:10,620 --> 01:29:11,120
דווין: נחמד.

2265
01:29:11,120 --> 01:29:12,760

2266
01:29:12,760 --> 01:29:13,410
כן?

2267
01:29:13,410 --> 01:29:15,430
>> תלמיד: כשאתה
באמצעות drand כאן,

2268
01:29:15,430 --> 01:29:17,660
אתה צריך לשים את srand לפני זה?

2269
01:29:17,660 --> 01:29:20,320
>> דווין: לא, לא, אני לא חושב כך.

2270
01:29:20,320 --> 01:29:23,040
>> ROB: כן, אז יש לך
לומר משהו על srand?

2271
01:29:23,040 --> 01:29:26,900
ברירת המחדל שלך אף פעם לא אומר srand
בכל הוא רק כדי לעשות srand של null.

2272
01:29:26,900 --> 01:29:29,350
אז drand על עבודת הרצון משלו.

2273
01:29:29,350 --> 01:29:33,759
וזה יהיה באופן אוטומטי לזרוע עם
הזמן הנוכחי, הוא מה שהיא עושה שימוש.

2274
01:29:33,759 --> 01:29:35,175

2275
01:29:35,175 --> 01:29:35,675
דווין: כן?

2276
01:29:35,675 --> 01:29:40,950
תלמיד: האם אתה [לא ברור]
עם המספרים?

2277
01:29:40,950 --> 01:29:42,570
דווין: כן, אתה יכול.

2278
01:29:42,570 --> 01:29:46,770
תלמיד: אז אתה יכול
אומר, כמו, 4 פעמים 2.

2279
01:29:46,770 --> 01:29:50,280
העניין הוא, שאתה לא יכול להניח
אז int הוא ארבעה בתים.

2280
01:29:50,280 --> 01:29:51,020
Only--

2281
01:29:51,020 --> 01:29:53,830
>> דווין: אני מתכוון, לחידון שאתה יכול.

2282
01:29:53,830 --> 01:29:54,830
[צוחק]

2283
01:29:54,830 --> 01:29:55,780
>> ROB: ממ, לא.

2284
01:29:55,780 --> 01:29:56,780
דווין: כן, כן אתה יכול.

2285
01:29:56,780 --> 01:30:00,197
אם אשאל אותך כמה גדול int הוא,
אתה לא יכול להיות, כמו, ארבע או שמונה.

2286
01:30:00,197 --> 01:30:02,030
רוב: אה, אז אם
שאלה היא באופן ספציפי,

2287
01:30:02,030 --> 01:30:04,857
כמו, אם מדוברים בבעיה הקידוד,
אתה צריך להגיד גודל של int.

2288
01:30:04,857 --> 01:30:06,690
אם זה שולחן, או
זה אומר כמה בתים,

2289
01:30:06,690 --> 01:30:08,808
אתה לא צריך למלא בגודל של ints.

2290
01:30:08,808 --> 01:30:11,278
>> סטודנטים: [צוחק]

2291
01:30:11,278 --> 01:30:18,210

2292
01:30:18,210 --> 01:30:20,580
>> דווין: נכון, אז למה הוא
גודל של int החשוב כאן?

2293
01:30:20,580 --> 01:30:23,085
אז כמו, אם אנחנו הולכים ל32-bit
מעבד או משהו כזה,

2294
01:30:23,085 --> 01:30:24,300
אז זה הולך להיות ארבעה בתים.

2295
01:30:24,300 --> 01:30:26,342
אבל בחלק מחדש יותר
דברים, זה יכול להיות מה?

2296
01:30:26,342 --> 01:30:27,383
זה יכול להיות שמונה, נכון?

2297
01:30:27,383 --> 01:30:30,550
אז זה-- אם אתה רק קוד קשה ארבעה,
אז על כמה מכונות, זה יעבוד.

2298
01:30:30,550 --> 01:30:32,180
כמה מכונות, זה לא יעבוד.

2299
01:30:32,180 --> 01:30:35,270
אבל אם על החידון אנחנו
כמו עד כמה גדול הוא int?

2300
01:30:35,270 --> 01:30:35,770
שים ארבעה.

2301
01:30:35,770 --> 01:30:38,710

2302
01:30:38,710 --> 01:30:39,210
ROB: נכון.

2303
01:30:39,210 --> 01:30:39,790
דווין: כן?

2304
01:30:39,790 --> 01:30:43,192
תלמיד: אז בגלל שאנחנו מכריזים
[לא ברור] בתוך פונקציה,

2305
01:30:43,192 --> 01:30:45,622
אנחנו צריכים לשים 3 בתוך הפונקציה ש?

2306
01:30:45,622 --> 01:30:46,907
או שאנחנו יכולים להשתמש בו בחוץ?

2307
01:30:46,907 --> 01:30:48,740
דווין: אתה יכול להשתמש בו
מחוץ לתפקיד ש.

2308
01:30:48,740 --> 01:30:49,890
אז הוא שואל את בחינם.

2309
01:30:49,890 --> 01:30:51,700
>> תלמיד: לרדת במסלול
היכן [לא ברור].

2310
01:30:51,700 --> 01:30:54,720
>> רוב: אה, החופשי אינו happen--
זה חלק מהקסם של malloc

2311
01:30:54,720 --> 01:30:57,220
הוא שאתה לא
מוגבל להיקף מקומי.

2312
01:30:57,220 --> 01:31:00,700
יש לך שליטה מלאה על
כמה זמן המשתנים שלך לחיות.

2313
01:31:00,700 --> 01:31:05,380
אז אנחנו קוראים malloc כאן, אולי זה
להיות פונקציה נפרדת לחלוטין.

2314
01:31:05,380 --> 01:31:08,670
זה יכול להיות 10 שעות מאוחר יותר
שסוף סוף להתקשר חינם.

2315
01:31:08,670 --> 01:31:11,764
>> דווין: כך למשל, כמו, כמה
שבועות מהיום כאשר אתה סוף סוף

2316
01:31:11,764 --> 01:31:13,680
לעשות איות המילון שלך
psets, אתה הולך

2317
01:31:13,680 --> 01:31:16,410
יש כמה פונקציה ש
יוצר טונות של בלוטות.

2318
01:31:16,410 --> 01:31:18,630
אז אתה mallocing טון
צמתים בפונקציה זו.

2319
01:31:18,630 --> 01:31:20,670
ואחר-כך ב
פונקציה נפרדת, אתה

2320
01:31:20,670 --> 01:31:22,440
הולך רוצה לשחרר את כל אותם צמתים.

2321
01:31:22,440 --> 01:31:25,740
כך שאתה יכול, פשוטו כמשמעו, רק לעבור ל
לשחרר את מצביע, ולכן כתובת זיכרון

2322
01:31:25,740 --> 01:31:26,684
למה שאתה malloced.

2323
01:31:26,684 --> 01:31:27,600
ושיהיה בסדר.

2324
01:31:27,600 --> 01:31:29,725
אתה לא חייב לשחרר,
כמו, באותו התפקיד.

2325
01:31:29,725 --> 01:31:30,449
כן?

2326
01:31:30,449 --> 01:31:36,197
>> תלמיד: אז malloc
משתנה [לא ברור] בחוץ?

2327
01:31:36,197 --> 01:31:37,384
האם זה מה שאתה אומר?

2328
01:31:37,384 --> 01:31:38,300
דווין: המתן, אומר את זה?

2329
01:31:38,300 --> 01:31:38,800
מצטער.

2330
01:31:38,800 --> 01:31:42,300
>> תלמיד: אם משתנה malloc
יכול להיות חופשי בכל מקום בקוד,

2331
01:31:42,300 --> 01:31:44,800
אז הם יכולים לגשת
בכל מקום בקוד?

2332
01:31:44,800 --> 01:31:45,800
אתה יכול לשמור אותם מקומי?

2333
01:31:45,800 --> 01:31:47,880
>> דווין: אה, היא שאלה,
כמו, משתנה, like--

2334
01:31:47,880 --> 01:31:51,300

2335
01:31:51,300 --> 01:31:55,510
>> רוב: אז אתה עדיין צריך
יש סוג מסוים של התייחסות

2336
01:31:55,510 --> 01:31:57,220
לבלוק של malloc של זיכרון.

2337
01:31:57,220 --> 01:31:58,540
אז הנה, אנחנו חוזרים x.

2338
01:31:58,540 --> 01:31:59,040
תלמיד: אה.

2339
01:31:59,040 --> 01:32:01,920
ROB: אם אנחנו לא חזרנו x
כאן, וזה היו פשוט חלל,

2340
01:32:01,920 --> 01:32:04,550
אז לא תהיה לנו גישה ל
המצביע שmalloced,

2341
01:32:04,550 --> 01:32:05,920
וזה דלף זיכרון.

2342
01:32:05,920 --> 01:32:06,690
>> תלמיד: אישור.

2343
01:32:06,690 --> 01:32:10,010
>> דווין: אז כמו, נניח שאתה
יש לי זה, כמו, ממש כאן.

2344
01:32:10,010 --> 01:32:10,510
רוב: מס '

2345
01:32:10,510 --> 01:32:13,430
דווין: בפונקציה העיקרית שלי, אני לא יכול
פשוט להתקשר x זה ולהיות, כמו, אישור,

2346
01:32:13,430 --> 01:32:14,645
בפונקציה זו, שעשיתי את זה.

2347
01:32:14,645 --> 01:32:14,960
>> ROB: נכון.

2348
01:32:14,960 --> 01:32:17,790
>> דווין: אז אני הולך להתקשר x ב,
כמו, עיקרי או משהו כזה.

2349
01:32:17,790 --> 01:32:18,540
אתה לא יכול לעשות את זה.

2350
01:32:18,540 --> 01:32:19,600
אתה הולך להחזיר משהו.

2351
01:32:19,600 --> 01:32:21,000
אבל מה אתה הולך לחזור?

2352
01:32:21,000 --> 01:32:22,130
אתה הולך לחזור כתובת זיכרון.

2353
01:32:22,130 --> 01:32:25,130
ומכיוון שאתה חוזר זיכרון
כתובת, שניתן לגשת אל מקום אחר.

2354
01:32:25,130 --> 01:32:27,262

2355
01:32:27,262 --> 01:32:28,255
עוד שאלות?

2356
01:32:28,255 --> 01:32:28,755
כן?

2357
01:32:28,755 --> 01:32:31,213
>> תלמיד: האם הפונקציה הנ"ל
להיות צ'ק על [לא ברור]?

2358
01:32:31,213 --> 01:32:33,270

2359
01:32:33,270 --> 01:32:35,005
>> דווין: למה אני לא צריך לעשות את זה?

2360
01:32:35,005 --> 01:32:35,880
תלמיד: [לא ברור].

2361
01:32:35,880 --> 01:32:37,755
דווין: בגלל שאתה
לא mallocing כל דבר.

2362
01:32:37,755 --> 01:32:39,640
אז זה not-- כן, זה
לא אוהב מחרוזת s.

2363
01:32:39,640 --> 01:32:41,160
זה מצביע במקום כלשהו.

2364
01:32:41,160 --> 01:32:42,951
אלה הם רק ערכים.

2365
01:32:42,951 --> 01:32:43,450
תלמיד: אישור.

2366
01:32:43,450 --> 01:32:43,949
דווין: כן.

2367
01:32:43,949 --> 01:32:47,600

2368
01:32:47,600 --> 01:32:48,470
כל דבר אחר?

2369
01:32:48,470 --> 01:32:48,970
ROB: כן?

2370
01:32:48,970 --> 01:32:50,386
תלמיד: אבל כאשר אתה [לא ברור]?

2371
01:32:50,386 --> 01:32:55,050

2372
01:32:55,050 --> 01:32:58,690
>> רוב: אז על מנת לשחרר
זיכרון, היינו אומר כאן.

2373
01:32:58,690 --> 01:33:01,350
אז x הוא המצביע שלנו
הבלוק של זיכרון.

2374
01:33:01,350 --> 01:33:02,845
אנו משחררים מצביע ש.

2375
01:33:02,845 --> 01:33:04,470
ולא היינו בהכרח לעשות את זה כאן.

2376
01:33:04,470 --> 01:33:05,390
אנחנו יכולים לעשות את זה בכל מקום.

2377
01:33:05,390 --> 01:33:10,400
אבל אתה קורא רק בחינם ב
משהו שmalloc מחזירה.

2378
01:33:10,400 --> 01:33:12,940
אז malloc, כאן חזר,
מה שמאוחסן בx.

2379
01:33:12,940 --> 01:33:14,802
כדי שנוכל להתקשר חינם על x.

2380
01:33:14,802 --> 01:33:18,730

2381
01:33:18,730 --> 01:33:20,556
כל שאלות האחרונות?

2382
01:33:20,556 --> 01:33:21,701
>> דווין: כל שאלות שעברה?

2383
01:33:21,701 --> 01:33:22,200
כן?

2384
01:33:22,200 --> 01:33:25,152
>> תלמיד: מצטער, אתה יכול מחדש להסביר
למה אתה תשחרר את שם?

2385
01:33:25,152 --> 01:33:26,630
למה [לא ברור]?

2386
01:33:26,630 --> 01:33:27,774
>> דווין: לכאן?

2387
01:33:27,774 --> 01:33:29,109
>> תלמיד: כן, כמו מייד אחרי.

2388
01:33:29,109 --> 01:33:30,900
דווין: אתה כנראה
לא רוצה בחינם כאן.

2389
01:33:30,900 --> 01:33:31,630
ROB: אתה כנראה לא היית.

2390
01:33:31,630 --> 01:33:33,060
דווין: כן, כי זה לא יעשה דבר.

2391
01:33:33,060 --> 01:33:35,220
זה היה, כמו, ליצור
זיכרון, לעשות את הדברים אליו,

2392
01:33:35,220 --> 01:33:37,390
ולאחר מכן באופן מיידי
תשכח מזה, כן.

2393
01:33:37,390 --> 01:33:39,850
>> ROB: אבל אנחנו יכולים לעשות, כמו,
כאן מסיבה כלשהי.

2394
01:33:39,850 --> 01:33:43,902
אפשר לומר כוכב int
y שווה מערך תמורה.

2395
01:33:43,902 --> 01:33:47,900
לעשות כמה דברים עם Y,
אולי להדפיס את התוכן.

2396
01:33:47,900 --> 01:33:49,350
ואז, סוף סוף, שנסיים.

2397
01:33:49,350 --> 01:33:50,626
אנחנו יכולים לשחרר את y.

2398
01:33:50,626 --> 01:33:51,501
תלמיד: [לא ברור].

2399
01:33:51,501 --> 01:33:57,839

2400
01:33:57,839 --> 01:33:59,005
דווין: אני צריך לגלול למטה?

2401
01:33:59,005 --> 01:34:00,445
תודה.

2402
01:34:00,445 --> 01:34:00,945
ROB: נחמד.

2403
01:34:00,945 --> 01:34:02,400

2404
01:34:02,400 --> 01:34:03,646
>> דווין: אישור, זה הכל.

2405
01:34:03,646 --> 01:34:04,520
ROB: בסדר, טוב.

2406
01:34:04,520 --> 01:34:05,070
מזל טוב.

2407
01:34:05,070 --> 01:34:06,800
>> דווין: אם יש לך שאלות, שלח לנו דוא"ל.

2408
01:34:06,800 --> 01:34:08,670
מזל טוב.

2409
01:34:08,670 --> 01:34:10,283