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

2
00:00:03,944 --> 00:00:10,732

3
00:00:10,732 --> 00:00:11,690
DAVID מלאן: בסדר.

4
00:00:11,690 --> 00:00:14,674
זה CS50, וזה
הוא סוף השבוע 2.

5
00:00:14,674 --> 00:00:16,840
אני כל כך מצטער שלא יכולתי להיות
יש איתך את כל היום,

6
00:00:16,840 --> 00:00:18,300
אבל אתה בידיים טובות מאוד.

7
00:00:18,300 --> 00:00:21,710
הרשה לי להציג
של רוב אודן של CS50.

8
00:00:21,710 --> 00:00:29,106

9
00:00:29,106 --> 00:00:31,730
ROB אודן: וכמובן, לאחר מכן
אנחנו צריכים לעשות את הכיף של העובדה

10
00:00:31,730 --> 00:00:36,820
שהוא שלח לנו אנכי
וידאו ולהראות את זה.

11
00:00:36,820 --> 00:00:38,320
>> [וידאו השמעה]

12
00:00:38,320 --> 00:00:39,820
>> [השמעת מוסיקה]

13
00:00:39,820 --> 00:00:42,350
>> [בעקבות]

14
00:00:42,350 --> 00:00:44,730
>> וידאו -זהו לא
צריך להסתכל בדרך זו.

15
00:00:44,730 --> 00:00:46,570
זה היה יכול להימנע.

16
00:00:46,570 --> 00:00:49,070
אומר לא לקטעי וידאו אנכיים.

17
00:00:49,070 --> 00:00:53,310
>> קטעי וידאו -Vertical לקרות כאשר אתה
להחזיק את המצלמה שלך בדרך הלא נכונה.

18
00:00:53,310 --> 00:00:55,880
הווידאו שלך יהיה בסופו
דבר נראה כמו זבל.

19
00:00:55,880 --> 00:00:57,650
>> - [רטינה]

20
00:00:57,650 --> 00:01:02,240
>> : רווחה הם יותר ויותר אנשים מכורים
לביצוע קטעי וידאו אנכי בכל יום.

21
00:01:02,240 --> 00:01:06,240
זה לא סדק או כלום,
אבל זה עדיין ממש רע.

22
00:01:06,240 --> 00:01:10,410
ישנם שני סוגים של שונים
אנשים שסובלים מVVS.

23
00:01:10,410 --> 00:01:14,160
הקבוצה הראשונה מתייחסת ל
קטעי וידאו שהם יורים כמו תמונות.

24
00:01:14,160 --> 00:01:15,850
הם לא מתכוונים לשום נזק.

25
00:01:15,850 --> 00:01:19,180
הם פשוט לא מבינים ש
בזמן שאתה יכול להפוך את תמונה,

26
00:01:19,180 --> 00:01:20,880
אתה לא באמת יכול להפוך את וידאו.

27
00:01:20,880 --> 00:01:21,880
>> [CRASH]

28
00:01:21,880 --> 00:01:23,460
>> - [MONKEY צלילים]

29
00:01:23,460 --> 00:01:27,540
>> בחור' קבוצה אחרת היא אנשים
שלא נותן [בליפ].

30
00:01:27,540 --> 00:01:31,090
>> תסמונת וידאו -Vertical היא מסוכנת.

31
00:01:31,090 --> 00:01:34,120
יש לי קולנוע
תמיד היה אופקי.

32
00:01:34,120 --> 00:01:35,990
טלוויזיות הן אופקיים.

33
00:01:35,990 --> 00:01:38,380
מסכי מחשב הם אופקיים.

34
00:01:38,380 --> 00:01:41,580
העיניים של אנשים הן אופקיים.

35
00:01:41,580 --> 00:01:45,170
אנחנו לא בנויים ל
לצפות בקטעי וידאו אנכיים.

36
00:01:45,170 --> 00:01:47,600
>> -אני אוהב את קטעי וידאו אנכיים.

37
00:01:47,600 --> 00:01:50,410
>> -לא אכפת לך.

38
00:01:50,410 --> 00:01:53,340
>> -אם של בעיה זו
עזב, אתה גם לא בדוק

39
00:01:53,340 --> 00:01:57,650
יתחיל להראות ארבעה קטעי וידאו
בבת אחת, רק כדי לחסוך ברוחב פס.

40
00:01:57,650 --> 00:02:02,400
>> קטעי וידאו אנכיים -Letterboxed היית
להיות בגודל של בול דואר.

41
00:02:02,400 --> 00:02:04,920
>> -ואז זה יתפשט בכל מקום.

42
00:02:04,920 --> 00:02:07,670
יש מסכי קולנוע
תמיד היה אופקי.

43
00:02:07,670 --> 00:02:11,200
אם קטעי וידאו אנכיים הפכו
תיאטראות מקובלים, סרט

44
00:02:11,200 --> 00:02:13,930
יצטרך להיות גבוה ורזה.

45
00:02:13,930 --> 00:02:17,710
>> -ואז כל בתי הקולנוע היית
צריכה לקבל נהרסו ונבנה מחדש.

46
00:02:17,710 --> 00:02:22,090
ועד שהם נבנו מחדש,
המילה קוניס יהיה זקן ומכוער.

47
00:02:22,090 --> 00:02:24,342
>> -Birds יתרסק לתוכם ולמות.

48
00:02:24,342 --> 00:02:26,530
>> כל החדים לקבל נוקשה
צוואר ממבטו.

49
00:02:26,530 --> 00:02:29,800
>> -ואז אף אחד לא יושב ב
השורה הראשונה אי פעם שוב.

50
00:02:29,800 --> 00:02:37,170
>> -George לוקאס מחדש שחרור כוכבים
מלחמות again-- המהדורה רזה.

51
00:02:37,170 --> 00:02:41,860
>> -אני אף פעם לא היה באמת מסוגל להגיד לי
הסיפור שאני רוצה לספר.

52
00:02:41,860 --> 00:02:46,030
זו הייתה הזדמנות גדולה עבורי
להתנסות בטכנולוגיה חדשה.

53
00:02:46,030 --> 00:02:48,150
>> "אתה אידיוט.

54
00:02:48,150 --> 00:02:54,430
>> ם בכל זמן מכשיר נייד משמש ל
להקליט וידאו, הפיתוי הוא שם.

55
00:02:54,430 --> 00:02:56,370
פשוט תגיד לא.

56
00:02:56,370 --> 00:03:00,116
אומר לא לג'ורג 'לוקאס.

57
00:03:00,116 --> 00:03:04,062
אומר לא למילת קוניס הישן.

58
00:03:04,062 --> 00:03:06,600
אומר לא לקטעי וידאו אנכיים.

59
00:03:06,600 --> 00:03:12,511
>> : ואם אתה רואה מישהו עושה את זה, אומר,
"אתה לא יורה שדמה נכון!"

60
00:03:12,511 --> 00:03:15,433
>> [השמעת מוסיקה]

61
00:03:15,433 --> 00:03:18,842

62
00:03:18,842 --> 00:03:19,830
>> [סוף ההשמעה]

63
00:03:19,830 --> 00:03:23,702
>> [מחיאות כפות]

64
00:03:23,702 --> 00:03:27,598
>> [AUDIO OUT]

65
00:03:27,598 --> 00:03:44,041

66
00:03:44,041 --> 00:03:45,790
ROB אודן: --simple
צורה של הצפנה,

67
00:03:45,790 --> 00:03:49,500
שהוא בעצם ההצפנה
ופענוח של מסרים סודיים.

68
00:03:49,500 --> 00:03:52,590
אז הנה יש לנו צעצוע פשוט מאוד.

69
00:03:52,590 --> 00:03:56,900
והרעיון הוא הטבעת החיצונית
מסתובב סביב הטבעת הפנימית.

70
00:03:56,900 --> 00:04:01,610
ואתה יכול לראות, אולי אם אני זום
ב, לראות-- זה קשה לראות.

71
00:04:01,610 --> 00:04:05,090
אבל, כמו, המספר
1-- גם, שעבר.

72
00:04:05,090 --> 00:04:09,120
>> מספר 1 מפות למכתב
X, מספר 2 מפות למכתב

73
00:04:09,120 --> 00:04:11,630
ג 'קשה מאוד
לא לדלג קדימה.

74
00:04:11,630 --> 00:04:16,100
מכתב 2 מפות לג '
מספר 3 מפות לד אז

75
00:04:16,100 --> 00:04:20,140
בטבעת זו אתה יכול לתת לי
מישהו הודעה 1, 2, 3.

76
00:04:20,140 --> 00:04:22,624
מסיבה כלשהי אתה
רוצה לומר להם XJD.

77
00:04:22,624 --> 00:04:24,540
אבל אתה יכול לתת להם
כמה הודעה של מספרים,

78
00:04:24,540 --> 00:04:28,460
וכל עוד יש להם טבעת זו, הם
יכול לפענח את מה שאתה מנסה לומר.

79
00:04:28,460 --> 00:04:32,510
>> זה אז אתה יכול לראות
דוגמא מסוימת של הצפנה

80
00:04:32,510 --> 00:04:36,640
לפני אם סביב עונת חג המולד
אתה כבר צפה סיפור חג המולד.

81
00:04:36,640 --> 00:04:38,520
אם מעולם לא ראו
את זה לפני, אז פשוט

82
00:04:38,520 --> 00:04:41,060
להפעיל TBS באופן מילולי
כל זמן בערב חג המולד,

83
00:04:41,060 --> 00:04:44,510
כי הם פשוט להראות את זה גב אל גב
לגב אל גב אל גב כל היום.

84
00:04:44,510 --> 00:04:46,744
והווידאו הרלוונטי הוא זו.

85
00:04:46,744 --> 00:04:47,410
[וידאו השמעה]

86
00:04:47,410 --> 00:04:50,020
-Be זה ידוע לכל ומשונים
שראלף פארקר הוא זאת

87
00:04:50,020 --> 00:04:52,850
מינה את חבר של ליטל
יתום אנני מעגל סודי

88
00:04:52,850 --> 00:04:56,490
והוא זכאי לכל הכבוד
והטבות המתרחשות בם.

89
00:04:56,490 --> 00:04:59,010
חתמה היתומה הקטנה אנני.

90
00:04:59,010 --> 00:05:03,120
בתשובה פייר אנדרה בדיו!

91
00:05:03,120 --> 00:05:07,460
הצטיינות והטבות
כבר בגיל תשע!

92
00:05:07,460 --> 00:05:12,530
>> [צועק מהרדיו]

93
00:05:12,530 --> 00:05:13,030
-בחייך.

94
00:05:13,030 --> 00:05:14,000
בואו נגמור עם זה.

95
00:05:14,000 --> 00:05:18,274
אני לא צריך את כל הג'אז הזה
על מבריחים ופירטים.

96
00:05:18,274 --> 00:05:20,440
מחר בלילה עם "תשמע
ההרפתקה המסכמת

97
00:05:20,440 --> 00:05:22,540
של שחור ספינת פיראטים.

98
00:05:22,540 --> 00:05:25,460
עכשיו, זה זמן ל
המסר הסודי של אנני

99
00:05:25,460 --> 00:05:28,620
לחבריך מהמעגל הסודי.

100
00:05:28,620 --> 00:05:32,370
זכרו ילדים, רק חברים
של המעגל הסודי של אנני

101
00:05:32,370 --> 00:05:34,880
יכול לפענח המסר הסודי של אנני.

102
00:05:34,880 --> 00:05:39,100
זכרו, אנני תלויה בך.

103
00:05:39,100 --> 00:05:41,660
הגדר הסיכות שלך לB2.

104
00:05:41,660 --> 00:05:43,960
הנה ההודעה.

105
00:05:43,960 --> 00:05:44,680
12.

106
00:05:44,680 --> 00:05:45,180
11.

107
00:05:45,180 --> 00:05:45,679
2.

108
00:05:45,679 --> 00:05:48,110
'אני בפגישה החשאית הראשונה שלי.

109
00:05:48,110 --> 00:05:49,030
>> -25.

110
00:05:49,030 --> 00:05:49,834
14.

111
00:05:49,834 --> 00:05:51,040
11.

112
00:05:51,040 --> 00:05:51,854
18.

113
00:05:51,854 --> 00:05:52,670
16.

114
00:05:52,670 --> 00:05:54,570
>> אה, פייר הוא בערב קול גדול.

115
00:05:54,570 --> 00:05:57,490
אני יכול לספר לי הערב של ש
ההודעה הייתה באמת חשובה.

116
00:05:57,490 --> 00:05:57,990
-3.

117
00:05:57,990 --> 00:06:00,080
25.

118
00:06:00,080 --> 00:06:01,580
זה מסר מאנני עצמה.

119
00:06:01,580 --> 00:06:02,880
זכור, לא לספר לאף אחד.

120
00:06:02,880 --> 00:06:07,840

121
00:06:07,840 --> 00:06:11,130
>> שניות לאחר מכן -Five, אני ברק
חדר בבית שבו ילד של תשע

122
00:06:11,130 --> 00:06:15,830
יכל לשבת בפרטיות ולפענח.

123
00:06:15,830 --> 00:06:16,620
אהה!

124
00:06:16,620 --> 00:06:17,340
B!

125
00:06:17,340 --> 00:06:20,210
הלכתי למשנהו.

126
00:06:20,210 --> 00:06:23,300
א המילה הראשונה היא "להיות".

127
00:06:23,300 --> 00:06:25,880
ס זה היה הקרוב יותר עכשיו.

128
00:06:25,880 --> 00:06:28,400
ע '25.

129
00:06:28,400 --> 00:06:30,528
זה ר '

130
00:06:30,528 --> 00:06:31,278
-בחייך, ראלפי!

131
00:06:31,278 --> 00:06:31,861
אני חייב ללכת!

132
00:06:31,861 --> 00:06:33,182
"אני אקה להיות ימין למטה, אמא!

133
00:06:33,182 --> 00:06:36,038
גאון גי.

134
00:06:36,038 --> 00:06:42,840
ט O. "הקפד" - כדי להיות בטוח מה?

135
00:06:42,840 --> 00:06:44,770
מה הייתה יתומה קטנה
אנני מנסה לומר?

136
00:06:44,770 --> 00:06:46,381
הקפד מה?

137
00:06:46,381 --> 00:06:47,825
>> -Randy חייב ללכת!

138
00:06:47,825 --> 00:06:48,866
אתה מוכן בבקשה לצאת?

139
00:06:48,866 --> 00:06:49,783
>> נכון -All, אמא!

140
00:06:49,783 --> 00:06:51,786
אני אהיה מחוץ נכון!

141
00:06:51,786 --> 00:06:53,606
אני מתקרב עכשיו.

142
00:06:53,606 --> 00:06:55,550
המתח היה נורא.

143
00:06:55,550 --> 00:06:57,050
מה זה היה?

144
00:06:57,050 --> 00:06:59,905
גורלו של כדור הארץ
עלול להיתקע במאזן!

145
00:06:59,905 --> 00:07:01,736
>> -Ralphie, רנדי חייב ללכת!

146
00:07:01,736 --> 00:07:05,680
>> "אני אקה להיות תקין החוצה, בוכה בקול רם!

147
00:07:05,680 --> 00:07:07,170
כמעט שם!

148
00:07:07,170 --> 00:07:08,150
האצבעות שלי טסו.

149
00:07:08,150 --> 00:07:09,980
המוח שלי היה מלכודת פלדה.

150
00:07:09,980 --> 00:07:11,496
כל נקבובית רטט.

151
00:07:11,496 --> 00:07:13,268
זה היה כמעט ברור!

152
00:07:13,268 --> 00:07:13,767
כן.

153
00:07:13,767 --> 00:07:14,609
כן.

154
00:07:14,609 --> 00:07:15,108
כן.

155
00:07:15,108 --> 00:07:16,449
כן.

156
00:07:16,449 --> 00:07:20,240
הקפד לשתות השוקו שלך.

157
00:07:20,240 --> 00:07:20,740
שוקו?

158
00:07:20,740 --> 00:07:26,687

159
00:07:26,687 --> 00:07:27,520
מסחרי עלוב?

160
00:07:27,520 --> 00:07:32,040

161
00:07:32,040 --> 00:07:34,920
בן זונה.

162
00:07:34,920 --> 00:07:35,890
>> [סוף ההשמעה]

163
00:07:35,890 --> 00:07:39,650
>> ROB אודן: אז ככה
השוקו מתייחס להצפנה.

164
00:07:39,650 --> 00:07:42,290
בעיקרון CS50 רק מפורסם
שוקו, כדי שנוכל

165
00:07:42,290 --> 00:07:44,400
להיות מסחרי עלובה לשוקו.

166
00:07:44,400 --> 00:07:44,900
בסדר.

167
00:07:44,900 --> 00:07:47,120
אז עכשיו מדעי מחשב בפועל.

168
00:07:47,120 --> 00:07:50,670
זכרו ביום שני שעזבנו את
צלילה עמוקה לתוך מחרוזות.

169
00:07:50,670 --> 00:07:52,820
אז יש לנו עסק עם
המחרוזת "Zamyla."

170
00:07:52,820 --> 00:07:55,130
ואנחנו מכירים
העובדה שאנחנו יכולים לטפל ב

171
00:07:55,130 --> 00:07:57,510
"Zamyla" כרצף של תווים.

172
00:07:57,510 --> 00:07:59,740
וזוכר שלמדנו
סימון הסוגר.

173
00:07:59,740 --> 00:08:01,995
אז אם זה היה מאוחסן
במחרוזת "של", ולאחר מכן

174
00:08:01,995 --> 00:08:05,860
אם אמרתי התושבת של 0, שהיית
מצביע ז הון המכתב

175
00:08:05,860 --> 00:08:09,790
ואם אמרו של התושבת 1, ש
מצביע על כך שהאותיות קטנות הראשונה,

176
00:08:09,790 --> 00:08:14,220
וכך הלאה עד לסוגר של 5,
המצביע על כך שעבר.

177
00:08:14,220 --> 00:08:17,090
>> עכשיו זוכר ש
אורך של מחרוזת זו הוא 6,

178
00:08:17,090 --> 00:08:23,220
אבל המדדים למחרוזת הם
0 עד 5, Z דרך שיימשך.

179
00:08:23,220 --> 00:08:28,650
אז זה עכשיו מתאים לתמונה גדולה יותר
של זיכרון המחשב שלך, זיכרון RAM שלך.

180
00:08:28,650 --> 00:08:32,020
אז איפשהו התכנית ש
אתה מפעיל את המחשב

181
00:08:32,020 --> 00:08:34,780
צריך לזכור Zamyla
אי שם בזיכרון.

182
00:08:34,780 --> 00:08:36,029
אז יכול להיות שאני מתנדב?

183
00:08:36,029 --> 00:08:38,840

184
00:08:38,840 --> 00:08:40,181
כן בבקשה.

185
00:08:40,181 --> 00:08:50,120

186
00:08:50,120 --> 00:08:51,500
ומה שמך?

187
00:08:51,500 --> 00:08:52,410
>> דיקן: דיקן.

188
00:08:52,410 --> 00:08:53,550
>> ROB אודן: דיקן?

189
00:08:53,550 --> 00:08:54,910
נחמד לפגוש אותך, דיקן.

190
00:08:54,910 --> 00:08:58,240
אז לבוא לכאן, ו
אנחנו הולכים יש לך לצייר

191
00:08:58,240 --> 00:09:00,740
על הפריסה מגניבות נחמדה שלנו של זיכרון.

192
00:09:00,740 --> 00:09:05,950
עכשיו אני רוצה לחשוב על זיכרון
כרצועה אחת ארוכה של בתים,

193
00:09:05,950 --> 00:09:11,090
אבל רק למטרות תצוגה שנציע ב
פשוט משמאל לימין, מלמעלה למטה.

194
00:09:11,090 --> 00:09:11,590
אוקיי?

195
00:09:11,590 --> 00:09:22,030
>> אז אני הולך להראות לי
program-- Getstrings.c.

196
00:09:22,030 --> 00:09:25,760
וכך כל תכנית זו היא
עושה מבקש ארבעה מיתרים

197
00:09:25,760 --> 00:09:28,830
מהמשתמש עם
הדפסת GetString ולאחר מכן

198
00:09:28,830 --> 00:09:30,950
מה שהמחרוזת הראשונה נכנסה היה.

199
00:09:30,950 --> 00:09:32,840
אנחנו מתעלמים משני בארבעה.

200
00:09:32,840 --> 00:09:33,610
אוקיי.

201
00:09:33,610 --> 00:09:38,210
אז כאן now-- כאשר
אני S1 הבקשה הראשון.

202
00:09:38,210 --> 00:09:39,740
אז אתה המחשב.

203
00:09:39,740 --> 00:09:41,680
ואתה מיישם GetString.

204
00:09:41,680 --> 00:09:46,710
אז אתה מבקש ממחרוזת
שלי, ואני אומרים, אוקיי, דיקן.

205
00:09:46,710 --> 00:09:47,900
תן את המחרוזת "דיקן".

206
00:09:47,900 --> 00:09:50,300
>> אז אי שם בזכרונך
צריך לזכור "דין".

207
00:09:50,300 --> 00:09:52,160
אז לכתוב את זה לזיכרון למקום.

208
00:09:52,160 --> 00:09:58,270

209
00:09:58,270 --> 00:09:59,210
ללא רבב.

210
00:09:59,210 --> 00:09:59,880
אוקיי.

211
00:09:59,880 --> 00:10:01,740
אז עכשיו יש לנו S2.

212
00:10:01,740 --> 00:10:03,869
וs2 הולך להיות
בקשה לGetString.

213
00:10:03,869 --> 00:10:05,160
אז אני הולך להיכנס מחרוזת.

214
00:10:05,160 --> 00:10:08,720
אני הולך להיכנס "חנה".

215
00:10:08,720 --> 00:10:10,586
אז להיכנס "חנה" אי שם בזיכרון.

216
00:10:10,586 --> 00:10:18,860

217
00:10:18,860 --> 00:10:19,360
כן.

218
00:10:19,360 --> 00:10:23,000
-H.

219
00:10:23,000 --> 00:10:25,550
>> אוקיי, אז עכשיו S3.

220
00:10:25,550 --> 00:10:28,380
וזה הולך להיות אחר
לבקש GetString.

221
00:10:28,380 --> 00:10:37,020
ואז עכשיו להיכנס "מריה".

222
00:10:37,020 --> 00:10:37,520
בסדר.

223
00:10:37,520 --> 00:10:40,980
ואז יש אחד אחרון
בקשה לGetString, S4.

224
00:10:40,980 --> 00:10:42,580
אז, אני לא יודע.

225
00:10:42,580 --> 00:10:45,640
מה אנחנו הולכים עם
אנטי אי.

226
00:10:45,640 --> 00:10:49,460
אז להיכנס לתוך זיכרון.

227
00:10:49,460 --> 00:10:50,400
כן.

228
00:10:50,400 --> 00:10:53,970
אז פשוט לעשות "רוב".

229
00:10:53,970 --> 00:10:54,560
>> אוקיי.

230
00:10:54,560 --> 00:10:58,410
אז עכשיו explain-- מדוע עשה
אתה משאיר החללים האלה?

231
00:10:58,410 --> 00:11:01,340
למה יש לך את זה ריק
שטח כאן, כאן, וכאן?

232
00:11:01,340 --> 00:11:05,170

233
00:11:05,170 --> 00:11:05,670
כן.

234
00:11:05,670 --> 00:11:09,450
אז שם לב כשאני הולך
להדפיס s1-- כך שאם אנחנו

235
00:11:09,450 --> 00:11:11,890
הייתה ריצה "חנה"
ממש עד לצד "דיקן,"

236
00:11:11,890 --> 00:11:14,360
איך אנחנו יודעים מתי
המחרוזת "הדיקן" מסתיים?

237
00:11:14,360 --> 00:11:19,470
אז הדפסת S1 המחרוזת עשויה להיות
רק מודפס "DeanHannahMariaRob"

238
00:11:19,470 --> 00:11:22,720
אם אין לו כל מושג
כאשר "דיקן" מסתיים למעשה.

239
00:11:22,720 --> 00:11:23,240
>> בסדר.

240
00:11:23,240 --> 00:11:27,650
אז בזיכרון הדרך בה אנו למעשה
מייצג סוף זה של מחרוזת

241
00:11:27,650 --> 00:11:29,940
הוא עם קו נטוי אפס.

242
00:11:29,940 --> 00:11:32,620
אז המרחב הזה הוא בדיוק מה שרצינו.

243
00:11:32,620 --> 00:11:34,040
זה צריך להיות קו נטוי אפס.

244
00:11:34,040 --> 00:11:37,690
זה יהיה קו נטוי אפס,
וזה יהיה קו נטוי אפס.

245
00:11:37,690 --> 00:11:41,585
ואתה יכול לקבל פרס מדהים
על היותו מתנדב מושלם.

246
00:11:41,585 --> 00:11:44,910

247
00:11:44,910 --> 00:11:45,860
קח כדור מתח!

248
00:11:45,860 --> 00:11:49,040

249
00:11:49,040 --> 00:11:49,700
>> אוקיי.

250
00:11:49,700 --> 00:11:54,420
אז קו נטוי דמות הזאת הוא אפס
איך אנחנו מציינים את קצה חוט.

251
00:11:54,420 --> 00:11:57,120
זה איך כאשר כל תכנית נתונה
רוצה להדפיס מחרוזת,

252
00:11:57,120 --> 00:11:59,760
זה how-- אנו זוכר שלמדנו
פונקצית strlen בשבוע שעבר?

253
00:11:59,760 --> 00:12:00,940
אורך מחרוזת?

254
00:12:00,940 --> 00:12:03,770
זה איך אורך מחרוזת הוא מסוגל
לקבוע כמה זמן מחרוזת היא.

255
00:12:03,770 --> 00:12:05,810
זה פשוט ממשיך iterating
על הדמויות

256
00:12:05,810 --> 00:12:08,217
עד שהוא מוצא
קו נטוי אפס אופי.

257
00:12:08,217 --> 00:12:11,050
אז הדבר חשוב להבין
על אופי הקו הנטוי אפס

258
00:12:11,050 --> 00:12:14,950
הוא זה מיוצג
על ידי כל האפסים בביטים.

259
00:12:14,950 --> 00:12:18,980
אז שם לב שזה הוא מובהק
מהאופי אפס.

260
00:12:18,980 --> 00:12:23,010
אז האופי אפס, אם אתה זוכר
בדוגמא שהוא נתן בסוף

261
00:12:23,010 --> 00:12:27,360
הרצאה שבי תווי המפה
צריכה-- כמו מפות הון ל -65.

262
00:12:27,360 --> 00:12:29,130
אותיות קטנות מפות עד 97.

263
00:12:29,130 --> 00:12:30,890
ב אותיות קטנות יהיו 98.

264
00:12:30,890 --> 00:12:35,220
אז מספר 0 המפות צריכה-- אני לא
יודע את החלק העליון של הראש שלי.

265
00:12:35,220 --> 00:12:36,400
44 או 45.

266
00:12:36,400 --> 00:12:37,890
אי שם באזור זה.

267
00:12:37,890 --> 00:12:40,850
>> אז הדמות 0 הוא מספר אמיתי.

268
00:12:40,850 --> 00:12:44,350
אבל אפס קו נטוי
מפות לכל אפס הביטים.

269
00:12:44,350 --> 00:12:46,380
אז יש הבחנה
בין הקו הנטוי אפס,

270
00:12:46,380 --> 00:12:48,450
שנתקשר אל שליחות קטלנית null.

271
00:12:48,450 --> 00:12:53,210
יש הבחנה בין
קו נטוי אפס והאופי אפס.

272
00:12:53,210 --> 00:12:54,350
>> בסדר.

273
00:12:54,350 --> 00:12:57,520
אז דיבר קצת יותר על מיתרים.

274
00:12:57,520 --> 00:13:01,470
אז אנחנו רואים כאן זה איך
זה יהיה ערוך בזיכרון.

275
00:13:01,470 --> 00:13:07,940
אז הרעיון הזה של מחרוזות כרצף
של characters-- כך המחשב הרשמי

276
00:13:07,940 --> 00:13:10,750
טווח sciency לרצף הוא מערך.

277
00:13:10,750 --> 00:13:13,790
אז היינו קורא מחרוזת
מערך של תווים.

278
00:13:13,790 --> 00:13:17,770
ולמעשה יש נתונים אחרים
סוגים שאנחנו יכולים לעשות את המערכים מתוך.

279
00:13:17,770 --> 00:13:19,975
>> אז להניע זה, תסתכל על דוגמא.

280
00:13:19,975 --> 00:13:22,810

281
00:13:22,810 --> 00:13:29,812
אנחנו קוראים לזה ages0.c אני יהיה
להעתיק ולהדביק התבנית שלנו.

282
00:13:29,812 --> 00:13:32,470

283
00:13:32,470 --> 00:13:33,410
אוקיי.

284
00:13:33,410 --> 00:13:39,378
אז בתכנית זו מה ש
רוצה לעשות הוא לתפוס את הגיל

285
00:13:39,378 --> 00:13:45,160
של שלושה סטודנטים בקורס.

286
00:13:45,160 --> 00:13:49,240
אז אנחנו יודעים int age--
ועכשיו אני הולך להגיד 0.

287
00:13:49,240 --> 00:13:53,140
אז אולי כדאי לך לומר AGE1, אבל
למטרות שנראה בקרוב מאוד,

288
00:13:53,140 --> 00:13:57,187
אני אגיד age0 int שווה GetInt.

289
00:13:57,187 --> 00:13:59,270
אז אותו השיחה לGetInt
שכבר משתמשים אני

290
00:13:59,270 --> 00:14:01,561
לא יקרה לך להיות שגרם
אומר, "תן לי את הגיל."

291
00:14:01,561 --> 00:14:03,120
אבל רק מבקש אותו.

292
00:14:03,120 --> 00:14:06,510
>> וAGE1 שווה GetInt.

293
00:14:06,510 --> 00:14:09,600
וAGE2 int שווה GetInt.

294
00:14:09,600 --> 00:14:14,070
אז, שוב, שלושה תלמידים, אבל
סופו של דבר המדדים משתנים

295
00:14:14,070 --> 00:14:16,890
הם age0 דרך AGE2.

296
00:14:16,890 --> 00:14:17,550
אוקיי.

297
00:14:17,550 --> 00:14:23,960
אז התכנית הזאת תעשה כל מה
אנחנו רוצים עם age0, AGE1, וAGE2,

298
00:14:23,960 --> 00:14:27,670
אך תכנית זו סופו של דבר
עובד לשלושה תלמידים.

299
00:14:27,670 --> 00:14:28,380
>> אוקיי.

300
00:14:28,380 --> 00:14:32,110
אז עכשיו מה אם אני רוצה ארבעה תלמידים?

301
00:14:32,110 --> 00:14:36,000
ובכן, אני הולך צריך לחזור
לתוך הקוד שלי, לשנות את התגובה,

302
00:14:36,000 --> 00:14:39,840
ועכשיו יש לנו int
age3 שווה GetInt.

303
00:14:39,840 --> 00:14:40,610
אוקיי.

304
00:14:40,610 --> 00:14:43,660
אז מי רואה את הבעיה כאן?

305
00:14:43,660 --> 00:14:47,310
מה הבעיה
עם סוג זה של התקנה?

306
00:14:47,310 --> 00:14:47,810
כן.

307
00:14:47,810 --> 00:14:53,110

308
00:14:53,110 --> 00:14:53,610
כן.

309
00:14:53,610 --> 00:14:56,360
אז אנחנו יוצרים
משתנה לכל תלמיד.

310
00:14:56,360 --> 00:15:00,140
עכשיו זה עובד, אבל
סופו של דבר מה אם אני עכשיו

311
00:15:00,140 --> 00:15:06,500
אומר, "אני רוצה לתפוס את גיל
שמונה תלמידים או 16 תלמידים

312
00:15:06,500 --> 00:15:11,340
או הסטודנטים אולם רבים מן
מאות תלמידים בCS50

313
00:15:11,340 --> 00:15:16,750
או אלפי סטודנטים בקמפוס
או מיליארדי אנשים בעולם?

314
00:15:16,750 --> 00:15:19,130
אז בסופו של הדבר אינו בר-קיימא.

315
00:15:19,130 --> 00:15:21,990
כל פעם שאתה רואה את עצמך העתקה
והדבקת קוד כזה,

316
00:15:21,990 --> 00:15:25,050
אתה צריך בדרך כלל מרגיש
שיש דרך טובה יותר.

317
00:15:25,050 --> 00:15:31,290
>> אז זה המקום שבו אנחנו מציגים
הכרזת מערך.

318
00:15:31,290 --> 00:15:34,564
לכן, כאשר אתה להצהיר על מערך,
זה מה הפורמט הכללי

319
00:15:34,564 --> 00:15:35,480
הוא הולך להיראות.

320
00:15:35,480 --> 00:15:36,664
אנחנו הולכים להגיד את הסוג.

321
00:15:36,664 --> 00:15:38,830
ואז אנחנו הולכים ל
לתת את שמו של מערך זה,

322
00:15:38,830 --> 00:15:41,150
בדיוק כפי שאנו מגדירים כל משתנים נתון.

323
00:15:41,150 --> 00:15:43,980
ואז סוף סוף אנחנו משתמשים
סימון הסוגר זה שוב

324
00:15:43,980 --> 00:15:47,480
אבל בהקשר שונה מ
איך אנחנו משתמשים בזה קודם לכן.

325
00:15:47,480 --> 00:15:51,860
>> אז הנה זה נראה כמו רגיל
הצהרה משתנה שראינו.

326
00:15:51,860 --> 00:15:54,890
אז ראינו int x למחצה מעי גס לפני.

327
00:15:54,890 --> 00:16:00,020
ובכן עכשיו אנחנו יכולים לראות משהו
כמו int סוגריים x 5.

328
00:16:00,020 --> 00:16:04,020
ולשים את הרעיון הזה ל
תכנית GetInt שנו--

329
00:16:04,020 --> 00:16:08,850
כדי שנוכל ליישם
זה באותה הדרך.

330
00:16:08,850 --> 00:16:13,630
>> בואו נגיד בCS אנו נוטים להשתמש
n כמספר משהו.

331
00:16:13,630 --> 00:16:16,150
אז הנה אנחנו הולכים
לאחסן ארבעה תלמידים.

332
00:16:16,150 --> 00:16:25,960
ועכשיו אנחנו יכולים להגיד גיל int
תושבת n-- לא ממש מבינה את זה yet--

333
00:16:25,960 --> 00:16:32,210
להכריז מערך של ארבעה תלמידים.

334
00:16:32,210 --> 00:16:38,050
אז איך זה ייראה ב
הזיכרון יהיה דומה לזה.

335
00:16:38,050 --> 00:16:39,570
נקה זה.

336
00:16:39,570 --> 00:16:46,606
ואנחנו הולכים להיות במקום כלשהו
בmemory-- אני אשים את זה שם למעלה.

337
00:16:46,606 --> 00:16:52,690

338
00:16:52,690 --> 00:16:53,808
>> אז אי שם בזיכרון.

339
00:16:53,808 --> 00:16:58,760

340
00:16:58,760 --> 00:16:59,727
אחד שתיים שלוש ארבע.

341
00:16:59,727 --> 00:17:03,383

342
00:17:03,383 --> 00:17:09,849
יש לנו ארבעה מספרים שלמים ברציפות
למערך זה של ארבעה מספרים שלמים.

343
00:17:09,849 --> 00:17:13,820
אז, ברגע זה, מה הוא
גודלו של אחד מהקופסות האלה?

344
00:17:13,820 --> 00:17:17,190

345
00:17:17,190 --> 00:17:17,690
כן.

346
00:17:17,690 --> 00:17:18,390
זה ארבעה בתים.

347
00:17:18,390 --> 00:17:19,690
זה 32 סיביות.

348
00:17:19,690 --> 00:17:22,310
אז עכשיו זה שונה
מהמערך ש

349
00:17:22,310 --> 00:17:24,020
ראה קודם לכן, המערך של תווים.

350
00:17:24,020 --> 00:17:28,540
במחרוזת כל תיבה הייתה רק בית אחד,
בגלל אופי הוא רק בית אחד.

351
00:17:28,540 --> 00:17:32,170
אבל עם מערך של מספרים שלמים, כל
תיבה צריכה להיות ארבעה בתים על מנת

352
00:17:32,170 --> 00:17:34,060
כדי להתאים כל מספר שלם.

353
00:17:34,060 --> 00:17:37,197
אז זה מה שמערך של
ארבעה ints ייראה.

354
00:17:37,197 --> 00:17:40,510

355
00:17:40,510 --> 00:17:43,870
>> ולאחר מכן חזרה לקוד.

356
00:17:43,870 --> 00:17:47,460
עכשיו אנחנו רוצים בעצם חנות
מספרים שלמים למערך זה.

357
00:17:47,460 --> 00:17:53,470
אז עכשיו זה מאוד, מאוד, מאוד
משותף דפוס שיהיה בשלב מסוים

358
00:17:53,470 --> 00:17:54,680
הפך זיכרון שריר.

359
00:17:54,680 --> 00:17:56,710
אז int i שווה 0.

360
00:17:56,710 --> 00:17:57,940
אני פחות מ n.

361
00:17:57,940 --> 00:18:01,850
אני פלוס פלוס.

362
00:18:01,850 --> 00:18:05,790
קבוצת הגיל אני שווה GetInt.

363
00:18:05,790 --> 00:18:15,100
>> אז זה ללולאה, בפורמט זה,
אתה צריך לקבל מאוד בעבר.

364
00:18:15,100 --> 00:18:20,010
אז זה בדרך כלל איך אנחנו
לחזר על כמעט כל מערך.

365
00:18:20,010 --> 00:18:23,690
עכשיו שם לב זה סוג של
מסביר מדוע מההתחלה

366
00:18:23,690 --> 00:18:29,870
לא היה לנו ללולאות הולכים לint
אני שווה 1, אני פחות או שווה ל -10.

367
00:18:29,870 --> 00:18:34,200
להיות כי החל מהסיבה
אפס עושה את העבודה הזאת גם עם מערכים.

368
00:18:34,200 --> 00:18:36,270
אז מערכים הם אפס באינדקס.

369
00:18:36,270 --> 00:18:40,360
אם מערך זה הוא באורך 4,
המדדים 0 עד 3.

370
00:18:40,360 --> 00:18:42,880
>> אז הדרך הראשונה
איטרציה של לולאה זה ל

371
00:18:42,880 --> 00:18:49,930
אנחנו הולכים להיות הגדרת גיל
תושבת 0 שווה לקריאה לGetInt.

372
00:18:49,930 --> 00:18:52,440
אז כל מה שאני קרה
להיכנס במקלדת.

373
00:18:52,440 --> 00:18:56,970
במעבר השני, אנחנו
הגדרת AGE1 שווה לGetInt.

374
00:18:56,970 --> 00:18:58,230
לעבור שלישי, AGE2.

375
00:18:58,230 --> 00:18:59,880
age3 לעבור סופי.

376
00:18:59,880 --> 00:19:05,750
אז אם במסירה הראשונה של הלולאה
אני נכנסים למספר 4 במקלדת,

377
00:19:05,750 --> 00:19:07,740
אז להכניס 4 כאן.

378
00:19:07,740 --> 00:19:11,470
אם במסירה השנייה שאני נכנסתי
50, שנשים 50 כאן.

379
00:19:11,470 --> 00:19:15,180
בהרצה השלישית אולי אני
הזן 1 שלילי, שלילי 1,

380
00:19:15,180 --> 00:19:21,810
ולבסוף, אם אני נכנסתי 0-- ו
עכשיו זוכר שזה היה מדד שלושה.

381
00:19:21,810 --> 00:19:25,350
>> אחרי שחזרנו לולאה, הוא אני
הולך להיות מוגדל עד 4.

382
00:19:25,350 --> 00:19:27,770
אני כבר לא פחות מ n, אשר הוא 4.

383
00:19:27,770 --> 00:19:29,840
ואנחנו לפרוץ את הלולאה.

384
00:19:29,840 --> 00:19:32,578
אז מה יהיה בסדר עם זה?

385
00:19:32,578 --> 00:19:38,140

386
00:19:38,140 --> 00:19:38,729
[לא ברור]?

387
00:19:38,729 --> 00:19:39,604
קהל: [לא ברור]

388
00:19:39,604 --> 00:19:45,880

389
00:19:45,880 --> 00:19:46,400
>> כן.

390
00:19:46,400 --> 00:19:51,550
אז המערך יש רק ארבעה מקומות,
מה שאומר שמדדים 0 עד 3.

391
00:19:51,550 --> 00:19:55,630
אז אם זה היה המקרה, הייתי
לקחת על עצם את הערך 4 בשלב מסוים.

392
00:19:55,630 --> 00:20:00,910
קבוצת הגיל 4 תהיה הגדרה
כל מה שקורה להיות כאן

393
00:20:00,910 --> 00:20:02,920
מה יש לי לומר, להיכנס 6.

394
00:20:02,920 --> 00:20:05,010
שתהיה הגדרה זו עד 6.

395
00:20:05,010 --> 00:20:06,560
>> אבל אנחנו לא יודעים מה נגמר כאן.

396
00:20:06,560 --> 00:20:08,836
זה לא זיכרון
שהיו לנו גישה ל.

397
00:20:08,836 --> 00:20:10,710
אז אם אתה זוכר מ
ההרצאה הקודמת,

398
00:20:10,710 --> 00:20:14,350
הוא הדפיס את ערכים של Zamyla ו
בשלב מסוים הוא הכה פילוח זה

399
00:20:14,350 --> 00:20:17,990
דופי. אז אתה בטח יהיה לראות
תקלות פילוח רבות ככל ש

400
00:20:17,990 --> 00:20:20,530
ליישם חלק מקבוצות הבעיה.

401
00:20:20,530 --> 00:20:24,950
אבל זה אחד מהדרכים שבהן
אתה יכול להיתקל פילוח

402
00:20:24,950 --> 00:20:28,540
דופי, כאשר אתה מתחיל גישה
זיכרון בדרכים שאתה לא צריך להיות.

403
00:20:28,540 --> 00:20:34,117
אז לא היה לנו גישה ל
מיקום זה ומדובר בבאג.

404
00:20:34,117 --> 00:20:37,760

405
00:20:37,760 --> 00:20:40,190
>> אז זה טוב יותר.

406
00:20:40,190 --> 00:20:45,820
עכשיו יש עדיין קטן
בעיה עם קוד זה.

407
00:20:45,820 --> 00:20:50,720
וזה בעצם שאנחנו
עדיין תקוע בארבעה תלמידים.

408
00:20:50,720 --> 00:20:52,940
עכשיו, אם אני רוצה להשתמש בשמונה תלמידים, על אישור.

409
00:20:52,940 --> 00:20:54,350
זה לא כזה עניין גדול.

410
00:20:54,350 --> 00:20:58,120
אני יכול ללכת ב, לשנות את
להגיב, ולשנות את n.

411
00:20:58,120 --> 00:20:59,760
עכשיו זה יעבוד עם שמונה תלמידים.

412
00:20:59,760 --> 00:21:02,190
אם אני לקמפל ולהריץ
זה, זה ייראה me--

413
00:21:02,190 --> 00:21:07,870
זה יהיה לבקש מספרים שלמים לשמונה
תלמידים וזה פשוט יעבוד.

414
00:21:07,870 --> 00:21:11,850
אבל זה פחות אידיאלי לצריך
להדר מחדש את התכנית בכל פעם

415
00:21:11,850 --> 00:21:15,960
אני רוצה לשנות את מספר התלמידים
שאני רוצה להיכנס לגילים ל.

416
00:21:15,960 --> 00:21:22,990
>> אז השיפור הסופי ב
זה, כפי שנראה כאן-- אנחנו

417
00:21:22,990 --> 00:21:26,177
הולך לבקש את מספר האנשים.

418
00:21:26,177 --> 00:21:28,010
כאן יש לנו מספר
אנשים בחדרים

419
00:21:28,010 --> 00:21:29,880
או כל גילים של אנשים בחדר.

420
00:21:29,880 --> 00:21:33,300
אבל אנחנו הולכים לבקש את המספר
אנשים בחדר מהמשתמש.

421
00:21:33,300 --> 00:21:36,171
אז זה אותו הדבר-לעשות בזמן המדויק
לולאה שלא ראו קודם.

422
00:21:36,171 --> 00:21:37,920
זה אותו הדבר בדיוק
עשה תוך לולאה ש

423
00:21:37,920 --> 00:21:40,050
ניתן ליישם על סט הבעיה.

424
00:21:40,050 --> 00:21:43,102
אז כל עוד הם
כניסת n פחות מ 1,

425
00:21:43,102 --> 00:21:45,310
כך שיש חייב להיות ב
אדם אחד לפחות בחדר.

426
00:21:45,310 --> 00:21:47,407
כל עוד הם
כניסת n פחות מ 1,

427
00:21:47,407 --> 00:21:48,990
אז אנחנו הולכים להמשיך לשאול שוב.

428
00:21:48,990 --> 00:21:50,906
נא להזין את המספר
אנשים בחדר.

429
00:21:50,906 --> 00:21:53,550
עכשיו, ברגע שיש לנו את המספר
אנשים בroom--

430
00:21:53,550 --> 00:21:58,020
אז אני יכול להיכנס כי יש
200 אנשים בחדר הזה.

431
00:21:58,020 --> 00:22:05,480
אז כאן אנחנו הולכים לבוא
ולהצהיר על מערך בגודל 200.

432
00:22:05,480 --> 00:22:10,220
אנחנו מכריזים מערך זה
גדול מספיק כדי להכיל 200 גילים.

433
00:22:10,220 --> 00:22:15,370
יורד, זה ללולאה
כי יקבל מאוד בעבר.

434
00:22:15,370 --> 00:22:19,490
אז iterating על מערך זה,
הקצאה לכל מיקום

435
00:22:19,490 --> 00:22:23,020
במערך שמספר שלם, ו
אז בסופו כאן אנחנו

436
00:22:23,020 --> 00:22:28,340
פשוט מקבל דוגמא של iterating
על מערך ש, שלא להקצות ערכים,

437
00:22:28,340 --> 00:22:30,150
אבל כדי לגשת לערכים.

438
00:22:30,150 --> 00:22:33,810
>> אז כאן אנחנו רואים שאנחנו
אומרים, שנה מעכשיו,

439
00:22:33,810 --> 00:22:40,470
% אדם שאני יהיו% ישנים ששנים,
בי% הראשונים שהוא אני ועוד 1.

440
00:22:40,470 --> 00:22:43,010
אז הוא שמשתנה מדד זה.

441
00:22:43,010 --> 00:22:49,420
ואני% השני הולך להיות
הערך המאוחסן במערך הגילים בתוספת 1.

442
00:22:49,420 --> 00:22:54,217
אז בתוספת זו 1 היא רק בגלל שאנחנו
saying-- תוספת זו 1, גילים אני בתוספת 1.

443
00:22:54,217 --> 00:22:57,050
תוספת זו היא 1 רק בגלל שאנחנו
אומר, שנה מהאדם

444
00:22:57,050 --> 00:22:58,280
יהיה זה בן.

445
00:22:58,280 --> 00:23:01,080
>> אז למה הוא אני זה פלוס 1?

446
00:23:01,080 --> 00:23:04,064
למה יש לנו בתוספת 1 לשם?

447
00:23:04,064 --> 00:23:04,564
כן.

448
00:23:04,564 --> 00:23:07,410

449
00:23:07,410 --> 00:23:07,930
כן.

450
00:23:07,930 --> 00:23:10,510
אז לזכור מערכים אפס אינדקס.

451
00:23:10,510 --> 00:23:14,840
אז אם אנחנו מדפיסים את זה ל
מישהו רק כדי לקרוא את הפלט,

452
00:23:14,840 --> 00:23:19,380
אז כנראה שהם רוצים לראות משהו
כמו אדם אחד, מספר אדם אחד,

453
00:23:19,380 --> 00:23:21,160
יהיה בן 20.

454
00:23:21,160 --> 00:23:23,570
מספר האדם שני יהיה בן 15.

455
00:23:23,570 --> 00:23:27,420
הם מעדיפים לא לראות את האדם
מספר אפס הוא בן 15 שנים.

456
00:23:27,420 --> 00:23:36,460
>> אז קומפילציה זה ופשוט לראות מה
זה נראה like-- צור קצת מרחב.

457
00:23:36,460 --> 00:23:43,560
הפוך הידור גילים.

458
00:23:43,560 --> 00:23:45,080
ריצת גילים.

459
00:23:45,080 --> 00:23:46,580
אנו רואים מספר האנשים בחדר.

460
00:23:46,580 --> 00:23:48,850
אז אני אגיד יש
שלושה אנשים בחדר.

461
00:23:48,850 --> 00:23:54,000
גיל של מספר אדם אחד,
נניח 15, 20, 25.

462
00:23:54,000 --> 00:23:59,680
ועכשיו אני אגיד שנה מ
עכשיו הם יהיו 16, 21, 26.

463
00:23:59,680 --> 00:24:02,900
בואו לראות שזה עובד עם
n שאינו שווה ל -3.

464
00:24:02,900 --> 00:24:07,940
אז אם אני אומר מספר האנשים הוא 5, אחד,
שתיים, שלוש, שתיים, אחת, שנה מעכשיו

465
00:24:07,940 --> 00:24:11,170
הם יהיו שתיים, שלוש,
ארבע, שלוש, בן שנתיים.

466
00:24:11,170 --> 00:24:16,500
אז אני יכול רק כ
בקלות n להיות 10,000.

467
00:24:16,500 --> 00:24:21,270
עכשיו אני אשב כאן די
בעת כניסת גילים, אבל זה עובד.

468
00:24:21,270 --> 00:24:26,000
>> אז עכשיו בזיכרון איפשהו
יש מערך בגודל 10,000,

469
00:24:26,000 --> 00:24:28,830
כך סופו של דבר 40,000
בתים, כי יש

470
00:24:28,830 --> 00:24:31,222
ארבעה בתים לכל אחד מהמספרים שלמים אלה.

471
00:24:31,222 --> 00:24:33,180
אז יש מערך של
גודל 10,000 שבו אנחנו יכולים

472
00:24:33,180 --> 00:24:36,201
לאחסן את הגילים של 10,000 האנשים האלה.

473
00:24:36,201 --> 00:24:36,700
בסדר.

474
00:24:36,700 --> 00:24:40,070
שאלות על כל זה?

475
00:24:40,070 --> 00:24:41,892
כן.

476
00:24:41,892 --> 00:24:43,350
מה אם נתן מספר שלילי?

477
00:24:43,350 --> 00:24:44,870
בואו לראות מה קורה.

478
00:24:44,870 --> 00:24:49,320
אז במספר case-- המסוים הזה
אנשים בחדר, אחד שלילי.

479
00:24:49,320 --> 00:24:52,580
זה דחה את זה,
כי כאן אנו לקרות

480
00:24:52,580 --> 00:24:57,180
לטיפול בעובדה שאם n הוא
פחות מאחוז אחד אנחנו הולכים לשאול שוב.

481
00:24:57,180 --> 00:25:01,780
אם תנסה להכריז
מערך של גודל שלילי,

482
00:25:01,780 --> 00:25:03,950
זה בדרך כלל לא עובד.

483
00:25:03,950 --> 00:25:05,570
>> אז בואו ננסה.

484
00:25:05,570 --> 00:25:08,000
בואו להתעלם מה
ערכם קלט עבור n

485
00:25:08,000 --> 00:25:10,571
ורק אומר גילים int שלילי אחד.

486
00:25:10,571 --> 00:25:12,410
בואו אראה אם ​​זה אפילו הידור.

487
00:25:12,410 --> 00:25:14,100
אני לא בטוח.

488
00:25:14,100 --> 00:25:14,920
מס '

489
00:25:14,920 --> 00:25:18,280
אז גילים הוכרז כ
מערך עם גודל שלילי.

490
00:25:18,280 --> 00:25:22,540
אז מראש היא מכירה מערך לא יכול
יהיה בגודל שלילי ודוחה אותו.

491
00:25:22,540 --> 00:25:26,840
עכשיו, אם אנחנו לא להתמודד
עשה תוך לולאה זה בצורה נכונה,

492
00:25:26,840 --> 00:25:28,810
אם לא היינו בודקים
אם n הוא פחות מ 1--

493
00:25:28,810 --> 00:25:32,690
נניח שאנחנו פשוט
לא היה לי זה בכלל

494
00:25:32,690 --> 00:25:35,940
ובמקום זה אנחנו פשוט לתפוס שלמים.

495
00:25:35,940 --> 00:25:40,710
לא משנה מה הוא מספר שלם ש,
אנו מצהירים מערך של גודל ש.

496
00:25:40,710 --> 00:25:44,250
>> אז המהדר לא יכול
אולי להתלונן עכשיו.

497
00:25:44,250 --> 00:25:48,780
אם אני לקמפל זה--
כך שזה לא יכול להתלונן,

498
00:25:48,780 --> 00:25:51,480
כי זה לא יכול לדעת שאני
הולך להזין מספר שלילי,

499
00:25:51,480 --> 00:25:52,550
אשר עשוי להיות לא חוקי.

500
00:25:52,550 --> 00:25:54,633
לכל זה יודע, אולי אני
להזין מספר חיובי,

501
00:25:54,633 --> 00:25:56,000
שהוא חוקי לחלוטין.

502
00:25:56,000 --> 00:26:01,090
אז אני מתאר לעצמי אם אני נכנסתי שלילי 1
אנשים בחדר, פילוח אשמה.

503
00:26:01,090 --> 00:26:06,040
>> אז, בסדר.

504
00:26:06,040 --> 00:26:13,160
אז בואו נוסיף את זה בחזרה רק
לשמור אותו מה זה היה במקור.

505
00:26:13,160 --> 00:26:15,640
אז להפוך את הגילים.

506
00:26:15,640 --> 00:26:18,120
עכשיו, אם אני רוצה לנסות
שלילי age-- אז בואו

507
00:26:18,120 --> 00:26:19,710
אומר שיש חמישה אנשים בחדר.

508
00:26:19,710 --> 00:26:23,180
גיל של מספר אדם אחד
הוא 4 שליליים, אדם שלושה

509
00:26:23,180 --> 00:26:26,500
הוא אפס, אדם לוש-- אישור.

510
00:26:26,500 --> 00:26:29,850
אז הנה, מחברה, מספר אדם בשנה
אחד יהיה שלילי בן 3 שנים.

511
00:26:29,850 --> 00:26:32,830
אז כנראה לא הגיוני.

512
00:26:32,830 --> 00:26:37,220
אבל זה רק בגלל שמחפש
בקוד כל מה שאנחנו עושים

513
00:26:37,220 --> 00:26:40,260
מבקש GetInt.

514
00:26:40,260 --> 00:26:44,110
>> עכשיו, אם היו לנו
פונקצית GetPositiveInt

515
00:26:44,110 --> 00:26:49,690
או שהיו פשוט עשה את זה
סוג של אותו תוך לולאה שם למטה,

516
00:26:49,690 --> 00:26:52,340
אז זה יעבוד בסדר גמור.

517
00:26:52,340 --> 00:26:54,200
אבל בזה בפרט
מקרה, שאנחנו עושים פשוט לא

518
00:26:54,200 --> 00:26:57,772
במקרה טיפול בערכים שליליים.

519
00:26:57,772 --> 00:26:59,147
שאלות אחרות על מערכים?

520
00:26:59,147 --> 00:27:02,290

521
00:27:02,290 --> 00:27:03,250
אוקיי.

522
00:27:03,250 --> 00:27:09,380
>> אז עכשיו שראינו מערכים.

523
00:27:09,380 --> 00:27:12,500
ואנחנו הולכים צריכים להשתמש
זה לטיעוני שורת הפקודה.

524
00:27:12,500 --> 00:27:14,680
אז בבעיה להגדיר two--
אני יודע שרבים מכם

525
00:27:14,680 --> 00:27:18,040
אולי עדיין עובד על סט בעיה
אחד, אבל בעיה להגדיר שני מתקרבות.

526
00:27:18,040 --> 00:27:22,260
בבעיה להגדיר שתי, אתה הולך
צריך להיות התמודדות עם מחרוזות, מערכים,

527
00:27:22,260 --> 00:27:23,950
וטיעוני שורת הפקודה.

528
00:27:23,950 --> 00:27:26,270
>> אז מה הם טיעוני שורת הפקודה?

529
00:27:26,270 --> 00:27:29,570
עכשיו, אתה יכול לראות כאן למטה
טיזר קטן בדיוק מה

530
00:27:29,570 --> 00:27:30,950
הולך להיות קורה.

531
00:27:30,950 --> 00:27:32,950
אנו רואים argc העיקרי, Inc int,
סוגריים argv המחרוזת.

532
00:27:32,950 --> 00:27:34,560

533
00:27:34,560 --> 00:27:38,130
אז בואו ראשון ננסה לפרש
מה שמנסה להגיד.

534
00:27:38,130 --> 00:27:40,800
עכשיו בסדר.

535
00:27:40,800 --> 00:27:44,637
>> אז בשורת הפקודה אתה צריך להיות
להתרגל לחלק מפקודות אלה

536
00:27:44,637 --> 00:27:48,580
עכשיו, ויש לך כנראה לרוץ
CD במסוף לפני.

537
00:27:48,580 --> 00:27:52,100
אז אם אנחנו אומרים pset1 CD,
אתה יודע שזה צריך

538
00:27:52,100 --> 00:27:55,050
להיות שינוי לתוך ספריית pset1.

539
00:27:55,050 --> 00:27:59,120
>> עכשיו שם לב שיש לך אף פעם לא
נכתב תכנית כמו זו לפני.

540
00:27:59,120 --> 00:28:03,120
כל תכנית שכתבת,
היית רץ, למשל, נקודה לקצץ מריו,

541
00:28:03,120 --> 00:28:06,779
הנקודה לקצץ חמדנים, ואז זה
אולי יבקש ממך הקלט.

542
00:28:06,779 --> 00:28:08,570
עכשיו, זה לא מה ש
שינוי הספרייה עושה.

543
00:28:08,570 --> 00:28:12,770
כאשר אתה מפעיל את התקליטור, זה לא אומר אז,
איזו ספרייה שאתה רוצה CD ל?

544
00:28:12,770 --> 00:28:17,200
במקום זאת, אתה פשוט אומר, pset1 CD, ו
זה פשוט הולך לספריית pset1.

545
00:28:17,200 --> 00:28:20,430
>> אז באופן דומה יש לנו דוגמאות נוספות.

546
00:28:20,430 --> 00:28:21,540
לעשות שלום.

547
00:28:21,540 --> 00:28:25,760
כאשר אתה מפעיל לעשות, זה לא אומר אז,
איזו תכנית היית רוצה לעשות?

548
00:28:25,760 --> 00:28:29,620
אתה פשוט אומר, ב
שורת הפקודה לעשות שלום.

549
00:28:29,620 --> 00:28:31,060
>> מהלך הוא דוגמא נוספת.

550
00:28:31,060 --> 00:28:34,840
אחד זה אנו נעים
mario.c להגיש את מדריך אחד.

551
00:28:34,840 --> 00:28:38,060
אז עכשיו אנחנו יודעים עם דוגמא זו
אנחנו באמת עוברים שתי טענות.

552
00:28:38,060 --> 00:28:42,090
יש mario.c כטענה הראשונה,
ונקודת נקודה היא הטענה השנייה.

553
00:28:42,090 --> 00:28:46,140
ואז כאשר אתה מפעיל לעשות, אתה
רואה שפקודה באמת ארוכה line--

554
00:28:46,140 --> 00:28:50,580
שפקודה באמת ארוכה
מודפס בשורת הפקודה.

555
00:28:50,580 --> 00:28:53,590
אז כל כך הרבה זמן command-- זה
הוא רק חלק קצר שלו,

556
00:28:53,590 --> 00:28:56,090
אבל עכשיו יש לנו שלוש
שורת הפקודה טיעונים.

557
00:28:56,090 --> 00:28:59,750
מקף דוט אפס, שלום, וhello.c.

558
00:28:59,750 --> 00:29:03,497
>> אז אלה הם שורת הפקודה
טיעונים, נימוקים

559
00:29:03,497 --> 00:29:05,580
שאתה עובר ב
שורת הפקודה כדי שזה

560
00:29:05,580 --> 00:29:08,680
לא צריך שתתבקש
כאשר אתה מפעיל את התכנית.

561
00:29:08,680 --> 00:29:13,090
זה יהיה מתסכל אם כש
אתה רץ מצלצל זה אמר, "בסדר,

562
00:29:13,090 --> 00:29:15,630
שprogram-- ש
קובץ אתה קומפילציה?

563
00:29:15,630 --> 00:29:17,010
Hello.c.

564
00:29:17,010 --> 00:29:19,440
מה הדגלים היית
רוצה להיכנס? o מקף.

565
00:29:19,440 --> 00:29:21,190
מה תרצה
הקובץ שייקרא?

566
00:29:21,190 --> 00:29:21,690
שלום.

567
00:29:21,690 --> 00:29:25,290
לא, אתה פשוט להפעיל צלצול
מקף o שלום hello.c.

568
00:29:25,290 --> 00:29:28,820
>> אז במבט לאחור בשלב זה.

569
00:29:28,820 --> 00:29:32,920
עכשיו argc argc-- הוא ספירת הטיעון.

570
00:29:32,920 --> 00:29:36,620
זה המספר של שורת הפקודה
טיעונים נכנסו בשורת הפקודה.

571
00:29:36,620 --> 00:29:39,720
ובכן, מבחינה טכנית argv--
v מייצג וקטור,

572
00:29:39,720 --> 00:29:41,460
אשר בעצם אומר מערך.

573
00:29:41,460 --> 00:29:42,680
אבל אתה יכול להתעלם מכך.

574
00:29:42,680 --> 00:29:47,540
Argv-- יש לנו argv מחרוזת,
כך argv מחרוזת בסוגריים.

575
00:29:47,540 --> 00:29:50,150
אז זה עוד צורה של
בסוגריים שלא ראה בעבר.

576
00:29:50,150 --> 00:29:52,300
הסוגר אז שראינו
סימון כאשר אנחנו כבר אמרו,

577
00:29:52,300 --> 00:29:53,970
כמו, מחרוזת של שווה Zamyla.

578
00:29:53,970 --> 00:29:56,910
הסוגר של 0 כניסות ז האופי

579
00:29:56,910 --> 00:30:00,720
>> כן, אנו רואים בסוגריים כש
אמרנו גילאי int סוגרים 5.

580
00:30:00,720 --> 00:30:03,160
שהכריז מערך של גודל 5.

581
00:30:03,160 --> 00:30:06,280
אז הנה גרסה של
סוגריים שלא ראו בעבר.

582
00:30:06,280 --> 00:30:09,630
אז זה סוג של argv מחרוזת ש
יהיה מוכר לחלוטין

583
00:30:09,630 --> 00:30:12,050
שזה יהיה רק ​​מחרוזת.

584
00:30:12,050 --> 00:30:14,520
עכשיו סוגריים מציינים
כי זה הוא מערך.

585
00:30:14,520 --> 00:30:19,920
אז אמצעי סוגריים argv המחרוזת
argv שהוא מערך של מחרוזות.

586
00:30:19,920 --> 00:30:22,540
עכשיו מבחינה טכנית מחרוזת
הוא מערך של תווים.

587
00:30:22,540 --> 00:30:26,400
אז זה עכשיו מערך
של מערך של תווים.

588
00:30:26,400 --> 00:30:31,490
אבל זה הרבה יותר קל לחשוב על
זה כמו רק מערך של מחרוזות.

589
00:30:31,490 --> 00:30:34,900
>> אז למה סוגריים עשויים להיות ריקים?

590
00:30:34,900 --> 00:30:38,170
כמו, למה אנחנו לא יכולים לומר,
תושבת 5, n הסוגר?

591
00:30:38,170 --> 00:30:40,700

592
00:30:40,700 --> 00:30:41,200
כן.

593
00:30:41,200 --> 00:30:43,731

594
00:30:43,731 --> 00:30:44,230
כן.

595
00:30:44,230 --> 00:30:46,396
אנחנו לא יודעים כמה
תשומות יש הולכים להיות.

596
00:30:46,396 --> 00:30:53,560
אם אנחנו מסתכל על דוגמא הצלצול אז,
אנחנו אומרים מצלצלים מקף o שלום hello.c.

597
00:30:53,560 --> 00:30:56,710
במקרה הספציפי הזה, יש לקרות
להיות שלושה טיעוני שורת הפקודה.

598
00:30:56,710 --> 00:31:00,522
וכך brackets-- נראה
בשנייה שזה לא יהיה שלושה.

599
00:31:00,522 --> 00:31:01,730
זה מבחינה טכנית יהיה ארבעה.

600
00:31:01,730 --> 00:31:04,030
אבל בסוגריים, שהיינו
למשל, יש שלוש.

601
00:31:04,030 --> 00:31:08,220
אבל עכשיו אם הסתכלנו מהלך
mario.c נקודת נקודה, סוגריים

602
00:31:08,220 --> 00:31:09,760
היינו רוצה לשים את שני בהם.

603
00:31:09,760 --> 00:31:12,884
>> ויש הרבה פקודות ש
יש מספר משתנה של שורת הפקודה

604
00:31:12,884 --> 00:31:13,620
טיעונים.

605
00:31:13,620 --> 00:31:17,430
אז מה גרסה זו של
סימון התושבת מציין

606
00:31:17,430 --> 00:31:20,820
הוא שargv הוא מערך של מחרוזות.

607
00:31:20,820 --> 00:31:24,360
אבל אנחנו לא יודעים כמה
מחרוזות במערך ש.

608
00:31:24,360 --> 00:31:27,090
ואיך אנחנו יודעים איך אז
מחרוזות רבות במערך?

609
00:31:27,090 --> 00:31:28,870
זה כל argc הנקודה.

610
00:31:28,870 --> 00:31:32,300
argc אומר לנו כמה זמן argv הוא.

611
00:31:32,300 --> 00:31:36,500
>> אז הדבר האחרון שכדאי
דעה היא ש, מבחינה טכנית,

612
00:31:36,500 --> 00:31:40,820
הפקודה עצמו נחשבת כאחד
טיעוני שורת הפקודה.

613
00:31:40,820 --> 00:31:45,330
אז pset1 CD, יש שני
שורת הפקודה טיעונים.

614
00:31:45,330 --> 00:31:50,260
התכנית בעצמו, CD, ולאחר מכן
החלק בפועל הטיעון שלו, pset1.

615
00:31:50,260 --> 00:31:54,490
כל תכנית שכתבת עד כה
יש לו נקודת argument-- שורת הפקודה אחד

616
00:31:54,490 --> 00:31:55,320
לקצץ מריו.

617
00:31:55,320 --> 00:31:57,350
זה הטיעון של שורת הפקודה בלבד.

618
00:31:57,350 --> 00:32:00,900
>> מחפש אז עכשיו בצלצול
מקף o שלום hello.c.

619
00:32:00,900 --> 00:32:01,905
אז מה הוא argc?

620
00:32:01,905 --> 00:32:05,260

621
00:32:05,260 --> 00:32:06,080
4.

622
00:32:06,080 --> 00:32:08,140
אז argc הוא 4.

623
00:32:08,140 --> 00:32:12,140
צלצול, תושבת כך argv 0 היא צלצול.

624
00:32:12,140 --> 00:32:15,630
תושבת argv 1 היא מקף 0.

625
00:32:15,630 --> 00:32:21,870
argv תושבת 2 היא שלום, ו
argv הסוגר 3 הוא hello.c.

626
00:32:21,870 --> 00:32:26,813
אוקיי, אז שאלות על זה, ואז
תסתכל על כמה דוגמאות תכנותית.

627
00:32:26,813 --> 00:32:29,460

628
00:32:29,460 --> 00:32:30,480
>> אוקיי.

629
00:32:30,480 --> 00:32:36,260
אז אנחנו נסתכל על hello3.c.

630
00:32:36,260 --> 00:32:41,890
אז זה צריך להיות מוכר מ
אחת דוגמאות הראשונות ג

631
00:32:41,890 --> 00:32:45,800
היו לנו איפה אנחנו היינו אומרים רק, שלום
עולם, אבל עכשיו זה הוא כללי יותר.

632
00:32:45,800 --> 00:32:52,300
אז הנה אנחנו אומרים שלום
% s תושבת argv n הלוכסן 1.

633
00:32:52,300 --> 00:32:57,440
Notice-- כך עד נקודה זו, זה הוא
מה קובץ התבנית שלי נראה.

634
00:32:57,440 --> 00:33:01,800
היה לי int הראשי (void), ולאחר מכן הייתי
לעשות משהו בפונקציה העיקרית.

635
00:33:01,800 --> 00:33:05,100
עכשיו במקום, ברגע שנתחיל התמודדות
עם טיעוני שורת הפקודה,

636
00:33:05,100 --> 00:33:07,890
אנחנו צריכים להצהיר
צורה שונה של עיקרי.

637
00:33:07,890 --> 00:33:11,930
>> אז מסתכל על hello3
שוב, העיקרי הולך

638
00:33:11,930 --> 00:33:15,990
לקחת שני טיעונים now-- argc int,
מספר טיעוני שורת הפקודה,

639
00:33:15,990 --> 00:33:20,970
ומחרוזת argv סוגריים, בפועל
מחרוזות נכנסו בשורת הפקודה.

640
00:33:20,970 --> 00:33:26,560
אז אני הולך לשנות את זה
תבנית כדי לשקף עובדה זו.

641
00:33:26,560 --> 00:33:29,060
עכשיו בכל פעם שאתה כותב
תכנית, אם לא

642
00:33:29,060 --> 00:33:33,720
צריך לקחת כל שורת הפקודה
טיעונים, ואז פשוט להשתמש int הראשי (void).

643
00:33:33,720 --> 00:33:37,070
אבל עכשיו כשאתה כותב
תוכניות טיעון שורת הפקודה, ש

644
00:33:37,070 --> 00:33:40,350
אתה הולך לעשות לבעיה
להגדיר two-- אז עכשיו שאתה מפעיל

645
00:33:40,350 --> 00:33:42,630
תוכניות שצריכות לקחת
שורת הפקודה טיעונים,

646
00:33:42,630 --> 00:33:45,250
אתה צריך שתהיה לי עיקרי של צורה זו.

647
00:33:45,250 --> 00:33:51,290
>> אז כאן-- זו היא השימוש הגדול
של הטיעון של שורת הפקודה.

648
00:33:51,290 --> 00:33:54,100
אז הדפסת argv 1.

649
00:33:54,100 --> 00:33:59,180
אישור אז בואו לקמפל
ולהפעיל את התכנית.

650
00:33:59,180 --> 00:34:02,440
הפוך hello3.

651
00:34:02,440 --> 00:34:03,570
הידור.

652
00:34:03,570 --> 00:34:06,870
דוט לקצץ hello3.

653
00:34:06,870 --> 00:34:08,920
ונניח, "רוב".

654
00:34:08,920 --> 00:34:10,760
שלום רוב.

655
00:34:10,760 --> 00:34:14,940
אם אני אומר, "שלום מריה," שלום מריה.

656
00:34:14,940 --> 00:34:15,719
שלום מריה.

657
00:34:15,719 --> 00:34:18,639
חנה עדיין אומרת, "שלום
מריה, "כי אני לא

658
00:34:18,639 --> 00:34:21,340
עושה שום דבר עם argv 2.

659
00:34:21,340 --> 00:34:22,590
Argv 2 עכשיו יהיה "חנה".

660
00:34:22,590 --> 00:34:25,030
Argc יהיה 3.

661
00:34:25,030 --> 00:34:27,735
מה אם אני עשיתי את זה?

662
00:34:27,735 --> 00:34:31,980

663
00:34:31,980 --> 00:34:34,679
אז שלום null.

664
00:34:34,679 --> 00:34:38,760
>> הוא נגע בקצרה על העובדה
כי, מבחינה טכנית, GetString

665
00:34:38,760 --> 00:34:42,429
אולי תחזיר null, אבל אנחנו נגיע
הרבה יותר למה שnull הוא למעשה.

666
00:34:42,429 --> 00:34:47,449
אבל לקחת את זה כעניין של
עובדה שאין הוא בדרך כלל רע.

667
00:34:47,449 --> 00:34:50,179
עשינו משהו לא בסדר אם
זה הדפסה "שלום null."

668
00:34:50,179 --> 00:34:52,179
והסיבה שעשינו
משהו לא בסדר הוא-- גם,

669
00:34:52,179 --> 00:34:56,179
כשרצתי hello3 נטוי נקודה, argc היה 1.

670
00:34:56,179 --> 00:34:59,680
אז זה אומר האורך של argv היה 1.

671
00:34:59,680 --> 00:35:05,110
אם מערך הוא באורך 1,
המדד תקף רק הוא אפס.

672
00:35:05,110 --> 00:35:08,550
ואז הנה argv 1 הוא מחוץ
מגוון של מערך זה.

673
00:35:08,550 --> 00:35:13,410
זה היה דומה ללפני כשניסיתי
לאחסון 6 מחוץ לסוף המערך.

674
00:35:13,410 --> 00:35:18,100
אז אני מנסה לגשת למשהו
מחוץ לספירת argv,

675
00:35:18,100 --> 00:35:21,340
ואנחנו מקבלים אפס.

676
00:35:21,340 --> 00:35:24,360
>> אז גרסה טובה יותר של
זה, שיפור,

677
00:35:24,360 --> 00:35:27,010
הוא במפורש בדיקת argc.

678
00:35:27,010 --> 00:35:33,580
אז אם argc שווה 2, זה אומר שאנחנו רצים
משהו כמו hello3 לוכסן נקודה רוב.

679
00:35:33,580 --> 00:35:36,840
וזה יהיה להדפיס "שלום רוב."

680
00:35:36,840 --> 00:35:39,850
אם argc לא שווה
2, אז זה רק הולך

681
00:35:39,850 --> 00:35:42,560
להתעלם מה אתה שם
בטענה של שורת הפקודה

682
00:35:42,560 --> 00:35:43,960
כטיעונים שורת הפקודה.

683
00:35:43,960 --> 00:35:47,168
או אם אתה לא שם בכלל, זה
רק הולך להתעלם מכך ורק אומרים,

684
00:35:47,168 --> 00:35:47,960
"שלום אתה."

685
00:35:47,960 --> 00:35:51,490
>> אז קומפילציה זה.

686
00:35:51,490 --> 00:35:54,500
הפוך hello4.

687
00:35:54,500 --> 00:35:56,790
ופועל hello4.

688
00:35:56,790 --> 00:36:00,010
מפעיל אותו בדרך זו,
מה צריך להיות מודפס?

689
00:36:00,010 --> 00:36:01,330
"שלום אתה."

690
00:36:01,330 --> 00:36:02,810
שלום אתה.

691
00:36:02,810 --> 00:36:05,870
מה לגבי hello4 רוב?

692
00:36:05,870 --> 00:36:06,950
"שלום רוב."

693
00:36:06,950 --> 00:36:10,580
ולבסוף, שלום רוב מריה
רק "שלום לך" שוב,

694
00:36:10,580 --> 00:36:13,677
כי אתה לא באמת להיכנס
משהו שציפה.

695
00:36:13,677 --> 00:36:15,510
אתה נכנס יותר שמות
ממה שהוא יכול להתמודד,

696
00:36:15,510 --> 00:36:19,500
כך שזה רק ברירת מחדל ל
שלום לך ההתנהגות.

697
00:36:19,500 --> 00:36:23,040
אז שאלות על זה?

698
00:36:23,040 --> 00:36:26,290
או טיעוני שורת הפקודה?

699
00:36:26,290 --> 00:36:28,690
>> אוקיי, אז לקחת מבט
עוד כמה דוגמאות של שימוש

700
00:36:28,690 --> 00:36:34,230
שורת הפקודה arguments-- הראשונה
יש לנו argv מקף 1 הנקודה ג.

701
00:36:34,230 --> 00:36:38,510
אז ההערות לתת מה
צריכה לעשות תכנית זו.

702
00:36:38,510 --> 00:36:42,460
אבל שם לב now-- זה ללולאה,
זו תואמת את התבנית המדויקת

703
00:36:42,460 --> 00:36:43,390
אני אומר לפני.

704
00:36:43,390 --> 00:36:46,240
אנחנו פשוט להיות
באמצעות argc במקום n.

705
00:36:46,240 --> 00:36:48,880
עכשיו argc הוא באמת n.

706
00:36:48,880 --> 00:36:51,260
זה האורך של מערך argv.

707
00:36:51,260 --> 00:36:59,600
אז הם iterating על argv
כל ערך argv ing-printf מערך.

708
00:36:59,600 --> 00:37:04,730
>> אז אם אני עושה את זה.

709
00:37:04,730 --> 00:37:08,232
הפוך argv 1.

710
00:37:08,232 --> 00:37:09,940
זה הידור.

711
00:37:09,940 --> 00:37:11,620
דוט לקצץ argv 1.

712
00:37:11,620 --> 00:37:15,530
פשוט רץ זה, זה
הדפסי נקודה argv הנטוי 1

713
00:37:15,530 --> 00:37:18,500
מאז שהייתה שורת הפקודה בלבד
argument-- את שם התכנית.

714
00:37:18,500 --> 00:37:22,080
תמיד יהיה בleast--
argc לא יכול להיות פחות מ,

715
00:37:22,080 --> 00:37:25,910
מאז תמיד יהיו לפחות
להיות שם התכנית לפעול.

716
00:37:25,910 --> 00:37:32,040
אז argv 1 רוב יודפס argv 1
ואז על הקו החדש "רוב".

717
00:37:32,040 --> 00:37:36,350
>> אז באיטרציה הראשונה
של לולאה זה, אני הוא 0.

718
00:37:36,350 --> 00:37:39,090
Argv 0 הוא שם התכנית.

719
00:37:39,090 --> 00:37:40,010
דוט לקצץ argv 1.

720
00:37:40,010 --> 00:37:43,770
ולאחר מכן argv 1 הוא ראשון שלי
שורת הפקודה טיעון, שהוא רוב.

721
00:37:43,770 --> 00:37:45,920
בשלב זה, אנו שווים לargc.

722
00:37:45,920 --> 00:37:48,210
אנו לפרוץ את הלולאה ואנחנו נעשו.

723
00:37:48,210 --> 00:37:53,940
אז זה יעבוד עבור שרירותי
מספר טיעוני שורת הפקודה.

724
00:37:53,940 --> 00:37:58,550
שים לב שזה מדפיס argv 0, argv
1, 2 argv, argv 3, argv 4.

725
00:37:58,550 --> 00:38:00,150
ואין argv 5.

726
00:38:00,150 --> 00:38:01,460
argc הוא שווה ל 5.

727
00:38:01,460 --> 00:38:06,960
אז בargc-- באני שווה 5,
אנחנו לפרוץ את הלולאה.

728
00:38:06,960 --> 00:38:07,950
אוקיי.

729
00:38:07,950 --> 00:38:11,315
אז שאלות על זה לפני ש
תתבונן בדוגמה מורכבת יותר?

730
00:38:11,315 --> 00:38:14,190

731
00:38:14,190 --> 00:38:16,860
>> אז argv 2.

732
00:38:16,860 --> 00:38:17,830
בסדר.

733
00:38:17,830 --> 00:38:20,610
אז אנחנו עדיין הדפסה
טיעוני שורת הפקודה.

734
00:38:20,610 --> 00:38:23,170
אבל עכשיו שמתי לב שיש לנו
מקונן ללולאה.

735
00:38:23,170 --> 00:38:24,670
אז מה הוא עושה את זה?

736
00:38:24,670 --> 00:38:28,430
אז הלולאה הראשונה הוא עושה
בדיוק מה שעשה בעבר.

737
00:38:28,430 --> 00:38:30,950
אנחנו עדיין לולאה מעל
כל טענה של שורת הפקודה,

738
00:38:30,950 --> 00:38:34,260
אבל עכשיו loop-- השני זה יש לנו
גם ראה משהו כזה בעבר.

739
00:38:34,260 --> 00:38:38,600
כשiterating על
Zamyla להדפיס את Z--M-Y-L-.

740
00:38:38,600 --> 00:38:44,816
אז הלולאה שנייה לj int שווה
0, n שווה strlen של תושבת argv אני.

741
00:38:44,816 --> 00:38:49,170
>> אז בואו נחשוב ראשון ל
כל-- בואו ללכת דרך.

742
00:38:49,170 --> 00:38:53,560
בואו נחשוב מה היית עושה במחשב
לעשות אם אני רץ תכנית זו כנקודה רק

743
00:38:53,560 --> 00:38:56,030
לקצץ argv מקף 2.

744
00:38:56,030 --> 00:39:03,590
אז אם רצתי את הקוד הזה, אז
argc הולך להיות שווה ל 1.

745
00:39:03,590 --> 00:39:07,050
ומחרוזת argv-- יש רק
הולך להיות מדד אחד בargv,

746
00:39:07,050 --> 00:39:12,370
וזה הולך להיות שווה לנקודה
לקצץ argv 2-- את שם התכנית.

747
00:39:12,370 --> 00:39:19,170
>> אוקיי, אז עכשיו אני שווה 0, אני פחות מ
1, אני בתוספת בתוספת לj int שווה 0,

748
00:39:19,170 --> 00:39:23,880
n שווה strlen של תושבת argv 0, כך ב
איטרציה הראשונה של לולאה זה. argv

749
00:39:23,880 --> 00:39:27,250
תושבת 0 היא הקו נטוי נקודת argv 2.

750
00:39:27,250 --> 00:39:29,320
אז מה הוא אורך המחרוזת ש?

751
00:39:29,320 --> 00:39:32,480
ובכן, נקודה לקצץ-R-G-V מקף 2.

752
00:39:32,480 --> 00:39:35,020
אז strlen של שיהיו 8.

753
00:39:35,020 --> 00:39:37,500
אז j שווה 0, n שווה 8.

754
00:39:37,500 --> 00:39:39,530
כל עוד j הוא פחות מ 8, ++ j.

755
00:39:39,530 --> 00:39:44,080
ועם זה אנחנו הולכים להיות
הדפסת תו בודד, אשר

756
00:39:44,080 --> 00:39:47,350
הוא argv הסוגר אני סוגר j.

757
00:39:47,350 --> 00:39:49,826
>> אז הוא רק אפס.

758
00:39:49,826 --> 00:39:51,700
עדיין יש לנו רק אחד
שורת הפקודה טיעון.

759
00:39:51,700 --> 00:39:53,890
שבאיטרציה הראשונה
של ללולאה, אנחנו

760
00:39:53,890 --> 00:39:56,950
הולך להיות הדפסה
תושבת argv 0 הסוגר 0.

761
00:39:56,950 --> 00:39:58,325
ואז j הולך להגדיל.

762
00:39:58,325 --> 00:40:01,650
ואנחנו הולכים להדפסה
תושבת argv 0 תושבת 1.

763
00:40:01,650 --> 00:40:04,150
ולאחר מכן argv הסוגר 0 התושבת 2.

764
00:40:04,150 --> 00:40:09,030
>> אז זה המפגש הראשון שלנו
מערכים רב-ממדיים.

765
00:40:09,030 --> 00:40:12,770
זכור קודם לכן שאמרתי
argv שהוא מבחינה טכנית

766
00:40:12,770 --> 00:40:15,950
מערך של מערכים של תווים.

767
00:40:15,950 --> 00:40:24,360
אז הנה אם אמרתי משהו כמו
מחרוזת של שווה תושבת argv אני,

768
00:40:24,360 --> 00:40:29,590
ואז אמרתי, של י הסוגר, זה
יהיה להשיג את אותו הדבר.

769
00:40:29,590 --> 00:40:31,960
עכשיו, אתה כבר ראית של j הסוגר לפני.

770
00:40:31,960 --> 00:40:36,680
זה פשוט לגשת לי-ה
אופי של מחרוזת זו.

771
00:40:36,680 --> 00:40:48,010
אז עם זה, אנחנו מקבלים
אופי י-ה מargv i-ה.

772
00:40:48,010 --> 00:40:51,450
>> אז מה צריך סופו של דבר תפוקה זה?

773
00:40:51,450 --> 00:40:53,210
הפוך argv 2.

774
00:40:53,210 --> 00:40:54,730
זה הידור.

775
00:40:54,730 --> 00:40:56,340
דוט לקצץ argv 2.

776
00:40:56,340 --> 00:41:03,790
"רוב מריה חנה,"
ולתת לנו קצת מקום.

777
00:41:03,790 --> 00:41:07,050
כך אנו רואים שזה פלט
נקודה על קו משלו וקו נטוי

778
00:41:07,050 --> 00:41:08,920
בשורה הנפרדת ובשורה הנפרדת.

779
00:41:08,920 --> 00:41:11,260
זה להדפיס את כל
דמות בודדת

780
00:41:11,260 --> 00:41:12,950
כל טענה של שורת הפקודה.

781
00:41:12,950 --> 00:41:15,960
ולאחר מכן ביניהם,
בגלל הקו החדש

782
00:41:15,960 --> 00:41:19,380
אנחנו מדפיסים כאן למטה, ב
ביניהם זה יהיה להדפיס קו חדש.

783
00:41:19,380 --> 00:41:24,540
>> אז זה דומה ל
מקף argv לפני 1,

784
00:41:24,540 --> 00:41:26,459
שהודפס בכל
שורת הפקודה טיעון,

785
00:41:26,459 --> 00:41:28,500
אבל עכשיו אנחנו הדפסה
טיעוני שורת הפקודה

786
00:41:28,500 --> 00:41:31,950
ולאחר מכן iterating דרך כל
אופי של כל טיעון של שורת הפקודה

787
00:41:31,950 --> 00:41:35,400
כדי לקבל פלט זה.

788
00:41:35,400 --> 00:41:36,870
אוקיי?

789
00:41:36,870 --> 00:41:40,570
אז שאלות על זה?

790
00:41:40,570 --> 00:41:45,130
>> דבר אחד שיש לציין הוא ש
arguments-- שורת הפקודה

791
00:41:45,130 --> 00:41:49,990
כך הם מופרדים על ידי רווחים כ
אתה באופן טבעי היה מצפה מהם להיות.

792
00:41:49,990 --> 00:41:53,050
אז מחרוזת יכולה להיות רווחים בזה.

793
00:41:53,050 --> 00:41:57,380
זה לא סופר חשוב, אבל אם אני
רציתי את טענת שורת הפקודה השלישית

794
00:41:57,380 --> 00:42:01,226
יש מקום בו, אז אני
אפשר לומר משהו כזה.

795
00:42:01,226 --> 00:42:04,470

796
00:42:04,470 --> 00:42:05,550
אוקיי?

797
00:42:05,550 --> 00:42:12,190
אז זה עדיין עכשיו יש שלוש בלבד
שורת הפקודה היטב arguments-- 4.

798
00:42:12,190 --> 00:42:17,620
דוט לקצץ argv מקף 2, רוב,
מריה, וחנה בלומברג.

799
00:42:17,620 --> 00:42:18,320
אוקיי.

800
00:42:18,320 --> 00:42:19,310
שאלות על זה?

801
00:42:19,310 --> 00:42:22,700

802
00:42:22,700 --> 00:42:24,894
>> אין שום דבר מיוחד
על אופי החלל.

803
00:42:24,894 --> 00:42:27,810
זה פשוט קורה להיות ש
שורת הפקודה מתייחסת לאופי החלל

804
00:42:27,810 --> 00:42:29,226
איך אתה להפריד כל ויכוח.

805
00:42:29,226 --> 00:42:32,048

806
00:42:32,048 --> 00:42:33,000
בסדר.

807
00:42:33,000 --> 00:42:39,950
אז סט הבעיה
two-- אתה הולך להיות

808
00:42:39,950 --> 00:42:43,240
מסתכל על הצפנה סודית-מפתח.

809
00:42:43,240 --> 00:42:47,700
אז, בדומה לדוגמא ש
ראינו מסיפור חג המולד,

810
00:42:47,700 --> 00:42:52,840
אתה הולך להיות יישום מסוים
אלגוריתמים ש, ניתנו הודעה,

811
00:42:52,840 --> 00:42:55,560
אתה הולך להיות מסוגל
כדי להצפין הודעה ש

812
00:42:55,560 --> 00:42:58,730
שמישהו רק עם סוד ש
מפתח, עם שטבעת המפענח,

813
00:42:58,730 --> 00:43:01,090
צריך להיות מסוגל לפענח.

814
00:43:01,090 --> 00:43:04,839
>> כך שהיא המהדורה סטנדרטית.

815
00:43:04,839 --> 00:43:07,130
אתה הולך להיות יישום
שתי גרסאות שונות.

816
00:43:07,130 --> 00:43:09,620
אם יקרה לך תסתכל
במהדורת ההאקר עכשיו,

817
00:43:09,620 --> 00:43:12,600
אנחנו הולכים לתת לי
אתה מחרוזת כמו זה,

818
00:43:12,600 --> 00:43:15,240
המייצג את סיסמא מוצפנת.

819
00:43:15,240 --> 00:43:19,990
אז המטרה שלך היא להבין
מה היא הסיסמה המפוענח.

820
00:43:19,990 --> 00:43:26,950
עכשיו זה בעצם הוא איך סיסמאות
מאוחסנים בהרבה מחשבים,

821
00:43:26,950 --> 00:43:31,290
וזה רק מאחסן זה
מחרוזת אקראית של תווים.

822
00:43:31,290 --> 00:43:34,440
יש לך להבין איך להגיע
ממחרוזת האקראית של תווים

823
00:43:34,440 --> 00:43:36,140
למה הסיסמה המקורית הייתה.

824
00:43:36,140 --> 00:43:39,060

825
00:43:39,060 --> 00:43:43,290
>> ולבסוף, אחרי זה
סט בעיה, אתה צריך

826
00:43:43,290 --> 00:43:46,100
להיות מסוגל להבין מה זה אומר.

827
00:43:46,100 --> 00:43:51,650
כך תוכל ללמוד כיצד לפענח
סוג זה של מחרוזת אקראית.

828
00:43:51,650 --> 00:43:56,390
באופן דומה, אם אתה זוכר משבוע
0, אתה יכול לראות את כתובת אתר.

829
00:43:56,390 --> 00:44:00,210
ואתה אמור להיות מסוגל
לפענח סופו של דבר זה.

830
00:44:00,210 --> 00:44:04,810
אתה לא יכול להיות מאושר כשאתה
לפענח אותו ולחץ על הקישור.

831
00:44:04,810 --> 00:44:05,700
בסדר.

832
00:44:05,700 --> 00:44:06,591
זהו זה להיום.

833
00:44:06,591 --> 00:44:12,095
אז תתראה בשבוע הבא!

834
00:44:12,095 --> 00:44:18,315
>> [השמעת מוסיקה אלקטרונית]

835
00:44:18,315 --> 00:47:15,619