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

2
00:00:02,742 --> 00:00:05,030

3
00:00:05,030 --> 00:00:09,090
>> ANDI פנג: זה CS50, ו
ברוכים הבאים לשבוע של סעיף שניים.

4
00:00:09,090 --> 00:00:11,740
זהו למעשה תוך שבוע
שתיים מclass-- בעצם,

5
00:00:11,740 --> 00:00:14,550
בשבוע הראשון שהיינו לנו חלק.

6
00:00:14,550 --> 00:00:18,897
הרמת ידיים, כמה מכל מה שאתה
הגיע לקטע סופר בשבוע שעבר?

7
00:00:18,897 --> 00:00:19,480
אישור, זה בסדר.

8
00:00:19,480 --> 00:00:20,020
זה בסדר.

9
00:00:20,020 --> 00:00:23,110
כמה מכם צפה
סעיף העל בשבוע שעבר?

10
00:00:23,110 --> 00:00:23,610
אוקיי.

11
00:00:23,610 --> 00:00:25,702
ואתם עשו בסדר
על בעיה להגדיר אחד?

12
00:00:25,702 --> 00:00:28,660
אז אני הולך לקחת את זה שיש לנו
חבורה של ילדים ממש חכמים

13
00:00:28,660 --> 00:00:32,310
בכיתה ודברים זה יהיה בסדר.

14
00:00:32,310 --> 00:00:33,180
אוקיי.

15
00:00:33,180 --> 00:00:33,980
אז first--

16
00:00:33,980 --> 00:00:37,900

17
00:00:37,900 --> 00:00:41,090
>> ראשית, אנחנו פשוט הולכים לזמן קצר
לעבור על סדר היום להיום.

18
00:00:41,090 --> 00:00:42,700
נדבר על לוגיסטיקה כמובן.

19
00:00:42,700 --> 00:00:45,480
הרבה אתה כנראה
יש לך שאלות בנוגע ל

20
00:00:45,480 --> 00:00:46,920
איך דברים מתנהל בקורס זה.

21
00:00:46,920 --> 00:00:47,897
אנחנו לענות עליהן.

22
00:00:47,897 --> 00:00:49,730
אנחנו הולכים לזמן קצר
לעבור על לולאות במקרה

23
00:00:49,730 --> 00:00:51,410
כולכם החמיץ סעיף סופר.

24
00:00:51,410 --> 00:00:53,240
נדבר על מיפוי ASCII.

25
00:00:53,240 --> 00:00:56,180
נדבר על מערכים,
פונקציות, טיעוני שורת הפקודה.

26
00:00:56,180 --> 00:01:00,210
ולבסוף, מה אתם כנראה כל
באמת רוצה להיות כאן כדי ללמוד על,

27
00:01:00,210 --> 00:01:01,270
הוא pset2.

28
00:01:01,270 --> 00:01:04,209
תהיה לנו כמה טריקים נחמדים
וטיפים לאיך לעשות את זה.

29
00:01:04,209 --> 00:01:07,910

30
00:01:07,910 --> 00:01:08,690
>> אוקיי.

31
00:01:08,690 --> 00:01:11,450
כמו כן, שנית, יש לנו
המון ממתקים כאן.

32
00:01:11,450 --> 00:01:13,583
כל מי שאוהב ממתקים,
רק לבוא לכאן.

33
00:01:13,583 --> 00:01:14,430
לתפוס קצת.

34
00:01:14,430 --> 00:01:15,100
יש לי חבורה.

35
00:01:15,100 --> 00:01:16,390
יש לנו המון במשרד.

36
00:01:16,390 --> 00:01:18,230
אני לא באמת רוצה
לאכול ממתקים כל היום.

37
00:01:18,230 --> 00:01:20,300
אתם צריכים לאכול את כל הממתקים,
כי אני הבאתי אותו כאן בשבילכם.

38
00:01:20,300 --> 00:01:20,990
פשוט לאכול ממתקים.

39
00:01:20,990 --> 00:01:24,080
שיהיה ממתקים בכל סעיף.

40
00:01:24,080 --> 00:01:25,330
>> אז קודם כל, מי אני?

41
00:01:25,330 --> 00:01:27,080
השם שלי הוא אנדי פנג.

42
00:01:27,080 --> 00:01:30,270
אני הראש ת"א של CS50 כאן באוניברסיטת ייל.

43
00:01:30,270 --> 00:01:32,540
ובנוסף ל
כי, אני גם להיות--

44
00:01:32,540 --> 00:01:35,600
אם מישהו היה like-- הריצה שלך
חבר, כתף לבכות עליה.

45
00:01:35,600 --> 00:01:39,140
אם בלילה שלפני עקב של pset,
אין לך מושג מה קורה,

46
00:01:39,140 --> 00:01:40,080
להכות אותי.

47
00:01:40,080 --> 00:01:42,770
אנחנו בצער יחד, וכולי.

48
00:01:42,770 --> 00:01:46,100
רק יודע שאני כאן כ
משאבים עבורך כקו החזית

49
00:01:46,100 --> 00:01:51,830
בעוזרים לך להבין איך בחורים
כדי לפתור בעיות בCS50 ומעבר.

50
00:01:51,830 --> 00:01:54,590
>> כתובת הדוא"ל שלי היא andi.peng@yale.edu.

51
00:01:54,590 --> 00:01:58,390
אני גם שולח בודד
דוא"ל עם מספר הטלפון שלי בזה

52
00:01:58,390 --> 00:02:01,860
כך שלא כולם ב
אינטרנט יכול לראות את מספר הטלפון שלי.

53
00:02:01,860 --> 00:02:03,640
אתה מוזמן להתקשר אליי בכל עת.

54
00:02:03,640 --> 00:02:07,510
ברצינות, הטלפון שלי הוא
בדרך כלל מצורף ליד שלי.

55
00:02:07,510 --> 00:02:10,240
אני לא יכול להגיב
בתוך כמה דקות.

56
00:02:10,240 --> 00:02:11,984
אני לא יכול להגיב בתוך כמה שעות.

57
00:02:11,984 --> 00:02:14,400
אבל אני יכול להבטיח לך, אם
אתה דואר אלקטרוני אותי, אם אתה קורא לי,

58
00:02:14,400 --> 00:02:17,404
טקסט אותי, אני אגיב תוך 24 שעות.

59
00:02:17,404 --> 00:02:19,820
לעתים קרובות, אני נגיב לפני
כי, משום שאני מבין

60
00:02:19,820 --> 00:02:23,900
כי לכולם יש כמה בעיות,
ואתה רוצה תשובות שלך

61
00:02:23,900 --> 00:02:26,110
להיות ענה מהר מאוד.

62
00:02:26,110 --> 00:02:28,945
>> עם זאת, אם אתה קורא
30 דקות לפניי

63
00:02:28,945 --> 00:02:31,570
חתיכה שנובע יום חמישי
night-- להיות כמו, אנדי, יעזור לי,

64
00:02:31,570 --> 00:02:35,380
אני לא started-- אני יכול לתת לי
אתה הכתף לבכות על ש.

65
00:02:35,380 --> 00:02:41,520
אבל אולי הגיע זמן לחשוב על
איך לא לעשות את זה בפעם הבאה.

66
00:02:41,520 --> 00:02:44,040
אוקיי.

67
00:02:44,040 --> 00:02:44,944
אופס.

68
00:02:44,944 --> 00:02:45,850
איך אני חוזר?

69
00:02:45,850 --> 00:02:48,140
הנה.

70
00:02:48,140 --> 00:02:52,310
>> אז בקורס זה, יש לנו
טון של תמיכה לכולם.

71
00:02:52,310 --> 00:02:54,640
בנוסף פשוט
חלקים כאן, שבו אתה

72
00:02:54,640 --> 00:02:57,000
בכל שבוע מקבל לבלות 90
דקות נפלאות איתי,

73
00:02:57,000 --> 00:02:58,330
יש לנו גם שעתי עבודה.

74
00:02:58,330 --> 00:03:01,021
כמה מכם יש כבר
היה לשעתי עבודה לעזרה?

75
00:03:01,021 --> 00:03:01,520
גדול.

76
00:03:01,520 --> 00:03:05,700
זה באמת טוב לראות, כי אנחנו
יש צוות של מעל 45 TAS ורשויות אישורים

77
00:03:05,700 --> 00:03:11,780
הוכשר לקורס זה שהם כאן
על שעזרת לכם עם psets.

78
00:03:11,780 --> 00:03:14,580
>> ימים שני הם החזיקו בצהבהבים
כיתה בבית היל 17 כאן

79
00:03:14,580 --> 00:03:15,350
באוניברסיטת ייל.

80
00:03:15,350 --> 00:03:17,349
ימי שלישי וחמישי,
הם החזיקו בנחלת כלל.

81
00:03:17,349 --> 00:03:20,010
8:00-11:00 פחות או יותר בכל יום חול.

82
00:03:20,010 --> 00:03:21,620
בואו, בוא החוצה.

83
00:03:21,620 --> 00:03:24,030
כל בעיה, לא problem--
רק לבוא ב,

84
00:03:24,030 --> 00:03:26,650
ואז אנחנו נעזור לך לצאת עם זה.

85
00:03:26,650 --> 00:03:31,640
>> שנית, בנוסף לשעתי עבודה
וחתכים, יש לנו גם מכנסיים קצרים.

86
00:03:31,640 --> 00:03:35,930
האם מישהו אי פעם ראה כמה
מכנסיים קצרים או ערוצים בקטעי הווידאו

87
00:03:35,930 --> 00:03:36,750
באתר?

88
00:03:36,750 --> 00:03:37,250
אוקיי.

89
00:03:37,250 --> 00:03:39,510
אז הם באמת, באמת מועילים.

90
00:03:39,510 --> 00:03:42,470
ייצור הרווארד היפה שלנו
צוות שם בבית הספר ש

91
00:03:42,470 --> 00:03:47,910
בצפון, הם צילמו והפיק
קטעי וידאו הדרכה המדהים הללו.

92
00:03:47,910 --> 00:03:52,290
>> הם ייקחו אותך צעד אחר צעד ב
איך ללכת על פתרון בעיה.

93
00:03:52,290 --> 00:03:56,340
לעתים קרובות, אם אתה מבולבל על
רעיון פשוט, רעיון ייחודי,

94
00:03:56,340 --> 00:03:59,780
תסתכל, כי אנחנו כנראה יש לי
קצר על זה איפשהו באתר שלנו.

95
00:03:59,780 --> 00:04:03,800
וזה בדרך כלל משאב נהדר
לחפש כאשר אתה ראשון

96
00:04:03,800 --> 00:04:06,510
איבד על איך להתמודד עם בעיה.

97
00:04:06,510 --> 00:04:09,750
>> שלישית, יש לנו גם
study50 וreference50.

98
00:04:09,750 --> 00:04:15,650
אז ללמוד 50 ב
אתר הוא רק קישור.

99
00:04:15,650 --> 00:04:21,500
זה, אני חושב, study.cs50.net
או משהו כזה.

100
00:04:21,500 --> 00:04:22,860
פשוט גוגל זה.

101
00:04:22,860 --> 00:04:24,229
יש לנו המון שקופיות שהוכנו.

102
00:04:24,229 --> 00:04:26,770
יש לנו הרבה מכנסיים קצרים ו
דברים walkthroughs-- כל הידור

103
00:04:26,770 --> 00:04:31,070
נחמד מאוד ומסודר לכולכם
כדי לדפדף, לראות כל מושגים

104
00:04:31,070 --> 00:04:32,860
שאתה מבולבל לגבי.

105
00:04:32,860 --> 00:04:35,920
זה הייתי כנראה להיות מכוסה
שם בstudy50.

106
00:04:35,920 --> 00:04:37,640
>> Reference50-- דומה.

107
00:04:37,640 --> 00:04:41,510
יש לנו הרבה הערות שונות
זמין לרשותכם.

108
00:04:41,510 --> 00:04:44,450
ולבסוף, יש לנו מה
נקרא CS50 דיון,

109
00:04:44,450 --> 00:04:48,082
פורום שבו, אם בלילה שלפני
אתה עושה בעיות שלך, אומר,

110
00:04:48,082 --> 00:04:49,880
יש לך שאלה.

111
00:04:49,880 --> 00:04:52,340
התחבר כדי CS50 דיון.

112
00:04:52,340 --> 00:04:53,190
פרסם את השאלה שלך.

113
00:04:53,190 --> 00:04:55,820
ואז אחד hundreds--
אולי, thousands-- של עמיתים

114
00:04:55,820 --> 00:04:57,960
לוקח המעמד הזה באינטרנט להתחבר.

115
00:04:57,960 --> 00:05:01,182
ואולי מישהו יכול לקבל
התשובה שלך לפני שפחית ת"א.

116
00:05:01,182 --> 00:05:03,390
זה בעצם רק
פורום מקוון שכולנו יכול

117
00:05:03,390 --> 00:05:04,556
להשתמש בו כדי לדון בבעיות שלנו.

118
00:05:04,556 --> 00:05:06,483
זה מגניב.

119
00:05:06,483 --> 00:05:10,660

120
00:05:10,660 --> 00:05:11,550
>> אוקיי.

121
00:05:11,550 --> 00:05:13,220
אז בעיה קובעת.

122
00:05:13,220 --> 00:05:17,840
אנחנו עומדים ממש ב
עבה של בעיה להגדיר שני.

123
00:05:17,840 --> 00:05:20,570
הרבה מאתנו יש כבר
נאבק בבעיה להגדיר אחד.

124
00:05:20,570 --> 00:05:24,460
אנחנו כבר יודעים שאולי מחכים
לאמש לעשות pset

125
00:05:24,460 --> 00:05:28,170
זה לא הדבר הכי חכם לעשות בCS50.

126
00:05:28,170 --> 00:05:32,380
>> טיפים ועצות במהות ל
הצלחה היא לקרוא את כל המפרט.

127
00:05:32,380 --> 00:05:36,270
כמה מכם יש כבר
לקרוא את המפרט לpset 2?

128
00:05:36,270 --> 00:05:36,770
אוקיי.

129
00:05:36,770 --> 00:05:39,840
זה סכום מוצק.

130
00:05:39,840 --> 00:05:43,210
אני יודע שאתם כנראה הכירו
עכשיו המפרט הוא באמת ארוך.

131
00:05:43,210 --> 00:05:45,700
הם באמת, באמת ארוכים.

132
00:05:45,700 --> 00:05:49,630
>> זה ממש קשה לקרוא כל שורה
של שמילה בקפידה על ידי מילה.

133
00:05:49,630 --> 00:05:52,780
אתה רוצה רק כדי לרחף למקום שבי
זה אומר לך לעשות משהו.

134
00:05:52,780 --> 00:05:54,459
אני יכול להבטיח לך, אל תעשה את זה.

135
00:05:54,459 --> 00:05:56,750
אם אתה עושה את זה, אתה כנראה
הולך לפספס איפשהו

136
00:05:56,750 --> 00:05:58,458
שבו הוא אומר לך
איך להתחיל בעיה

137
00:05:58,458 --> 00:06:01,140
או שזה אומר לך מה לשם
הבעיה שלך או שזה אומר לך,

138
00:06:01,140 --> 00:06:03,720
זה כנראה הדרך הטובה ביותר
להתחיל לעשות את הבעיה שלך.

139
00:06:03,720 --> 00:06:05,050
ואז אתה תהיה אבוד.

140
00:06:05,050 --> 00:06:08,219
>> כאשר אתה מנסה לקרוא שלך
spec באמצע,

141
00:06:08,219 --> 00:06:10,510
הרבה החשוב
information-- בכי אתה לא

142
00:06:10,510 --> 00:06:12,260
הולך להיות מסוגל באמת גישה.

143
00:06:12,260 --> 00:06:13,219
אז לקרוא את כל המפרט.

144
00:06:13,219 --> 00:06:15,468
נסה לקרוא את כל המפרט
לפני שאתם מגיעים לקטע,

145
00:06:15,468 --> 00:06:17,360
כי אז, כאשר אנו
לדבר על pset,

146
00:06:17,360 --> 00:06:21,070
כל יכול יש לנו רעיון
של מה שקורה.

147
00:06:21,070 --> 00:06:25,169
>> שנית, מדובר בקונספט
שאני רוצה להפנות

148
00:06:25,169 --> 00:06:26,710
הרבה לאורך כל סמסטר הקורס.

149
00:06:26,710 --> 00:06:30,070
אבל בעצם, לפגוש אותנו באמצע הדרך, נכון?

150
00:06:30,070 --> 00:06:33,970
שלי, כמו ת"א וג'ייסון כקורס
מנהל וScaz כפרופסור שלך

151
00:06:33,970 --> 00:06:37,120
ודוד כפרופסור וכולך
TAS היפה האחר בקורס זה,

152
00:06:37,120 --> 00:06:39,830
עוזרים בcourse-- זה
אנחנו עושים כמיטב יכולתנו

153
00:06:39,830 --> 00:06:42,965
כדי להבטיח שאתה מגדיר
עד כדי להצליח בקורס זה.

154
00:06:42,965 --> 00:06:43,840
אנחנו יקיימו את החלק.

155
00:06:43,840 --> 00:06:44,870
אנחנו יקיימו שעתי עבודה.

156
00:06:44,870 --> 00:06:47,087
אנו לענות לטלפון שלך
שיחות, לענות הודעות הדואר האלקטרוני שלך,

157
00:06:47,087 --> 00:06:49,670
לעשות כל מה שאנחנו יכולים לעשות
בטוח השאלות שלך נענות.

158
00:06:49,670 --> 00:06:51,460
>> עם זאת, לעזור לנו יותר מדי.

159
00:06:51,460 --> 00:06:52,450
לפגוש אותנו באמצע הדרך.

160
00:06:52,450 --> 00:06:56,040
אם אתה בא לשעתי עבודה
לא שהלכתי לסעיף, לא

161
00:06:56,040 --> 00:07:02,060
אחרי שראה את ההרצאות, שאין לו
המושג מה קורה, להיות כמו, יעזור לי.

162
00:07:02,060 --> 00:07:04,350
אני הולך להיות כמו, כן, אני מצטער.

163
00:07:04,350 --> 00:07:06,410
זה יכול להיות זמן להלוות
הכתף לבכות על ש,

164
00:07:06,410 --> 00:07:08,959
כי אני לא בטוח
מה אני יכול לעשות כדי לעזור לך

165
00:07:08,959 --> 00:07:12,000
אם אתה לא מנסה לפחות לעזור
את עצמך קצת בהתחלה.

166
00:07:12,000 --> 00:07:12,910
לפגוש אותנו באמצע הדרך.

167
00:07:12,910 --> 00:07:15,020
אתה יודע, בבקשה לבוא
מוכן לענות ולקבל

168
00:07:15,020 --> 00:07:16,353
מוכן לעסוק בחומר.

169
00:07:16,353 --> 00:07:19,342
זה עושה כל כך הרבה דברים
קל יותר לכל המעורבים.

170
00:07:19,342 --> 00:07:22,970
כן, זה די הרבה זה.

171
00:07:22,970 --> 00:07:23,720
>> דירוג.

172
00:07:23,720 --> 00:07:29,250
אז בתכנית הלימודים, זה די
לגבי מעמיק כיצד אנו כיתה.

173
00:07:29,250 --> 00:07:32,440
אבל בעצם, ההתמוטטות
בזה הוא 50% מהציון שלך

174
00:07:32,440 --> 00:07:34,530
יהיה psets, ש
הוא נחמד, כי זה

175
00:07:34,530 --> 00:07:37,400
שבו אתה מבלה את הרוב
רוב הזמן כמובן שלך על.

176
00:07:37,400 --> 00:07:39,854
בחנים 40%, ושלך
פרויקט גמר יהיה 10%.

177
00:07:39,854 --> 00:07:42,520
יהיו שני בחנים בכל
במהלך הסמסטר.

178
00:07:42,520 --> 00:07:47,050
אני חושב פעמים והתאריכים
גם מופיע בתכנית הלימודים.

179
00:07:47,050 --> 00:07:49,210
>> הדרך שתהיינה
להיות לדירוג psets

180
00:07:49,210 --> 00:07:53,930
הוא שיש לנו בעצם ארבעה
ערכים שאנו מקצים לכל כיתה.

181
00:07:53,930 --> 00:07:57,250
יש לנו ערך של היקף,
תקינות, עיצוב וסגנון.

182
00:07:57,250 --> 00:08:01,530
אז כפי שאתם רואים, זה סוג שלנו
נוסחה לחישוב psets.

183
00:08:01,530 --> 00:08:03,640
שלושה אנחנו נותנים ביותר
משקל לנכונותו,

184
00:08:03,640 --> 00:08:06,140
כי ברור שהמאמן שלך
יש בדיקה למקרים

185
00:08:06,140 --> 00:08:08,480
כי אנחנו רוצים את זה לבדיקה.

186
00:08:08,480 --> 00:08:11,000
>> יש לכם את כל
check50 לרשותכם.

187
00:08:11,000 --> 00:08:13,730
זה פונקציה שימושית מאוד
שכולכם יכולים

188
00:08:13,730 --> 00:08:17,560
להעלות את הקוד שלך לשרתים שלנו,
שבו אנחנו נבדוק את זה בשבילך.

189
00:08:17,560 --> 00:08:20,800
ושראית אותם
Frowny פנים, פרצופים מחייכים.

190
00:08:20,800 --> 00:08:22,119
הם באמת, באמת מועילים.

191
00:08:22,119 --> 00:08:23,910
נא לא להיות
תלמיד שרוצה ניסיונות

192
00:08:23,910 --> 00:08:26,230
לhardcode בכל התשובות להם.

193
00:08:26,230 --> 00:08:30,050
אני בהחלט ראיתי בי pset
מישהו ראה את כל הערכים של check50

194
00:08:30,050 --> 00:08:33,429
והם פשוט קשים מקודדים in-- אם
מספר זה, להדפיס את המספר הזה.

195
00:08:33,429 --> 00:08:35,080
אם מספר ש, להדפיס את המספר הזה.

196
00:08:35,080 --> 00:08:36,090
אל תעשה את זה.

197
00:08:36,090 --> 00:08:39,360
>> למרות שבחינה טכנית
check50 הוא נכון,

198
00:08:39,360 --> 00:08:41,809
הדרך לפתרון שלך
הבעיה היא לא נכונה.

199
00:08:41,809 --> 00:08:45,770
אז פשוט להשתמש check50 במשורה.

200
00:08:45,770 --> 00:08:48,497
אבל גם לוודא שאתה
להבין איך זה פועל,

201
00:08:48,497 --> 00:08:50,580
התכנית פועלת
בנוסף לcheck50,

202
00:08:50,580 --> 00:08:53,120
כי אנחנו לא יכולים לבדוק כל
מקרה אפשרי של check50.

203
00:08:53,120 --> 00:08:55,440
אנחנו נהיה בדיקה כמה מהם.

204
00:08:55,440 --> 00:09:00,390
>> עיצוב הוא למעשה, כיצד
מתוכנן היטב הוא את הקוד שלך?

205
00:09:00,390 --> 00:09:04,150
אם אתה מרובה עותק-הדבקה
שורות קוד רב, פעמים רבות.

206
00:09:04,150 --> 00:09:06,960
אולי אתה לא צריך למדי
העיצוב הטוב ביותר בקוד שלך.

207
00:09:06,960 --> 00:09:09,470
אולי זה זמן להוסיף לולאה ש.

208
00:09:09,470 --> 00:09:12,090
בעיקרו של דבר, כאן זה רק כל
על מנסה לעשות את הקוד שלך,

209
00:09:12,090 --> 00:09:17,010
מנסה לכתוב את הקוד שלך בצורה יעילה
ככל האפשר, כך שהתכנית שלך פועלת

210
00:09:17,010 --> 00:09:19,630
מהר ככל האפשר.

211
00:09:19,630 --> 00:09:20,996
>> לבסוף, יש לנו סגנון.

212
00:09:20,996 --> 00:09:24,360
אז סגנון הוא סוג של
שרירותי, מונח סובייקטיבי.

213
00:09:24,360 --> 00:09:27,470
אני יודע שיש לנו באופן רשמי
מדריך סגנון 50 לCS50,

214
00:09:27,470 --> 00:09:30,050
שבו הוא אומר לך, אה, אתה
צריך מקום כאן.

215
00:09:30,050 --> 00:09:32,220
אתה צריך סוג של פורמט
הקוד שלך בדרך זו.

216
00:09:32,220 --> 00:09:34,070
אתה צריך שם דברים בדרך זו.

217
00:09:34,070 --> 00:09:38,180
>> באמת לא אכפת לי, כשלעצמה, איך
אתה בוחר סגנון הקוד שלך,

218
00:09:38,180 --> 00:09:39,840
רק כל עוד אתה נשאר עקבי.

219
00:09:39,840 --> 00:09:43,732
לדוגמא, אם אתה רוצה
להשאיר רווח אחרי הארבעה

220
00:09:43,732 --> 00:09:45,690
לפני ארבע הלולאה שלך,
רק לעשות את זה בכל פעם.

221
00:09:45,690 --> 00:09:46,523
לא סוג של לעשות את זה.

222
00:09:46,523 --> 00:09:47,730
אל תעשה את זה פעמים אחרות.

223
00:09:47,730 --> 00:09:51,046
אם אתה רוצה לשמור מתולתל
שטח פלטה בצורה מסוימת,

224
00:09:51,046 --> 00:09:52,170
פשוט תמיד לעשות את זה ככה.

225
00:09:52,170 --> 00:09:54,628
לא סוג של לעשות את זה איפשהו
פה ואי שם לא שם.

226
00:09:54,628 --> 00:09:57,010
כאשר אנחנו דירוג,
זה באמת קשה

227
00:09:57,010 --> 00:09:59,420
אם אין לי מושג איך
אתה עיצוב הקוד שלך,

228
00:09:59,420 --> 00:10:02,064
דברים מטורפים ומחוץ למקום.

229
00:10:02,064 --> 00:10:04,980
אם אתה פשוט לשמור אותו עולה בקנה אחד, זה
הרבה יותר קל לי כגדול יותר

230
00:10:04,980 --> 00:10:06,310
כדי להיות מסוגל לקרוא את הקוד שלך.

231
00:10:06,310 --> 00:10:09,393
זה הרבה יותר קל לך כסטודנט
כדי להיות מסוגל להסתכל דרך הקוד שלך

232
00:10:09,393 --> 00:10:11,720
ולראות מה לא בסדר עם
זה לחתוך למה יש בעיות.

233
00:10:11,720 --> 00:10:15,740
סגנון הוא אחד הדברים הקלים ביותר
אתם יכולים לעשות כדי לקבל ציונים מלאים.

234
00:10:15,740 --> 00:10:18,770
בעיקרו של דבר, אם אתה רק אכפת, אם
אתה משלם חמש דקות של תשומת לב

235
00:10:18,770 --> 00:10:22,760
הקוד שלך כל שבוע, אתה צריך
להיות מקבלים נקודות בסגנון מלאה.

236
00:10:22,760 --> 00:10:26,020
>> לבסוף, יש לנו מה שנקרא
המכפיל של היקף.

237
00:10:26,020 --> 00:10:28,890
Scope-- אני יודע שזה גדול
מילה, במיוחד במעמד הזה.

238
00:10:28,890 --> 00:10:31,030
אבל היקף, בכל אמצעים ש
הוא שאתה מנסה

239
00:10:31,030 --> 00:10:33,670
psets למיטב יכולתך.

240
00:10:33,670 --> 00:10:37,180
אם תפעיל בשלושה מתוך
ארבע הבעיות שלך

241
00:10:37,180 --> 00:10:39,460
ואפילו לא מנסה
אחרון, אתה כנראה

242
00:10:39,460 --> 00:10:41,630
הולך לאבד כמה נקודות בהיקף.

243
00:10:41,630 --> 00:10:44,560
>> גם אם אתה רק מתחיל בעיה,
לעשות את המיטב כדי לעבור אותו.

244
00:10:44,560 --> 00:10:47,691
גם אם זה לא עובד, פונה בזה,
משום שמראה ומדגים

245
00:10:47,691 --> 00:10:50,190
לנו שאתה מנסה, ש
אתה ניסית את הבעיה להגדיר

246
00:10:50,190 --> 00:10:51,430
למיטב יכולתך.

247
00:10:51,430 --> 00:10:53,800
ואז אנחנו יכולים לתת לך
נקודות מלאה להיקף.

248
00:10:53,800 --> 00:10:58,715
>> היקף הוא גם חשוב מאוד עבורנו כאשר
מדבר על ירידת ציון pset הנמוכה ביותר.

249
00:10:58,715 --> 00:11:02,010
אז במהלך
סמסטר, יש לכם תשע psets.

250
00:11:02,010 --> 00:11:05,340
ואנחנו יהיו למעשה יורדים
הציון הנמוך ביותר מאלה תשע,

251
00:11:05,340 --> 00:11:07,670
אבל רק אם יש לך נקודות היקף מלאה.

252
00:11:07,670 --> 00:11:11,120
>> אז אם אתה פונה בpset שלם,
למרבה הצער, אנחנו לא יכולים לרדת כי אחד,

253
00:11:11,120 --> 00:11:13,540
בגלל ההיקף שלך
נקודות לא הושלמו.

254
00:11:13,540 --> 00:11:16,570
אז גם אם יש לך את השבוע הנורא
שבו אתה מת ואתה חולה

255
00:11:16,570 --> 00:11:20,040
או הכלב שלך מת, החתול שלך מת,
ואתה עמוס בשיעורי בית,

256
00:11:20,040 --> 00:11:21,074
רק אנסה pset.

257
00:11:21,074 --> 00:11:22,490
לעשות את זה על הצד הטוב ביותר של היכולת שלך.

258
00:11:22,490 --> 00:11:23,840
אם זה לא עובד, זה לא משנה.

259
00:11:23,840 --> 00:11:24,506
רק להפעיל אותו ב.

260
00:11:24,506 --> 00:11:26,590
לפחות אנחנו יכולים לתת
אתה מצביע על מאמץ.

261
00:11:26,590 --> 00:11:28,510
>> למאמץ בכיתה זו.

262
00:11:28,510 --> 00:11:30,170
בירידת הציון הנמוכה ביותר לפחות למאמץ.

263
00:11:30,170 --> 00:11:32,354
אז כן.

264
00:11:32,354 --> 00:11:33,270
זה פחות או יותר אותו.

265
00:11:33,270 --> 00:11:36,521
למישהו יש שאלות כל כך
הרבה על איך אנחנו כיתה בכיתה?

266
00:11:36,521 --> 00:11:37,187
או כל אחד מאלה?

267
00:11:37,187 --> 00:11:41,220
כל אלה כל כך far--
סעיפים, שעתי עבודה?

268
00:11:41,220 --> 00:11:41,720
מגניב.

269
00:11:41,720 --> 00:11:46,720

270
00:11:46,720 --> 00:11:47,800
אוקיי.

271
00:11:47,800 --> 00:11:51,260
>> אז זה נושא שלא
אחד לא באמת אוהב לדבר עליו.

272
00:11:51,260 --> 00:11:53,084
אני לא ממש רוצה לדבר על זה.

273
00:11:53,084 --> 00:11:55,250
אתם לא באמת רוצים
לשמוע אותי מדבר על זה.

274
00:11:55,250 --> 00:11:57,690
אך למרבה הצער, כולנו
צריך לדבר על זה.

275
00:11:57,690 --> 00:12:00,110
דוד בילה 20 דקות
הרצאה מדברת על זה.

276
00:12:00,110 --> 00:12:02,580
וכי הוא הנושא
יושר אקדמי.

277
00:12:02,580 --> 00:12:08,110
>> אז כולנו כאן כנראה נכתבו
מתישהו מאמר בקריירה שלנו ייל.

278
00:12:08,110 --> 00:12:11,800
כנראה שאנחנו מקבלים שיחה בי יש לנו
כבר אמר לא לגנוב המאמר שלנו,

279
00:12:11,800 --> 00:12:13,940
בגלל שהעבודה היא לא שלנו.

280
00:12:13,940 --> 00:12:18,109
במדעי מחשב, יש לנו
אותו הסוג של מושג.

281
00:12:18,109 --> 00:12:20,150
כל העבודה שאתה שולח,
כל הקוד שאתה כותב

282
00:12:20,150 --> 00:12:21,900
צריך להיות קוד שכתבת.

283
00:12:21,900 --> 00:12:24,280
לא צריך להיות קוד שיש לך
הועתק ממקום אחר.

284
00:12:24,280 --> 00:12:26,777
לא צריך להיות קוד ש
אתה כבר בגוגל וצנחת ב

285
00:12:26,777 --> 00:12:28,360
ואתה לא באמת יודע אם זה עובד.

286
00:12:28,360 --> 00:12:32,440
אתה סוג של יש תחושה של
מה הוא עושה, אבל לא ממש.

287
00:12:32,440 --> 00:12:36,562
במקרה של ספק, בעצם,
זה פשוט להיות סביר.

288
00:12:36,562 --> 00:12:38,520
בתכנית הלימודים שלנו, יש לנו
רשימה שלמה של דברים

289
00:12:38,520 --> 00:12:40,560
אנו רואים סבירים כ
לעומת לא סביר.

290
00:12:40,560 --> 00:12:43,820
>> לדוגמא, סביר
הוא שאתה וחבר שלך

291
00:12:43,820 --> 00:12:47,360
דיון מה הדרך הטובה ביותר ללכת
על לוגי פתרון בעיה.

292
00:12:47,360 --> 00:12:48,910
זה די סביר.

293
00:12:48,910 --> 00:12:53,244
מה לא יהיה סביר הוא אם אתה
בחורים הגיעו יחד, הקלידו אותו הקוד,

294
00:12:53,244 --> 00:12:54,410
ופנה באותו הקוד.

295
00:12:54,410 --> 00:12:56,302
זה לא סביר.

296
00:12:56,302 --> 00:12:57,510
אותו דבר, סוג של חיבור.

297
00:12:57,510 --> 00:12:59,290
אם אתה רוצה לדון ב
עם חבר שלך, היי,

298
00:12:59,290 --> 00:13:00,220
זה מה שאני רוצה לכתוב על.

299
00:13:00,220 --> 00:13:02,500
אלה הם הצעדים שאני רוצה
לקחת לכתוב על זה, גדול.

300
00:13:02,500 --> 00:13:03,208
זה נפלא.

301
00:13:03,208 --> 00:13:04,790
אנא לשתף פעולה אחד עם השני.

302
00:13:04,790 --> 00:13:06,540
אם אתם מתחילים
כתיבה אותו הדבר,

303
00:13:06,540 --> 00:13:10,020
להפוך באותו המאמר, זה פחות אישור.

304
00:13:10,020 --> 00:13:13,200
אז במקרה של ספק, פשוט לא עושה את זה.

305
00:13:13,200 --> 00:13:16,940
>> כאן, בCS50, יש לנו אנחנו סקריפטים
שהריצה כדי להפוך לבדוק

306
00:13:16,940 --> 00:13:21,740
לא רק את נכונות הקוד שלך,
אלא גם את ייחודו של הקוד שלך.

307
00:13:21,740 --> 00:13:25,920
אז בבקשה, אל תעמידו אותנו בעמדה
שיש להתייחס למקרה שלך EXCOMM.

308
00:13:25,920 --> 00:13:31,110
בבקשה, רק לכולם, בואו פשוט
להפוך את זה לחוויה נפלאה.

309
00:13:31,110 --> 00:13:33,600
כולם לומדים טובים יותר,
כולנו מאושרים יותר,

310
00:13:33,600 --> 00:13:37,926
וכולנו להגדיר ל
להצליח בקורס זה.

311
00:13:37,926 --> 00:13:39,800
משהו שהוא מאוד
ייחודי על זה בכיתה

312
00:13:39,800 --> 00:13:42,660
כי אני חושב שכולם באמת צריך
לשים לב אליה הוא שיש לנו

313
00:13:42,660 --> 00:13:44,930
מה שנקרא החרטה
סעיף בתכנית הלימודים שלנו.

314
00:13:44,930 --> 00:13:50,010
אז בעצם, בתוך 72 שעות, אם
אתה מאמין שאתה עשית משהו

315
00:13:50,010 --> 00:13:53,240
אתה לא ממש בטוח ש
מתאים, בבקשה לבוא אלינו.

316
00:13:53,240 --> 00:13:57,220
אנו מבטיחים לכם שתוך 72 שעות
אנחנו נטפל במקרה עצמנו

317
00:13:57,220 --> 00:13:59,820
מבלי להתייחס לגבוה יותר
סמכות בממשל.

318
00:13:59,820 --> 00:14:03,100
>> אז אם אתה בא אליי ואומר,
אנדי, היי, אני באמת מצטער,

319
00:14:03,100 --> 00:14:07,620
אבל אני חושב שיש כמה קווים בי
קוד אמש שאני סוג של בגוגל,

320
00:14:07,620 --> 00:14:10,120
ירד מסטאק
גלישה, להעתיק ולהדביק,

321
00:14:10,120 --> 00:14:13,680
ואני באמת, באמת מצטער
על זה, תודיע לי.

322
00:14:13,680 --> 00:14:16,900
נא לא רק לתת לו מוגלה
ורק מקווה שאני תופס את זה.

323
00:14:16,900 --> 00:14:17,784
אנו לתפוס אותו.

324
00:14:17,784 --> 00:14:18,450
רק תבואו אליי.

325
00:14:18,450 --> 00:14:20,520
תודיע לי תוך 72 שעות.

326
00:14:20,520 --> 00:14:22,240
אנחנו להבין פתרון.

327
00:14:22,240 --> 00:14:26,679
ואנו מבטיחים כי לא נתייחס ל
רשויות אוניברסיטה במהות.

328
00:14:26,679 --> 00:14:29,220
אז זה לטובתך
רק להיות כנה עם כולם

329
00:14:29,220 --> 00:14:31,720
מעורב בקורס.

330
00:14:31,720 --> 00:14:34,630
>> אוקיי.

331
00:14:34,630 --> 00:14:35,240
אוקיי.

332
00:14:35,240 --> 00:14:37,800
אז עכשיו, במהירות לפני ש
אני עובר על, עושה כל אחד

333
00:14:37,800 --> 00:14:42,670
יש לך שאלות בנוגע ללוגיסטיקה
על איך קורסים שאנחנו הולכים לרוץ,

334
00:14:42,670 --> 00:14:45,982
איך חלקים הולכים
לרוץ, כל זה?

335
00:14:45,982 --> 00:14:46,711
אוקיי.

336
00:14:46,711 --> 00:14:47,210
כן.

337
00:14:47,210 --> 00:14:48,126
>> קהל: [לא ברור]?

338
00:14:48,126 --> 00:14:50,414

339
00:14:50,414 --> 00:14:51,080
ANDI פנג: כן.

340
00:14:51,080 --> 00:14:54,850
אז quizzes-- כמה מכם
בסעיף השנייה / יום רביעי?

341
00:14:54,850 --> 00:14:56,700
כמה מכם נמצא ב
ביום שלישי / יום חמישי?

342
00:14:56,700 --> 00:14:58,550
אוקיי, אז זה פיצול מוצק כאן.

343
00:14:58,550 --> 00:15:00,900
לכן הדרך שאנחנו רצים
זה באוניברסיטת ייל הוא ש

344
00:15:00,900 --> 00:15:04,040
הולכים להיות שתי נפרדים
quizzes-- אחד לכל section-- ש

345
00:15:04,040 --> 00:15:06,160
יילקח בזמן השיעור.

346
00:15:06,160 --> 00:15:09,310
אני חושב שזה באוקטובר, סוף אוקטובר,
משהו כזה, כשבוע אחד

347
00:15:09,310 --> 00:15:10,794
של החידון.

348
00:15:10,794 --> 00:15:11,960
כן, כל כך פשוט מגיע לכיתה.

349
00:15:11,960 --> 00:15:13,920
באותו יום שני או ביום רביעי,
אתה תיקח את החידון.

350
00:15:13,920 --> 00:15:16,336
ביום שלישי או ביום חמישי,
אתה תיקח את חידון שונה.

351
00:15:16,336 --> 00:15:18,570
אבל את אותו החומר יהיה מכוסה.

352
00:15:18,570 --> 00:15:19,160
כן.

353
00:15:19,160 --> 00:15:20,660
שאלה טובה.

354
00:15:20,660 --> 00:15:21,160
כן.

355
00:15:21,160 --> 00:15:23,260
>> קהל: איפה אנחנו
ללכת לבדוק הציונים שלנו?

356
00:15:23,260 --> 00:15:23,926
>> ANDI פנג: כן.

357
00:15:23,926 --> 00:15:28,420
אז אני אשלח את
דואר אלקטרוני מה כל שבוע

358
00:15:28,420 --> 00:15:31,460
כאשר בחנים הם graded-- או,
מצטער, כאשר psets מדורג.

359
00:15:31,460 --> 00:15:34,120
Psets בדרך כלל מופעלים
בצהריים או ביום שישי.

360
00:15:34,120 --> 00:15:37,540
אז אני מבטיח שאני אעשה
לנסות להשיג אותם בחזרה אליך

361
00:15:37,540 --> 00:15:40,000
על ידי הצהריים של יום שישי הבא.

362
00:15:40,000 --> 00:15:44,950
>> בכל פעם שאני כיתה pset, אני אשלח
את הודעה על הספר בכיתה

363
00:15:44,950 --> 00:15:47,070
שאומר לך את הציון שלך
ניתן לצפות באינטרנט.

364
00:15:47,070 --> 00:15:52,022
אז זכות זו בשבוע, אחרי ש
לסיים דירוג psets בשבוע שעבר,

365
00:15:52,022 --> 00:15:54,230
אתם תקבלו דואר אלקטרוני
הודעה אומרת לך,

366
00:15:54,230 --> 00:15:55,870
היי זה המקום שבך
ללכת כדי להציג את הציונים שלך.

367
00:15:55,870 --> 00:15:57,680
ואתה יכול לראות בכל
התפלגות הציונים שלך.

368
00:15:57,680 --> 00:15:58,555
אתה יכול לראות את ההערות.

369
00:15:58,555 --> 00:16:00,360
אה, דבר מהיר גם.

370
00:16:00,360 --> 00:16:03,060
סעיף התגובה בגדול
ספר הוא המקום שבי אני בטח

371
00:16:03,060 --> 00:16:05,300
מבלה את רוב הזמן שלי לדירוג.

372
00:16:05,300 --> 00:16:07,094
אז דבר אחד זה
באמת חשוב כאשר

373
00:16:07,094 --> 00:16:09,010
אתם צופים
הציונים שלך בpsets

374
00:16:09,010 --> 00:16:11,400
הוא לא מחפש רק
בציון הפיזי

375
00:16:11,400 --> 00:16:14,630
אבל לוקח גם זמן ל
באמת לקרוא התגובות שלי.

376
00:16:14,630 --> 00:16:17,820
>> לעתים קרובות זה נותן לך משוב
על איך שאתה פתרון בעיה.

377
00:16:17,820 --> 00:16:20,480
אם אתה צריך לעשות
משהו קצת יותר טוב,

378
00:16:20,480 --> 00:16:24,080
ביקורת בונה בדרך כלל היא
הטוב ביותר שניתן בסעיף הערות אלה.

379
00:16:24,080 --> 00:16:26,950
אז בבקשה, בבקשה, אני הולך
לבלות זמן כתיבת הערות.

380
00:16:26,950 --> 00:16:30,440
אנא, הייתי ממש מעריך את זה
אם אתם היו לקרוא תגובות אלה.

381
00:16:30,440 --> 00:16:31,170
אוקיי.

382
00:16:31,170 --> 00:16:34,150
מגניב.

383
00:16:34,150 --> 00:16:34,680
>> בסדר.

384
00:16:34,680 --> 00:16:40,680
אז אנחנו הולכים להתחיל לדבר
ורק בדיקת מהירות

385
00:16:40,680 --> 00:16:45,040
חלק מהחומר מ
שבוע אפס רק כדי שאנחנו

386
00:16:45,040 --> 00:16:48,760
בעמוד הנכון עבור
מתחיל בעיות של השבוע.

387
00:16:48,760 --> 00:16:52,600
אז בזמן שהלולאה היא אחד
של שלושה הסוגים של לולאות

388
00:16:52,600 --> 00:16:54,510
שהזכרנו קודם לכן במעמד הזה.

389
00:16:54,510 --> 00:16:57,060
>> לולאה בזמן שבעצם
כתוב בתחביר

390
00:16:57,060 --> 00:17:00,666
שבו, בזמן שמצב מסוים,
לעשות את זה שוב ושוב, נכון?

391
00:17:00,666 --> 00:17:02,040
תחשוב על זה בגרפיקה זה כאן.

392
00:17:02,040 --> 00:17:04,780
אתה הולך להתחיל ב
נקודה מסוימת בקוד שלך.

393
00:17:04,780 --> 00:17:09,030
אתה הולך להיכנס למצב הלולאה
if-- אני לא יודע-- x הוא פחות מאחד.

394
00:17:09,030 --> 00:17:11,677
>> אם זה נכון, אתה הולך
כדי להפעיל את גוף הלולאה.

395
00:17:11,677 --> 00:17:14,010
ואתה הולך להמשיך לעשות
כי שוב, שוב, שוב,

396
00:17:14,010 --> 00:17:17,900
שוב וover-- ולכן זה
loop-- עד המצב שלך הופך להיות

397
00:17:17,900 --> 00:17:19,079
שווא.

398
00:17:19,079 --> 00:17:22,140
אז בדרך זו, תוך לולאה
הוא אחת הדרכים פשוטות יותר

399
00:17:22,140 --> 00:17:25,619
לכתוב כל סוג של מצב ש
צריך לחזור שוב ושוב ושוב.

400
00:17:25,619 --> 00:17:28,109
רק להיזהר בכל פעם ש
אתה כותב כל סוג של לולאה

401
00:17:28,109 --> 00:17:32,140
שיש לך מצב יציאה כ
גם עדכון לכל מה ש

402
00:17:32,140 --> 00:17:36,714
כך שהלולאה שלך לא רק
לרוץ שוב ושוב לאין שיעור.

403
00:17:36,714 --> 00:17:38,630
בכל מקרה, אתה הולך
לרוצה לוודא

404
00:17:38,630 --> 00:17:42,670
שאתה משנה היבט כלשהו של
הקוד או בסוף הלולאה שלך

405
00:17:42,670 --> 00:17:46,680
רק כדי לוודא שיש לך דרך
של התקדמות לקראת המצב

406
00:17:46,680 --> 00:17:48,400
שאתה רוצה לפגוש לסוף.

407
00:17:48,400 --> 00:17:50,239
האם זה הגיוני לכולם?

408
00:17:50,239 --> 00:17:52,530
אנחנו פשוט לא רוצים להיות
תפס בספירלה שבו זה

409
00:17:52,530 --> 00:17:55,710
אנחנו הולכים סביב סביב ו
אין דרך לשבור את הלולאה.

410
00:17:55,710 --> 00:17:58,844
וכל לולאה במהות
יש דרך לעשות את זה.

411
00:17:58,844 --> 00:17:59,344
אוקיי.

412
00:17:59,344 --> 00:18:03,030

413
00:18:03,030 --> 00:18:06,060
>> שנית, רבים מכם
בpsets מריו

414
00:18:06,060 --> 00:18:08,910
כנראה הייתי צריך להעסיק
סוג זה של לולאה.

415
00:18:08,910 --> 00:18:11,802
זה נקרא לעשות בזמן לולאה.

416
00:18:11,802 --> 00:18:14,510
קודם כל, כל אחד יכול להגיד לי
מה ההבדל בין מטלות

417
00:18:14,510 --> 00:18:16,586
תוך לולאה ולולאה בזמן שהוא?

418
00:18:16,586 --> 00:18:17,086
כן.

419
00:18:17,086 --> 00:18:21,030
>> קהל: לעשות בזמן לולאה
פועל בראשון [לא ברור].

420
00:18:21,030 --> 00:18:22,120
>> ANDI פנג: כן, בדיוק.

421
00:18:22,120 --> 00:18:27,130
אז לעשות בזמן הלולאה תמיד עושה מה ש
הוא בתוך המטלות, בתוך סוגריים

422
00:18:27,130 --> 00:18:30,520
שם ועושה מצב ש
לפני בדיקה כל-- מצטער,

423
00:18:30,520 --> 00:18:32,940
עושה קוד שלפני
בדיקת המצב.

424
00:18:32,940 --> 00:18:37,200
וזה רלוונטי במיוחד לנו
כאן במעמד הזה, משום שרוב הפעמים

425
00:18:37,200 --> 00:18:41,450
אנחנו הולכים רוצים להנחות
המשתמש לסוג כלשהו של קלט.

426
00:18:41,450 --> 00:18:43,520
ולאחר מכן, בהתאם ל
הקלט הם נותנים לנו,

427
00:18:43,520 --> 00:18:46,150
אז אנחנו יכולים להעריך, הו, לעשות
אנחנו צריכים להנחות אותם שוב?

428
00:18:46,150 --> 00:18:49,930
>> אז במריו, אם המשתמש נתן לך
גובה שלילי, למשל,

429
00:18:49,930 --> 00:18:52,990
אתה הולך לפקודה הראשונה
ולעשות כל מה שיש בתוכו.

430
00:18:52,990 --> 00:18:54,820
אז אתה הולך לבדוק אילו.

431
00:18:54,820 --> 00:18:57,570
אתה יודע, הוא שלילי 1,
הוא שמספר חיובי?

432
00:18:57,570 --> 00:19:00,680
אם זה לא, אני מתכוון ללכת
בחזרה ולחזור על המטלות וחזור

433
00:19:00,680 --> 00:19:03,950
וחזור וחזור עד ש
לבסוף אתן לך מספר שאתה אוהב,

434
00:19:03,950 --> 00:19:07,002
שכולנו יכול להעסיק בקוד שלנו.

435
00:19:07,002 --> 00:19:09,210
זה די חשוב ל
בעצם כל קלט משתמש.

436
00:19:09,210 --> 00:19:11,760
אני יכול להבטיח לך
זמן בpset בי

437
00:19:11,760 --> 00:19:15,070
אנו מבקשים מכם הקלט
כל סוג של קוד, אנחנו

438
00:19:15,070 --> 00:19:17,540
כנראה הולך לתת לך
מקרה מבחן שבו אנו נמצאים

439
00:19:17,540 --> 00:19:21,200
הולך לתת לך משהו רע זה
הולך לנסות לשבור את הקוד שלך.

440
00:19:21,200 --> 00:19:25,044
>> אם ננסה לשאול אותך לקלט
מספר שלם, אנחנו יכולים רק לתת לך מחרוזת

441
00:19:25,044 --> 00:19:26,460
ותראה איך היית להתמודד עם זה.

442
00:19:26,460 --> 00:19:30,610
אם אנו מבקשים מכם להעסיק גיל,
אנחנו יכולים לתת לך מספר שלילי

443
00:19:30,610 --> 00:19:32,340
כדי לראות איך היית להתמודד עם זה.

444
00:19:32,340 --> 00:19:37,260
רק לוודא שאתם בודקים ל
מקרים שבהם אתה לא מקבל את הטוב ביותר

445
00:19:37,260 --> 00:19:38,590
קלט, בואו נגיד.

446
00:19:38,590 --> 00:19:40,510
ולעשות בזמן לולאה
לעתים קרובות הוא הטוב ביותר

447
00:19:40,510 --> 00:19:45,260
דרך לעצב את הקוד שלך כל כך
כי היא עונה על היקף זה.

448
00:19:45,260 --> 00:19:45,760
אוקיי.

449
00:19:45,760 --> 00:19:48,930

450
00:19:48,930 --> 00:19:49,470
>> אוקיי.

451
00:19:49,470 --> 00:19:53,270
אז זה כנראה ביותר
לולאה מתוך שלוש מורכבת

452
00:19:53,270 --> 00:19:54,990
שבדקנו עד כה.

453
00:19:54,990 --> 00:19:56,689
וזה נראה מאוד מפחיד בהתחלה.

454
00:19:56,689 --> 00:19:59,730
אבל אני מבטיח לך, ברגע שאתה חבר '
לקבל את העיקרון של איך להשתמש בלולאה,

455
00:19:59,730 --> 00:20:03,320
זה אחד הדברים השימושיים ביותר,
רוב הכלים שימושיים בארסנל שלך

456
00:20:03,320 --> 00:20:05,300
להתקדמות במעמד הזה.

457
00:20:05,300 --> 00:20:09,920
>> כך למשל, בלגרד,
היו לנו בלוק פשוט מאוד זה

458
00:20:09,920 --> 00:20:13,180
שרק אמר לחזור על זה מסוים
ביטויי מספר מסוים של פעמים.

459
00:20:13,180 --> 00:20:16,260
אגב, SAJ--
זה Scaz אנדי ג'ייסון.

460
00:20:16,260 --> 00:20:18,740
אנחנו לעתים קרובות לחתום SAJ המיילים שלנו.

461
00:20:18,740 --> 00:20:20,360
אם אנחנו אומרים SAJ, אל תהיה מבולבל.

462
00:20:20,360 --> 00:20:22,630
זה רק אנחנו.

463
00:20:22,630 --> 00:20:28,600
>> אז בScratch, שהיינו מסוגלים לי
בלוק שאמרו, אני אוהב לחזור על SAJ!

464
00:20:28,600 --> 00:20:29,430
10 פעמים.

465
00:20:29,430 --> 00:20:30,130
פשוט מאד.

466
00:20:30,130 --> 00:20:32,302
ההיגיון מאחורי זה הוא
מאוד, מאוד פשוט, נכון?

467
00:20:32,302 --> 00:20:35,260
אני רוצה ראשון לעבור הראשון
זמן ורואה את זה, בפעם השנייה

468
00:20:35,260 --> 00:20:38,510
ורואה את זה, בפעם שלישית, כן הלאה
וכן הלאה, עד שתגיע ל -10.

469
00:20:38,510 --> 00:20:41,960
>> וכפי שהיינו מצהיר כי ב
קוד הוא רק דרך פשוט ללולאה.

470
00:20:41,960 --> 00:20:45,440
אז ל, אתה הולך להכריז
משתנה כאן, במקרה זה,

471
00:20:45,440 --> 00:20:46,349
עם int.

472
00:20:46,349 --> 00:20:47,390
אנחנו הולכים לשם זה אני.

473
00:20:47,390 --> 00:20:49,500
אנחנו הולכים לאתחל אותו ל -0.

474
00:20:49,500 --> 00:20:52,490
ומהדורת העצירה היא
הולך להיות לי הוא פחות מ -10.

475
00:20:52,490 --> 00:20:54,622
והעדכון הולך להיות אני ++.

476
00:20:54,622 --> 00:20:57,750
>> ובתוך הלולאה, זה הולך
לביצוע עד סופו של דבר זה

477
00:20:57,750 --> 00:21:01,490
פוגע בסופו של condition-- בי
מקרה, זה הולך לשבור את הלולאה.

478
00:21:01,490 --> 00:21:04,600
לא צריך להיות דברים שאתה
בחורים שראו כל סוג של לפני

479
00:21:04,600 --> 00:21:07,270
והייתי צריך לעשות לבעיה שלך להגדיר אחד.

480
00:21:07,270 --> 00:21:12,310
האם יש למישהו שאלות
לגבי ללולאות עכשיו?

481
00:21:12,310 --> 00:21:12,930
אוקיי.

482
00:21:12,930 --> 00:21:13,430
גדול.

483
00:21:13,430 --> 00:21:17,520

484
00:21:17,520 --> 00:21:18,620
>> אוקיי.

485
00:21:18,620 --> 00:21:22,270
אז לאלה מכם שיש לי
לקרוא את מפרט pset לשבוע

486
00:21:22,270 --> 00:21:27,690
יודע שאנחנו הולכים צריכים להעסיק
משהו שנקרא ASCII ושולחן ASCII.

487
00:21:27,690 --> 00:21:32,380
אז דוד בהרצאה ניגש לזמן קצר
איך הכל essentially-- מחשבים

488
00:21:32,380 --> 00:21:35,410
מקודד במחשב ב
בינארי, באפסים ואחדים.

489
00:21:35,410 --> 00:21:39,740
ואופן שבו מחשבים יכולים
כדי לאחסן ערכים שונים בתוספת

490
00:21:39,740 --> 00:21:44,360
לאפסים ואחדים הם באמצעות מיפוי
מספרים אלה מייצגים ספרות אחרות

491
00:21:44,360 --> 00:21:47,220
או דמויות אחרות במהות.

492
00:21:47,220 --> 00:21:49,810
>> אז במקרה הזה,
ASCII table-- כל שהיא עושה

493
00:21:49,810 --> 00:21:53,600
הוא דמויות מפה, או תווים, למספרים.

494
00:21:53,600 --> 00:21:57,385
אז את קובץ קוד המקור ב
שלך computer-- הוא רואה,

495
00:21:57,385 --> 00:22:00,010
היי, חבורה של אפסים ואחדים,
אפסים ואחדים, אפסים ואחדים.

496
00:22:00,010 --> 00:22:02,350
זה מה שמאוחסן ב
זיכרון בפועל של המחשב שלך.

497
00:22:02,350 --> 00:22:04,750
>> אבל כאשר אנו בני אדם רוצים
תקשורת עם המחשב,

498
00:22:04,750 --> 00:22:08,249
אנחנו want-- אומרים, למשל,
אם אני רוצה רישיות,

499
00:22:08,249 --> 00:22:10,540
אני הולך צריך דרך כלשהי
של מורים למחשב, אוי,

500
00:22:10,540 --> 00:22:16,300
כאשר אני מקליד אותיות גדולות, אני מתכוון
ייצוג זה בינארי.

501
00:22:16,300 --> 00:22:22,260
>> ולכן הדרך שאנחנו עושים, כי הוא זרקה
דבר שרירותי נקרא שולחן ASCII,

502
00:22:22,260 --> 00:22:25,020
שבו אנחנו, בני אדם, כ
מתכנתים, לפני כמה זמן,

503
00:22:25,020 --> 00:22:28,660
החלטנו באופן שרירותי ש
הולכים להקצות מספר אלה

504
00:22:28,660 --> 00:22:30,960
ערכים לדמויות הללו.

505
00:22:30,960 --> 00:22:32,720
>> אז אתם יכולים google מקוון זה.

506
00:22:32,720 --> 00:22:37,120
אני חושב שיש קישור אליו בך
pset-- רק שולחן מפת ASCII, ASCII

507
00:22:37,120 --> 00:22:37,720
שולחן.

508
00:22:37,720 --> 00:22:40,722
זה פשוט מתרגם ינארי
מספרים לתווים.

509
00:22:40,722 --> 00:22:42,930
וזה הולך להיות מאוד
שימושי עבור סט הבעיה שלך

510
00:22:42,930 --> 00:22:45,470
בכל פעם שאתה רוצה
לחשב משהו או אם אתה

511
00:22:45,470 --> 00:22:47,880
רוצה להציג מסוים
תווים או מספרים שלמים

512
00:22:47,880 --> 00:22:50,327
או לתפעל תווים מסוימים.

513
00:22:50,327 --> 00:22:52,160
זה הולך להיות מאוד
חשוב שכל מה שאתה

514
00:22:52,160 --> 00:22:55,140
יודע איך לנווט שולחן ASCII.

515
00:22:55,140 --> 00:23:01,260
>> כך למשל, באותיות גדולות
מיוצג על ידי המספר 65.

516
00:23:01,260 --> 00:23:04,207
והאותיות קטנות
מיוצג על ידי 97.

517
00:23:04,207 --> 00:23:07,040
לכן חשוב לדעת ש
הבדל בין שני הערכים

518
00:23:07,040 --> 00:23:08,320
הוא 32.

519
00:23:08,320 --> 00:23:13,210
לעתים קרובות, אם אתה צריך להמיר מ
אחת לשנייה, ההבדל הוא 32.

520
00:23:13,210 --> 00:23:15,710
ואל תדאגו אם אתה סוג
מבולבל של על זה בהתחלה.

521
00:23:15,710 --> 00:23:20,230
אנחנו נלך על איך היינו
להעסיק את זה בקוד בפועל.

522
00:23:20,230 --> 00:23:24,700

523
00:23:24,700 --> 00:23:26,380
>> אוקיי.

524
00:23:26,380 --> 00:23:30,770
אז לאלה מכם עם מחשבים ניידים החוצה,
אל תהסס להרים את שולחן ASCII,

525
00:23:30,770 --> 00:23:36,030
כי כנראה יהיו אלה
אתם דורשים הפניה

526
00:23:36,030 --> 00:23:38,100
מה הם התווים.

527
00:23:38,100 --> 00:23:38,640
אוקיי.

528
00:23:38,640 --> 00:23:42,840
>> אז בידיעה כי מסוים
דמויות המפה למספרים מסוימים,

529
00:23:42,840 --> 00:23:47,240
אם הייתי לרוץ רק הראשון
קו של שcode-- printf,

530
00:23:47,240 --> 00:23:50,900
אותיות קטנות, בניכוי
אותיות גדולות א 'האם מישהו

531
00:23:50,900 --> 00:23:55,880
יש ניחוש על מה יהיה
הדפסה מתוך המסך עכשיו?

532
00:23:55,880 --> 00:23:58,190
>> אז קודם כל, מה עושה
אותיות קטנות מייצג?

533
00:23:58,190 --> 00:24:00,990
מה מספר הוא ש
מקודד בטבלת ASCII.

534
00:24:00,990 --> 00:24:01,490
מצטער?

535
00:24:01,490 --> 00:24:02,630
>> קהל: 97?

536
00:24:02,630 --> 00:24:03,630
>> ANDI פנג: 97, גדול.

537
00:24:03,630 --> 00:24:05,077
ומה הוא באותיות גדולות?

538
00:24:05,077 --> 00:24:06,330
>> קהל: 65.

539
00:24:06,330 --> 00:24:08,255
>> ANDI פנג: אז מה הוא 97 מינוס 65?

540
00:24:08,255 --> 00:24:09,227
>> קהל: 32.

541
00:24:09,227 --> 00:24:09,810
ANDI פנג: אישור.

542
00:24:09,810 --> 00:24:13,530
אז מה אתם חושבים שקורים ל
יקרה כשקלט ששורת קוד

543
00:24:13,530 --> 00:24:14,670
למחשב שלי?

544
00:24:14,670 --> 00:24:17,981

545
00:24:17,981 --> 00:24:19,896
>> קהל: [לא ברור].

546
00:24:19,896 --> 00:24:21,020
ANDI פנג: מצטער, לדבר.

547
00:24:21,020 --> 00:24:22,520
אין דאגות.

548
00:24:22,520 --> 00:24:25,750
זה מאוד בטוח
הסביבה, מינוס המצלמה.

549
00:24:25,750 --> 00:24:27,550
אנחנו הולכים כל צריכה-- אין דאגות.

550
00:24:27,550 --> 00:24:30,940
רק שכולנו הולכים להעמיד פנים כמו
זה פשוט מצמרר אותנו בחדר הזה.

551
00:24:30,940 --> 00:24:31,480
אין דאגות.

552
00:24:31,480 --> 00:24:33,410
אין שאלה היא טפשה מדי.

553
00:24:33,410 --> 00:24:35,300
אין תשובה היא תשובה טיפשית.

554
00:24:35,300 --> 00:24:38,260
אני כנראה הולך לעשות טעויות
במהלך ההוראה שלי.

555
00:24:38,260 --> 00:24:40,740
ברצינות, בחורים, פשוט לפלוט את זה.

556
00:24:40,740 --> 00:24:43,092
להיות בטוח בעצמך, אתה יודע?

557
00:24:43,092 --> 00:24:43,800
אז מה זה היה?

558
00:24:43,800 --> 00:24:47,990
מי אמר שהתשובה האחרונה?

559
00:24:47,990 --> 00:24:48,540
אוקיי.

560
00:24:48,540 --> 00:24:50,380
לצעוק שנחמד וברור.

561
00:24:50,380 --> 00:24:51,220
>> קהל: 32?

562
00:24:51,220 --> 00:24:51,850
>> ANDI פנג: 32.

563
00:24:51,850 --> 00:24:54,141
אישור, בואו להפעיל קוד זה ו
לראות אם זה מה שקורה.

564
00:24:54,141 --> 00:25:00,260

565
00:25:00,260 --> 00:25:00,760
אוקיי.

566
00:25:00,760 --> 00:25:03,300

567
00:25:03,300 --> 00:25:06,360
אז כפי שאתם יכולים סוג של
לראות, הסימון האופייני לי

568
00:25:06,360 --> 00:25:12,250
הקמתי כאן לאיך היינו להעסיק
כל סוג של תכנית במחשב שלנו.

569
00:25:12,250 --> 00:25:14,770
יש לנו הפונקציה העיקרית שלנו
בתוך הפונקציה העיקרית שלנו.

570
00:25:14,770 --> 00:25:17,265
אני רק הולך להעתיק ו
להדביק את שורת קוד.

571
00:25:17,265 --> 00:25:21,082

572
00:25:21,082 --> 00:25:23,540
גם להיות זהיר כשאתה בחורים
מעתיק ומדביק את קוד.

573
00:25:23,540 --> 00:25:28,750
מפעילים מסוימים לפעמים
לא להדביק על כראוי.

574
00:25:28,750 --> 00:25:31,397
במקרה זה, בניכוי
סימן היה למעשה מקף.

575
00:25:31,397 --> 00:25:32,980
וכך המחשב לא להרים אותו.

576
00:25:32,980 --> 00:25:35,870
אז הייתי צריך לחזור ו
הקלד פיזי ש.

577
00:25:35,870 --> 00:25:37,846
רק להיזהר כש
אתם עושים את זה.

578
00:25:37,846 --> 00:25:41,178

579
00:25:41,178 --> 00:25:42,660
>> אוקיי.

580
00:25:42,660 --> 00:25:43,980
אנחנו הולכים כדי להפעיל את זה כאן.

581
00:25:43,980 --> 00:25:45,670
אז אנחנו הולכים לCD לsection2.

582
00:25:45,670 --> 00:25:50,470

583
00:25:50,470 --> 00:25:52,030
אני כבר נקרא asciimath תכנית זו.

584
00:25:52,030 --> 00:25:55,690
אז לזכור, כאשר אנחנו רצים כל
תכנית, אנחנו רוצים לקמפל את זה ראשון

585
00:25:55,690 --> 00:25:57,150
על ידי הפעלתו באמצעות האיפור שלנו.

586
00:25:57,150 --> 00:26:00,030
ואז אנחנו רוצים לרוץ למעשה
התכנית על ידי עושה dot-קו נטוי.

587
00:26:00,030 --> 00:26:01,280
אז אנחנו הולכים ל./asciimath.

588
00:26:01,280 --> 00:26:05,780

589
00:26:05,780 --> 00:26:06,590
>> נכון, יש לנו ללכת.

590
00:26:06,590 --> 00:26:07,410
ואנחנו רואים 32.

591
00:26:07,410 --> 00:26:07,930
כל הכבוד.

592
00:26:07,930 --> 00:26:10,340
מגיע לך ממתק.

593
00:26:10,340 --> 00:26:11,160
סוכריות בשבילך.

594
00:26:11,160 --> 00:26:11,900
מצטער.

595
00:26:11,900 --> 00:26:13,100
בסדר.

596
00:26:13,100 --> 00:26:13,670
אוקיי.

597
00:26:13,670 --> 00:26:18,070
אז אנחנו יכולים לחזור לדוגמא שלנו כאן.

598
00:26:18,070 --> 00:26:23,530

599
00:26:23,530 --> 00:26:24,345
אהה, לא.

600
00:26:24,345 --> 00:26:29,147

601
00:26:29,147 --> 00:26:31,090
אהה.

602
00:26:31,090 --> 00:26:32,490
אוקיי.

603
00:26:32,490 --> 00:26:34,610
אני רק הולך לשמור את זה ככה.

604
00:26:34,610 --> 00:26:48,520

605
00:26:48,520 --> 00:26:51,240
אוקיי.

606
00:26:51,240 --> 00:26:51,740
אוקיי.

607
00:26:51,740 --> 00:26:55,340
אז כפי שאתם יכולים לראות, אנחנו יכולים לעשות
הרבה דברים מאוד מעניינים,

608
00:26:55,340 --> 00:26:58,880
הרבה דברים מאוד מגניבים, הרבה
דברים מאוד מסובכים מעורבים

609
00:26:58,880 --> 00:27:02,720
תווי ASCII ומספרים.

610
00:27:02,720 --> 00:27:05,890
ברגע שאתה מגיע לקו חמש,
זה הרבה פעל יחד.

611
00:27:05,890 --> 00:27:07,640
אנחנו לא מתכוונים ללכת
באמצעות הסעיף.

612
00:27:07,640 --> 00:27:10,720
אל תהסס, אם אתה יכול,
היגיון את זה על נייר

613
00:27:10,720 --> 00:27:14,750
ראשון על מה שצריך להיות קורים כאשר
אתה קלט מחרוזת כזה של ערכים.

614
00:27:14,750 --> 00:27:19,720
לדוגמא, שבשורה האחרונה, יש לנו
z-- המייצג number-- מסוים

615
00:27:19,720 --> 00:27:24,740
זה-- שמייצג גם
modulos number-- בתוספת 1 מסוים 26

616
00:27:24,740 --> 00:27:26,750
בתוספת אותיות קטנות.

617
00:27:26,750 --> 00:27:29,220
>> אם אתם תמשיכו לקרוא
באמצעות אלה, ש

618
00:27:29,220 --> 00:27:34,009
יכול לראות דפוס לבוא ב
איך אנחנו מניפולציה הקוד.

619
00:27:34,009 --> 00:27:36,050
אני מאוד, מאוד ממליץ
אחרי סעיף כולכם

620
00:27:36,050 --> 00:27:38,160
בחורים קדימה, קלט
אלה כל במחשב שלך

621
00:27:38,160 --> 00:27:40,060
ולראות איזה סוג של
מספרים יוצאים

622
00:27:40,060 --> 00:27:43,090
והנמקה מדוע דרך אלה
קורה, כי לpsets

623
00:27:43,090 --> 00:27:45,060
זה יהיה חשוב באמת
לך להבין

624
00:27:45,060 --> 00:27:47,132
מדוע דברים מסוימים קורים.

625
00:27:47,132 --> 00:27:48,590
כל שקופיות אלה יהיו מקוונים.

626
00:27:48,590 --> 00:27:51,510
אז אינו דואג מנסה
להעתיק פיזי את הערות.

627
00:27:51,510 --> 00:27:52,510
באינטרנט הכל.

628
00:27:52,510 --> 00:27:54,050
סעיף זה עצמו יהיה באינטרנט.

629
00:27:54,050 --> 00:27:57,500
כל קוד המקור שלי ש
אני רץ יהיה מקוון.

630
00:27:57,500 --> 00:27:58,180
כן.

631
00:27:58,180 --> 00:27:59,430
האם עדיין יש לך שאלה?

632
00:27:59,430 --> 00:28:00,587
קהל: מה הוא modulos?

633
00:28:00,587 --> 00:28:01,170
ANDI פנג: אישור.

634
00:28:01,170 --> 00:28:05,620
אז מודולו הוא מפעיל שהולך
להיות די חשוב pset של הבחורים שלך

635
00:28:05,620 --> 00:28:06,690
כאן.

636
00:28:06,690 --> 00:28:12,280
לכן הדרך שמפעילים
ב- C ובעבודת תכנות

637
00:28:12,280 --> 00:28:16,360
הוא שיש לך מה שנקרא
סמל חטיבה וסמל מודולוס,

638
00:28:16,360 --> 00:28:18,350
אשר הוא בדיוק כמו סימן אחוזים.

639
00:28:18,350 --> 00:28:24,840
>> אז ב- C, כאשר אתה עושה שלם
מחולק במספר שלם עם קו נטוי,

640
00:28:24,840 --> 00:28:27,720
יש C נטייה רוצה לחתוך
את כל הנקודות עשרוניות,

641
00:28:27,720 --> 00:28:30,290
כי שלם רוצה
להמיר למספר שלם.

642
00:28:30,290 --> 00:28:33,550
זה לא הולך לרוצה להיות כפול
עם חבורה של מספרים עשרוניים כל אחרי זה.

643
00:28:33,550 --> 00:28:39,322
>> אז אם אני עושה 3 חלקי 2, שזה הולך
לנתק את 0.5 ורק לתת לך 1.

644
00:28:39,322 --> 00:28:41,530
אז זה משהו שיש
זהיר מאוד של כשאתה

645
00:28:41,530 --> 00:28:45,294
עושה כל סוג של מתמטיקה בתכנות,
הוא שהמספרים שאתה מקבל

646
00:28:45,294 --> 00:28:47,210
לא יכול להיות המספרים
שאתה חושב,

647
00:28:47,210 --> 00:28:50,190
ולכן עיגול בך
pset האחרון הוא כל כך חשוב.

648
00:28:50,190 --> 00:28:51,980
>> מודולו נותן לך את השארית.

649
00:28:51,980 --> 00:28:56,200
כך למשל, אם אני עשיתי 3
מודולו 2-- כך 3 אחוזים סימן 2--

650
00:28:56,200 --> 00:28:58,020
זה ייתן לך את שארית ש.

651
00:28:58,020 --> 00:29:00,460
3 מחולק אז על ידי 2 הוא 1.5.

652
00:29:00,460 --> 00:29:01,410
זה שארית 1 מתוך 1.

653
00:29:01,410 --> 00:29:04,600
זה היה נותן לך 1, ש
הוא שארית ש.

654
00:29:04,600 --> 00:29:07,361
>> לכן, כאשר אתם נעים
דרך שולחן ASCII,

655
00:29:07,361 --> 00:29:09,735
מודולו יהיה בסופו
משהו שהוא מאוד חשוב,

656
00:29:09,735 --> 00:29:11,240
ונדברנו שמאוחר יותר.

657
00:29:11,240 --> 00:29:17,750

658
00:29:17,750 --> 00:29:19,040
>> אוקיי.

659
00:29:19,040 --> 00:29:27,300
אז משהו שהוא יפה,
די חדש ודי ייחודי

660
00:29:27,300 --> 00:29:31,920
שאנחנו כבר דנו השבוע הוא
המושג מה הוא מערך.

661
00:29:31,920 --> 00:29:34,370
אז המערך הוא הראשון
סוג של מבנה נתונים

662
00:29:34,370 --> 00:29:36,320
שאנחנו הולכים
נתקל בזה בכיתה.

663
00:29:36,320 --> 00:29:40,010
כל מבנה הנתונים הוא
איזה שרירותי,

664
00:29:40,010 --> 00:29:43,370
פשוטו כמשמעו דברים כמו מבנה
שאנחנו כמתכנתים יצרנו,

665
00:29:43,370 --> 00:29:47,890
שאנחנו כבר לשים בקוד שלנו ש
יכול להכיל קטעי קוד אחרים.

666
00:29:47,890 --> 00:29:51,090
>> אז במובן הזה, array--
לחשוב על זה כקובץ ממשלה,

667
00:29:51,090 --> 00:29:53,470
שבו אם אתה פותח שונה
מדפים של ארון הקובץ שלך,

668
00:29:53,470 --> 00:29:55,630
אתה יכול לגשת לדברים שונים.

669
00:29:55,630 --> 00:29:58,630
בזיכרון, מערך הוא פשוט עושה
אותו הדבר במחשב שלך.

670
00:29:58,630 --> 00:30:01,730
אתה יכול יש לנו blocks-- שונה
קורא להם indices-- של מערך.

671
00:30:01,730 --> 00:30:04,210
זה בדיוק כמו בלוק,
מדף של זיכרון

672
00:30:04,210 --> 00:30:07,580
שיצרנו בתוכך
מחשב שאתה יכול קלט

673
00:30:07,580 --> 00:30:10,270
דברים מסוימים בחללים שונים.

674
00:30:10,270 --> 00:30:18,000
>> אז עם מערך, אתה
תמיד צריך specify--

675
00:30:18,000 --> 00:30:22,360
אתה צריך לציין שהכריז
מערך בפורמט הבא.

676
00:30:22,360 --> 00:30:24,290
אתה הולך ראשון
לציין את סוג הנתונים

677
00:30:24,290 --> 00:30:25,831
שברצונך ליצור המערך.

678
00:30:25,831 --> 00:30:28,870
אם אני רוצה מערך של מספרים שלמים,
אני הולך לשים int ממש שם.

679
00:30:28,870 --> 00:30:32,079
אם אני רוצה מערך של מחרוזות,
אני הולך לשים את המחרוזות שם,

680
00:30:32,079 --> 00:30:34,995
שמו של המערך שלך, ולאחר מכן
אתה הולך להיות בסוגריים מרובעים.

681
00:30:34,995 --> 00:30:39,580
ובתוך סוגריים מרובעים, אתה
הולך להיות בגודל של המערך שלך.

682
00:30:39,580 --> 00:30:42,900
>> משהו שבאמת חשוב ל
יש לזכור בעת יצירת מערכים היא

683
00:30:42,900 --> 00:30:46,530
כי ברגע שאתה יוצר
מערך, גודל שלא ניתן לשנות.

684
00:30:46,530 --> 00:30:50,180
אז אם אתה יודע שעכשיו
יש לך מערך של גודל 10,

685
00:30:50,180 --> 00:30:54,550
אתה יודע שאני הולך יש לי 10 תאים
בתוך או 10 מדדים במערך זה,

686
00:30:54,550 --> 00:30:56,830
וזה אף פעם לא קורה
כדי להרחיב או לצמצם

687
00:30:56,830 --> 00:30:59,850
לא משנה מה, ושיש
כיום רק 10 בלוקים של שטח

688
00:30:59,850 --> 00:31:04,490
הוקצה בזיכרון שלך שיכול לאחסן
עד 10 דברים של מה שהשקעת.

689
00:31:04,490 --> 00:31:08,790
>> אז בדרך זו, סוג נתוני מערך,
מבנה נתונים שהוא מערך

690
00:31:08,790 --> 00:31:13,392
שונה מאוד מכמה אחר שנציע ב
להיות כיסוי מאוחר יותר בקורס זה.

691
00:31:13,392 --> 00:31:15,170
כן.

692
00:31:15,170 --> 00:31:20,080
לדוגמא, אם אתה רוצה
ליצור מערך של גודל 3 ש

693
00:31:20,080 --> 00:31:23,670
משתנים כלולים של integer--
אה, סליחה, של temperature--

694
00:31:23,670 --> 00:31:25,640
וטמפרטורה, של
כמובן, הוא מספר שלם.

695
00:31:25,640 --> 00:31:28,710
>> אז היינו ליצור int, שהוא
סוג נתונים של מה שאנחנו רוצים לאחסן.

696
00:31:28,710 --> 00:31:32,680
אנחנו הולכים לקרוא לזה בטמפרטורות
למען המינוח של שמות

697
00:31:32,680 --> 00:31:34,200
משהו שכולנו מבינים.

698
00:31:34,200 --> 00:31:35,900
ואנחנו הולכים להיות בסוגריים מרובעים.

699
00:31:35,900 --> 00:31:37,200
ואנחנו רוצים שלושה מספרים.

700
00:31:37,200 --> 00:31:39,000
אז אנחנו הולכים לשים
שלוש בתוכו.

701
00:31:39,000 --> 00:31:41,041
>> משהו שהוא באמת
חשוב לזכור

702
00:31:41,041 --> 00:31:43,530
הוא שמערכים אפס אינדקס.

703
00:31:43,530 --> 00:31:46,410
כל זה אומר הוא שאתה
תתחיל עם המדד של 0,

704
00:31:46,410 --> 00:31:49,800
ואתה מפעיל דרך
גודל של המערך מינוס 1.

705
00:31:49,800 --> 00:31:52,730
כך למשל כאן, אנחנו
יש מערך בגודל 3.

706
00:31:52,730 --> 00:31:54,680
זה הולך להיות מסוגל
להחזיק שלושה ערכים.

707
00:31:54,680 --> 00:31:57,450
אבל המספרים themselves-- ש
מספר, המערך, מדד ש,

708
00:31:57,450 --> 00:32:00,271
המערך, הם 0 עד 2.

709
00:32:00,271 --> 00:32:03,520
אז חבר'ה, באמת, באמת זהירים כאשר
אתם עוברים הבעיות שלך להגדיר

710
00:32:03,520 --> 00:32:06,500
ויצירת כל סוג של מערך,
כי הרבה פעמים זה

711
00:32:06,500 --> 00:32:08,490
באמת, באמת קל לשכוח את זה.

712
00:32:08,490 --> 00:32:11,840
אני באמת לא צריך את המדד
של 3, שאני פשוט כרגע

713
00:32:11,840 --> 00:32:13,130
יש המדד של 2.

714
00:32:13,130 --> 00:32:16,046
ואם אתה מנסה
לגשת למדד השלישי,

715
00:32:16,046 --> 00:32:18,170
זה הולך להיות מה
בשם שליחות קטלנית null.

716
00:32:18,170 --> 00:32:19,990
זה לא הולך לבעצם
קיימים במערך.

717
00:32:19,990 --> 00:32:21,781
והמחשב
לא הולך רוצה את זה.

718
00:32:21,781 --> 00:32:24,570
כדי להיות זהיר בכל פעם ש
אתה ניגש רק דברים

719
00:32:24,570 --> 00:32:28,070
כדי לוודא שאתה זוכר
שמערכים הם אפס צמוד.

720
00:32:28,070 --> 00:32:28,880
>> אוקיי.

721
00:32:28,880 --> 00:32:34,030
אז הדוגמא הראשונה היא פשוט
דרך של יצירת מערך אחד.

722
00:32:34,030 --> 00:32:36,790
הדוגמא השנייה שיש לי
להלן הוא רק דרך נפרד

723
00:32:36,790 --> 00:32:40,210
של יצירת מה הוא אותם נתונים
מבנה שיש לנו רק שהוזן.

724
00:32:40,210 --> 00:32:44,347
אז במקום פיזי פועל
דרך ולשים בטמפרטורה של 0

725
00:32:44,347 --> 00:32:47,180
שווה כל, טמפרטורת 1
שווה כל מה ש, 2 שווים הטמפרטורה

726
00:32:47,180 --> 00:32:50,950
מה, אני באמת יכול רק
ישירות ליצור את כל זה בשורה אחת

727
00:32:50,950 --> 00:32:53,010
לסוגריים מרובעים טמפרטורה שווה.

728
00:32:53,010 --> 00:32:56,536
>> והודעה מוקדמת במקרה זה, אתה לא צריך
כדי לציין עד כמה גדול המערך שלך הוא,

729
00:32:56,536 --> 00:32:59,160
מכיוון שהמחשב הולך
לעבור ולראות שיש

730
00:32:59,160 --> 00:33:01,570
שלושה אלמנטים בסוגריים מסולסלים אלה.

731
00:33:01,570 --> 00:33:04,000
וזה הולך יודע, אישור,
אני צריך מערך של גודל 3.

732
00:33:04,000 --> 00:33:07,440
אתה לא הולך צריך
קלט זה בדרך הבאה.

733
00:33:07,440 --> 00:33:10,170
>> וגם, כן, ככה.

734
00:33:10,170 --> 00:33:12,610
האם יש למישהו שאלות
לגבי איך אנחנו עושים את המערכים

735
00:33:12,610 --> 00:33:17,391
או איך המבנה של מערך עובד?

736
00:33:17,391 --> 00:33:17,890
כן.

737
00:33:17,890 --> 00:33:18,806
>> קהל: [לא ברור]?

738
00:33:18,806 --> 00:33:21,649

739
00:33:21,649 --> 00:33:22,690
ANDI פנג: כן, בדיוק.

740
00:33:22,690 --> 00:33:26,150
אז אם אתה היה להכריז ולאתחל
מערך בשיטה הבאה,

741
00:33:26,150 --> 00:33:28,477
שהוא הדרך השנייה,
אתה יכול פשוט לעזוב אותם.

742
00:33:28,477 --> 00:33:30,310
והמחשב
באופן אוטומטי יודע ש

743
00:33:30,310 --> 00:33:33,950
צריך לספור כמה אלמנטים
הם בסוגריים מסולסלים אלה, מופרדים

744
00:33:33,950 --> 00:33:34,930
בפסיקים.

745
00:33:34,930 --> 00:33:37,517
>> אז הנה הם רואים 65, 87, 30.

746
00:33:37,517 --> 00:33:39,600
אז המחשב יודע, הו,
יש שלושה מספרים שלמים.

747
00:33:39,600 --> 00:33:45,960
אני יודע ליצור שם מערך
טמפרטורה עם שלושה אלמנטים בזה.

748
00:33:45,960 --> 00:33:46,590
שאלה טובה.

749
00:33:46,590 --> 00:33:47,090
כן.

750
00:33:47,090 --> 00:33:51,590
>> קהל: האם לא ניתן ליצור
מערך עם סוגים שונים של נתונים

751
00:33:51,590 --> 00:33:53,021
שאפשר היה להיכנס לתוכו?

752
00:33:53,021 --> 00:33:56,746
לדוגמא, עם מספרים שלמים [לא ברור]?

753
00:33:56,746 --> 00:33:59,120
ANDI פנג: לעניין
של המעמד הזה, לא, עכשיו.

754
00:33:59,120 --> 00:34:03,070
כאשר אתה יוצר נתונים
מבנה דמוי מערך,

755
00:34:03,070 --> 00:34:04,990
אתה אומר לי
מחשב, היי, אני צריך אותך

756
00:34:04,990 --> 00:34:08,159
להקצות זה הרבה
זיכרון בכונן הקשיח שלי,

757
00:34:08,159 --> 00:34:10,690
עם כל תא ש
מספר מסוים של ביטים.

758
00:34:10,690 --> 00:34:13,429
>> זכור שלמדנו בשבוע
אפס כי הנתונים שונים

759
00:34:13,429 --> 00:34:15,300
יש סוגים גדלים שונים?

760
00:34:15,300 --> 00:34:17,630
כך למשל, מחרוזת
הוא סכום שונה

761
00:34:17,630 --> 00:34:20,719
של שטח מאשר char, ש
היא כמות השטח שונה

762
00:34:20,719 --> 00:34:21,830
ממספר שלם.

763
00:34:21,830 --> 00:34:25,534
ולכן אם לא תציין ולך
לערבב ולהתאים אילו סוגים של משתנים

764
00:34:25,534 --> 00:34:27,659
יש לך, מחשב של
הולך להיות מאוד מבולבל.

765
00:34:27,659 --> 00:34:29,950
וזה לא הולך לדעת
כמה זיכרון לתת לך.

766
00:34:29,950 --> 00:34:32,480
אז למטרות של ימין
עכשיו, מחשבים יכולים רק

767
00:34:32,480 --> 00:34:36,120
להכיר סוג אחד של מערך.

768
00:34:36,120 --> 00:34:37,940
שאלה טובה.

769
00:34:37,940 --> 00:34:38,440
אוקיי.

770
00:34:38,440 --> 00:34:45,179

771
00:34:45,179 --> 00:34:47,120
>> אז באופן טבעי,
שאלה שנייה שיש לנו

772
00:34:47,120 --> 00:34:50,760
הוא, ובכן, עכשיו שיצרנו
מערך ואנחנו כבר לשים את כל הדברים האלה

773
00:34:50,760 --> 00:34:54,190
במערך, איך אנחנו
הולך להיות מסוגל לגשת אליו?

774
00:34:54,190 --> 00:34:59,710
אז המבנה האופייני שאנחנו תמיד
לגשת מערך הוא שלנו יפה ללולאה.

775
00:34:59,710 --> 00:35:03,830
אני מבטיח לכם שנהיה
רואה הרבה הבחור הזה כאן.

776
00:35:03,830 --> 00:35:06,470
>> בעיקרו של דבר, כל עת שתרצה
לקלט ערכים למערך

777
00:35:06,470 --> 00:35:09,940
או שאתה רוצה לגשת אליהם,
הדרך הטובה ביותר לעשות זאת היא ללולאה,

778
00:35:09,940 --> 00:35:13,730
כי ללולאה, אתה
יודע כמה פעמים אתה

779
00:35:13,730 --> 00:35:17,290
הולך רוצה לרוץ דרך המערך,
כי יש לך מהדורת תחנה, נכון?

780
00:35:17,290 --> 00:35:19,680
ובכל פעם שאתה מפעיל
דרך, אתה יכול לגשת ל

781
00:35:19,680 --> 00:35:21,310
אלמנט שונה של המערך.

782
00:35:21,310 --> 00:35:26,920
>> וגם, זה סיבה בדרך כלל
אנחנו מתחילים ללולאות בערך 0,

783
00:35:26,920 --> 00:35:30,080
משום שכאשר אתה ניגש למערכים,
אתה יכול לגשת למדד אפס.

784
00:35:30,080 --> 00:35:32,070
וכך זה מקביל יפה מאוד.

785
00:35:32,070 --> 00:35:35,295
אתם אולי רצינו
לכתוב לint i שווה 1.

786
00:35:35,295 --> 00:35:37,330
הוא אני פחות או שווה ל -3.

787
00:35:37,330 --> 00:35:39,890
>> אבל זה לא היה עובד די כ
גם כאן, כי אתה רק

788
00:35:39,890 --> 00:35:42,010
יש אלמנטים של 0, 1, ו -2.

789
00:35:42,010 --> 00:35:45,815
ולכן אם היה לך להתחיל
אני שלך באלמנט 1, 2, ו -3,

790
00:35:45,815 --> 00:35:48,440
אתה הולך בסופו של פועל
מחוץ לגבולות של המערך שלך,

791
00:35:48,440 --> 00:35:50,440
ודברים רעים הולכים לקרות.

792
00:35:50,440 --> 00:35:54,480
>> אז אני מקווה שאתם רואים את segue
מדוע בשיעורים הקודמים

793
00:35:54,480 --> 00:35:58,560
אנחנו מלמדים אתכם איך לנהל ו
לעצב ללולאת הדרך שאנחנו.

794
00:35:58,560 --> 00:36:01,900
זה בגלל ש, עכשיו יש לנו
הועבר למערכים,

795
00:36:01,900 --> 00:36:06,760
אתה יכול לראות למה 0 משאיל
עצמו יפה מאוד לגישה.

796
00:36:06,760 --> 00:36:09,880
>> אז כפי שאנחנו עושים את זה הוא לראות-- אני
רק הדפסתו כאן למען

797
00:36:09,880 --> 00:36:10,830
של הדפסה את זה.

798
00:36:10,830 --> 00:36:13,750
אבל יש לי מציין המיקום, הפסיק שלי.

799
00:36:13,750 --> 00:36:15,645
ואת הגישה בפועל
חלק שקורה.

800
00:36:15,645 --> 00:36:17,520
שמו של המערך
נקרא טמפרטורה.

801
00:36:17,520 --> 00:36:21,570
אז זה טמפרטורה ו
i-ה אלמנט של המערך.

802
00:36:21,570 --> 00:36:24,400
>> אז כמו ללולאה עובר,
זה הולך להתחיל ב 0.

803
00:36:24,400 --> 00:36:27,640
זה הולך להדפיס את
מדד ה 0 של מערך זה.

804
00:36:27,640 --> 00:36:29,599
אז זה הולך להדפיס
את האלמנט הראשון.

805
00:36:29,599 --> 00:36:31,431
אז זה הולך להדפיס
את השנייה.

806
00:36:31,431 --> 00:36:32,880
ואז אנחנו הולכים לשבור.

807
00:36:32,880 --> 00:36:36,718
האם כולם ברורים ב
איך זה קורה?

808
00:36:36,718 --> 00:36:37,217
גדול.

809
00:36:37,217 --> 00:36:43,230

810
00:36:43,230 --> 00:36:44,100
>> בסדר.

811
00:36:44,100 --> 00:36:47,270
אז הנה יש לנו דרך של
אומר, אם אנחנו לא רוצים

812
00:36:47,270 --> 00:36:50,020
לקשה-קוד in-- כמתכנת.

813
00:36:50,020 --> 00:36:53,320
אני ממש פיזי לא רציתי
לשים בכל מרכיב בודד

814
00:36:53,320 --> 00:36:54,020
של מערך זה.

815
00:36:54,020 --> 00:36:56,500
אם אני רוצה במקום
יש ערכי קלט משתמש,

816
00:36:56,500 --> 00:36:58,100
מהי הדרך הטובה ביותר לעשות את זה?

817
00:36:58,100 --> 00:37:00,920
>> ובכן, כאן אני יצרתי
הפונקציה הנחמדה הזה,

818
00:37:00,920 --> 00:37:03,560
שבו אני יכול להצהיר על מערך.

819
00:37:03,560 --> 00:37:06,210
אז int scores-- בואו
רק אומר שאנחנו רוצים לעשות

820
00:37:06,210 --> 00:37:10,660
מערך שנערך הציונים של כל 18
של התלמידים כאן בסעיף זה.

821
00:37:10,660 --> 00:37:12,670
אני חושב שיש לנו קצת
יותר מ -18 ילדים היום.

822
00:37:12,670 --> 00:37:16,460
אבל למען הדוגמא,
בואו פשוט להניח לנו 18.

823
00:37:16,460 --> 00:37:21,580
הייתי ליצור שם מערך ציונים עם
int סוג, בגלל ציונים, כמובן,

824
00:37:21,580 --> 00:37:22,987
הם מספרים.

825
00:37:22,987 --> 00:37:24,820
ואני הולך יש לי
18 בסוגריים מרובעים,

826
00:37:24,820 --> 00:37:29,900
כי זה כמה תלמידים ש
רוצה להיות מסוגל לאחסן עשרות.

827
00:37:29,900 --> 00:37:32,206
>> והדרך הייתי לאכלס
המערך הוא שלא היה לי

828
00:37:32,206 --> 00:37:35,572
להפעיל אותו דרך לולאה, של
כמובן, עם 0 להיות מדד ה 0 שלי.

829
00:37:35,572 --> 00:37:38,030
ולאחר מכן עם 18 להיות שלי
עצירת מהדורה, כי יש

830
00:37:38,030 --> 00:37:39,690
18 אלמנטים במערך.

831
00:37:39,690 --> 00:37:44,620
ואז אני הולך לעשות printf, הזן
לזכות student-- בלה בלה בלה.

832
00:37:44,620 --> 00:37:51,171
>> האם מישהו יכול להגיד לי למה אני כאן
הדפסת i בתוספת 1 ולא אני?

833
00:37:51,171 --> 00:37:52,920
זה סוג של טריק
שאלה, לא ממש.

834
00:37:52,920 --> 00:37:56,020
זה לא ממש פיזי
משפיע על הריצה של הקוד.

835
00:37:56,020 --> 00:37:56,520
כן.

836
00:37:56,520 --> 00:37:57,909
>> קהל: [לא ברור] 0?

837
00:37:57,909 --> 00:37:58,950
ANDI פנג: כן, בדיוק.

838
00:37:58,950 --> 00:38:02,620
זה קצת מביך להגיד, היי,
אתה התלמיד בכיתה ה 0 זה.

839
00:38:02,620 --> 00:38:03,780
זה קצת מוזר.

840
00:38:03,780 --> 00:38:08,340
אז לנו, כבני אדם, לא ממש אוהבים
לחשוב על איך מחשבים חושבים.

841
00:38:08,340 --> 00:38:10,930
אז למרות ב
מחשב, זה אחסון ערכים

842
00:38:10,930 --> 00:38:13,310
במדד 0-ה, כאשר
אנחנו בני אדם, אנחנו לא באמת

843
00:38:13,310 --> 00:38:15,520
רוצה להתייחס לעצמנו כאפס.

844
00:38:15,520 --> 00:38:18,119
לכן, כאשר אני פשוט להדפיס את זה,
אני הולך להדפיס ולהוסיף

845
00:38:18,119 --> 00:38:19,410
1 רק למען הבהירות.

846
00:38:19,410 --> 00:38:22,447
לכן, כאשר אני מדפיס, אני הולך להיות
תוכל להדפיס תלמידי 1 עד 18.

847
00:38:22,447 --> 00:38:24,530
זה לא ממש משפיע
הריצה של הקוד

848
00:38:24,530 --> 00:38:27,110
בכל דרך, בדרך שאני להדפיס.

849
00:38:27,110 --> 00:38:30,380
>> אבל להיות זהיר כשאתה
למעשה גישה למערך.

850
00:38:30,380 --> 00:38:32,780
כשאתה רואה את הציונים אני,
מבחין כאן אני בעצם

851
00:38:32,780 --> 00:38:38,200
גישה למדד ה 0 ו
לא בתוספת 0-- 1 או 1 פלוס 1,

852
00:38:38,200 --> 00:38:45,530
במקרה זה, מדד כל כך
שזה בעצם ברור.

853
00:38:45,530 --> 00:38:48,870
האם כולם סוג של אישור על
איך זה פועל דרך

854
00:38:48,870 --> 00:38:51,470
ועם כל מדד אני
לשים ערך למערך

855
00:38:51,470 --> 00:38:55,340
ויצירת מערך עם 18 מספרים
שהמשתמש הולך קלט?

856
00:38:55,340 --> 00:38:58,780

857
00:38:58,780 --> 00:38:59,821
אוקיי.

858
00:38:59,821 --> 00:39:00,321
מגניב.

859
00:39:00,321 --> 00:39:05,380

860
00:39:05,380 --> 00:39:07,400
>> אוקיי.

861
00:39:07,400 --> 00:39:12,220
עכשיו אנחנו עוברים למשהו שדי
רלוונטי לפיסה להגדיר גם את זה.

862
00:39:12,220 --> 00:39:15,020
אני יודע בהרצאה, David--
מצטער, הייתה לך שאלה?

863
00:39:15,020 --> 00:39:16,840
>> קהל: האם אתה יכול להגדיל אותו?

864
00:39:16,840 --> 00:39:18,080
>> ANDI פנג: כן, אז ניסיתי.

865
00:39:18,080 --> 00:39:18,788
אבל אני לא יודע.

866
00:39:18,788 --> 00:39:21,437
מסיבה כלשהי, זה
גרסה של PowerPoint

867
00:39:21,437 --> 00:39:23,270
הוא ממש לא עובד
גם עם התצוגה.

868
00:39:23,270 --> 00:39:25,260
אז אנחנו פשוט הולכים
כדי לשמור את זה ככה.

869
00:39:25,260 --> 00:39:27,280
כל אלה יועלו באינטרנט.

870
00:39:27,280 --> 00:39:28,218
מצטער, חבר'ה.

871
00:39:28,218 --> 00:39:30,090
כן.

872
00:39:30,090 --> 00:39:30,980
אוקיי.

873
00:39:30,980 --> 00:39:35,530
>> אז אנחנו יכולים להיות גם מחרוזות.

874
00:39:35,530 --> 00:39:39,320
אז אם אתם באמת notice-- אני
לדעת רוב הלכו על זה בהרצאה ש

875
00:39:39,320 --> 00:39:43,652
שהוא did-- מחרוזת היא למעשה
רק מערך של תווים,

876
00:39:43,652 --> 00:39:44,860
אם אתה חושב על זה, נכון?

877
00:39:44,860 --> 00:39:47,500
מחרוזת היא שם או
משפט או מילה, נכון?

878
00:39:47,500 --> 00:39:52,975
>> אם הייתי ליצור מחרוזת בשם
Andi-- רק את השם שלי, N-D-אני.

879
00:39:52,975 --> 00:39:55,460
אתה חושב על זה כפשוט משתנה אחד.

880
00:39:55,460 --> 00:39:58,630
אבל בעצם, זה מתפרק
לפשוט מערך של תווים.

881
00:39:58,630 --> 00:40:01,910
אז יש לו אופי של
מאוחסן במערך ערך.

882
00:40:01,910 --> 00:40:05,420
יש לו אופי של n מאוחסן ב
מדד שני וכן הלאה וכן הלאה.

883
00:40:05,420 --> 00:40:08,660
>> אז באופן כזה, ש
יש בעצם סוג זה

884
00:40:08,660 --> 00:40:10,970
של מבנה נקבע ב
מקום למיתרים שלנו.

885
00:40:10,970 --> 00:40:14,660
אז הנה, אם הייתי קלט
מילה "לאכול" - כך מילה שווה מחרוזת

886
00:40:14,660 --> 00:40:15,540
תקבל מחרוזת.

887
00:40:15,540 --> 00:40:19,260
אם הייתי קלט המילה "לאכול", ש
הוא פיזי אופן שהמחשב שלי

888
00:40:19,260 --> 00:40:21,870
הוא אחסון מחרוזת שבזיכרון שלי.

889
00:40:21,870 --> 00:40:27,140
>> ואם אני רוצה לרוץ שב
והדפסה שout-- כך לי

890
00:40:27,140 --> 00:40:30,890
שווה אפס, זוכרים, בהרצאה, ש
משהו מכוסה שנקרא strlen,

891
00:40:30,890 --> 00:40:32,990
או האורך של המחרוזת.

892
00:40:32,990 --> 00:40:36,520
כי אני לא ממש
יודע עד כמה גדול הוא המערך

893
00:40:36,520 --> 00:40:38,210
של כל מה שinputting-- של המשתמש

894
00:40:38,210 --> 00:40:40,370
>> לדוגמא, אני הוזנתי
המילה "לאכול", ואני יודע ש

895
00:40:40,370 --> 00:40:41,870
זה ארוך שלוש דמויות, נכון?

896
00:40:41,870 --> 00:40:44,700
אז אני יכול להכניס לשם שלוש
והכל יהיה בסדר.

897
00:40:44,700 --> 00:40:49,290
אבל אם משהו קלט המשתמש
זה מספר שונה של ערכים,

898
00:40:49,290 --> 00:40:52,760
אתה הולך לא להיות מסוגל באמת
יודע שכאשר אתה לתכנת את הקוד שלך.

899
00:40:52,760 --> 00:40:56,040
>> אז הדרך שבה אנו מטפלים מקרי מבחן
כמו שזה שיש לנו משהו

900
00:40:56,040 --> 00:41:00,070
נקרא strlen, שהוא רק פונקציה
זה אומר לך כמה זמן מחרוזת היא.

901
00:41:00,070 --> 00:41:02,080
אז strlen של מילה.

902
00:41:02,080 --> 00:41:03,470
המילה שלי היא לאכול.

903
00:41:03,470 --> 00:41:05,990
n שווה strlen של מילה.

904
00:41:05,990 --> 00:41:08,930
מישהו יכול להגיד לי מה ש
ערך בעצם הוא שם?

905
00:41:08,930 --> 00:41:12,550
מה n מייצג תקין
עכשיו, בדוגמא זו, אם היה לי לאכול?

906
00:41:12,550 --> 00:41:13,530
>> קהל: 3.

907
00:41:13,530 --> 00:41:14,520
>> ANDI פנג: 3, בדיוק.

908
00:41:14,520 --> 00:41:18,820
אז יש לנו לשווה אני int
אפס, n שווה 3, בעצם.

909
00:41:18,820 --> 00:41:22,355
ואני הולך לרוץ
עד שזה פחות מ3i ++.

910
00:41:22,355 --> 00:41:24,980
וזה הולך בעצם ללכת
דרך ולעשות את אותו הדבר.

911
00:41:24,980 --> 00:41:26,979
זה הולך להדפיס
וכל ערך לתת לך

912
00:41:26,979 --> 00:41:29,700
E-A-T. זה פשוט המציין
דרך שונה של כתיבתו.

913
00:41:29,700 --> 00:41:31,170
זה הולך להיות מאוד מועיל.

914
00:41:31,170 --> 00:41:31,670
כן.

915
00:41:31,670 --> 00:41:35,174
קהל: מה היתרונות של לשים
n שווה מילת strlen בתוך ש

916
00:41:35,174 --> 00:41:36,894
ללולאה [לא ברור]?

917
00:41:36,894 --> 00:41:37,560
ANDI פנג: כן.

918
00:41:37,560 --> 00:41:44,880
אז אם אני היה אומר צריכה--, למשל,
אם הייתי עושה את זה ולאחר מכן

919
00:41:44,880 --> 00:41:51,935
do-- oop-- ש, בקוד שלי, זה היה
למעשה להיות עושה כמו אותו הדבר.

920
00:41:51,935 --> 00:41:55,060
עם זאת, הדרך שהדוד הסביר
שלו במהלך הרצאה, אם מישהו מכם בחורים

921
00:41:55,060 --> 00:41:57,854
זוכר, היה ש, כ
בני אדם, כמתכנתים,

922
00:41:57,854 --> 00:42:00,270
אנחנו באמת מנסים לתכנתנו
קוד כך שהמחשב שלנו

923
00:42:00,270 --> 00:42:04,070
לעבוד מינימאלי ככל האפשר, כך
שהקוד שלנו הוא יעיל מאוד.

924
00:42:04,070 --> 00:42:06,850
>> אז אם היה לי שיש, מה ש
יקרה דרך ללולאה שלי

925
00:42:06,850 --> 00:42:10,790
הוא שהייתי מכריז ראשון
אני בשם משתנה הולך להיות 0.

926
00:42:10,790 --> 00:42:13,350
אני הולך לבדוק, אה,
מה הוא strlen של מילה?

927
00:42:13,350 --> 00:42:15,000
אה, strlen הוא 3.

928
00:42:15,000 --> 00:42:16,191
אז הוא שפחות משלושה?

929
00:42:16,191 --> 00:42:16,690
כן זה כן.

930
00:42:16,690 --> 00:42:17,870
אני הולך לרוץ.

931
00:42:17,870 --> 00:42:21,130
>> ואז בפעם השנייה חזרה סביב
הלולאה, אני הולך להגדיל i.

932
00:42:21,130 --> 00:42:22,550
אני הולך להיות אחד.

933
00:42:22,550 --> 00:42:25,600
ואני הולך לבדוק, אה,
אבל מה strlen של מילה?

934
00:42:25,600 --> 00:42:26,839
אה, זה שלוש.

935
00:42:26,839 --> 00:42:29,880
ועושה את זה נראה סוג של בזבוז,
בכל פעם שאתה מפעיל דרך הלולאה,

936
00:42:29,880 --> 00:42:33,340
לבדיקת התפקוד,
למרות strlen של מילה

937
00:42:33,340 --> 00:42:35,490
לא משנה בעצם?

938
00:42:35,490 --> 00:42:38,590
>> אז זה תוספת כוח למחשב.

939
00:42:38,590 --> 00:42:42,180
כשאתה מתחיל לדבר על דברים
כי מיליארדים ומיליארדים

940
00:42:42,180 --> 00:42:44,431
ומיליארדים של מקומות
ארוך, לדמיין את המחשב

941
00:42:44,431 --> 00:42:47,430
צורך לעבור דרך פיזי ו
לבדוק את כל זה בכל פעם.

942
00:42:47,430 --> 00:42:53,170
לכן, כדי לעשות רק
למען היעילות,

943
00:42:53,170 --> 00:42:57,620
אנו נוטים רק כדי לעשות את זה,
כי ככה אנחנו רק

944
00:42:57,620 --> 00:42:59,850
קריאה לפונקציה
פעם אחת בהתחלה,

945
00:42:59,850 --> 00:43:01,766
וכי בכל פעם ש
עובר זה הולך

946
00:43:01,766 --> 00:43:03,789
כדי לאחסן את הערך 3
שם, כי אתה לא

947
00:43:03,789 --> 00:43:05,330
צריך לבדוק כל זמן ללא הרף.

948
00:43:05,330 --> 00:43:05,743
כן.

949
00:43:05,743 --> 00:43:06,409
>> קהל: מצטער.

950
00:43:06,409 --> 00:43:09,070
רק [לא ברור].

951
00:43:09,070 --> 00:43:13,985
אתה יכול לעשות int n שווה strlen ולשים
שמעל מחוץ ללולאה

952
00:43:13,985 --> 00:43:15,364
גם כן?

953
00:43:15,364 --> 00:43:16,030
ANDI פנג: כן.

954
00:43:16,030 --> 00:43:17,100
אתה יכול לעשות את זה, בהחלט.

955
00:43:17,100 --> 00:43:19,970
הסיבה שיש לנו אותו בכאן היא
כי הדרך לעבודות לולאה

956
00:43:19,970 --> 00:43:23,500
הוא שזה נקרא
משתנה מקומי במובן

957
00:43:23,500 --> 00:43:26,150
שכל מה שאתה
יצירת הפנימית של לולאה

958
00:43:26,150 --> 00:43:27,890
רק קיים בתוך לולאה.

959
00:43:27,890 --> 00:43:31,530
>> אז אני רק משתנה
קיים בסוגריים אלה.

960
00:43:31,530 --> 00:43:35,260
וכאן המשתנים של n גם
קיים רק בסוגריים אלה.

961
00:43:35,260 --> 00:43:39,350
אז אם היה לך להשתמש strlen של
מילה מספר פעמים למטה,

962
00:43:39,350 --> 00:43:42,230
בהחלט הדרך הטובה ביותר לעשות את זה
יהיה להכריז עליה את הראש

963
00:43:42,230 --> 00:43:43,563
אז אתה לא צריך לעשות את זה פעם אחת.

964
00:43:43,563 --> 00:43:45,420
כן.

965
00:43:45,420 --> 00:43:47,670
קהל: למה יש לך
קו חדש לאחר אחוזים

966
00:43:47,670 --> 00:43:51,300
לראות אם אתה רוצה לשים את כל
המכתבים לידו להפריד?

967
00:43:51,300 --> 00:43:54,140
>> ANDI פנג: אה, אני רוצה
להדפיס את כולם בכל שורה.

968
00:43:54,140 --> 00:43:54,890
זה לא משנה.

969
00:43:54,890 --> 00:43:55,890
כן, זה עיצוב.

970
00:43:55,890 --> 00:43:57,181
זו שאלה טובה, אם כי.

971
00:43:57,181 --> 00:43:59,360
כן, אם אני רוצה להדפיס
את כל זה על רק קו אחד,

972
00:43:59,360 --> 00:44:02,731
לא הייתי המקף ב.

973
00:44:02,731 --> 00:44:03,230
אוקיי.

974
00:44:03,230 --> 00:44:06,880
כולם טובים?

975
00:44:06,880 --> 00:44:07,500
אוקיי.

976
00:44:07,500 --> 00:44:08,000
מגניב.

977
00:44:08,000 --> 00:44:12,080

978
00:44:12,080 --> 00:44:14,750
>> אז אני חושב שיש לי דיברתי מספיק.

979
00:44:14,750 --> 00:44:20,040
תורו של אתם לרוץ דרך
קוד ויגיד לי מה לא בסדר כאן.

980
00:44:20,040 --> 00:44:21,560
איפה הבאג?

981
00:44:21,560 --> 00:44:26,920
אז כפי שאתם יכולים לראות, אני כבר הכריז
מערך חדש של מחלקה בשם מחרוזת הסוג.

982
00:44:26,920 --> 00:44:30,220
ואני כבר הוזנתי סם,
ג'ס, וקים לתוכו.

983
00:44:30,220 --> 00:44:33,400
ואני מנסה להדפיס
כל האלמנטים של המערך.

984
00:44:33,400 --> 00:44:36,796
מישהו יכול להגיד לי למה זה
הוא הולך לתת לי בעיות?

985
00:44:36,796 --> 00:44:39,320
אני אתן לכם 10
שניות לחשוב על זה.

986
00:44:39,320 --> 00:44:55,490

987
00:44:55,490 --> 00:44:56,619
>> אוקיי.

988
00:44:56,619 --> 00:44:57,118
כן?

989
00:44:57,118 --> 00:45:01,972
>> קהל: האם מרכז השמאל
שווה 3 או [לא ברור]?

990
00:45:01,972 --> 00:45:02,680
ANDI פנג: ימין.

991
00:45:02,680 --> 00:45:06,784
אז כמה פעמים הוא זה בעצם
הולך לרוץ דרך לולאה זה?

992
00:45:06,784 --> 00:45:07,620
>> קהל: ארבעה.

993
00:45:07,620 --> 00:45:08,070
>> ANDI פנג: בדיוק.

994
00:45:08,070 --> 00:45:09,445
זה הולך דרך ארבע פעמים.

995
00:45:09,445 --> 00:45:12,250
זה הולך לרוץ דרך
ב 0, 1, 2, ו -3,

996
00:45:12,250 --> 00:45:15,200
בגלל האלמנט שלהם הוא אני
הוא פחות או שווה ל -3.

997
00:45:15,200 --> 00:45:16,960
זה לא הולך לעצור כאשר זה 2.

998
00:45:16,960 --> 00:45:18,800
זה הולך לשמור
הולך עד שהוא מגיע 3.

999
00:45:18,800 --> 00:45:21,720
וכמו שאנחנו יודעים, יש רק שלושה
אלמנטים במערך האמיתי שלנו.

1000
00:45:21,720 --> 00:45:27,260
>> אם ננסה לגשת הרביעי
אלמנט או המדד של 3,

1001
00:45:27,260 --> 00:45:30,357
אתה הולך להכות איפשהו
בזיכרון שאינו קיימים.

1002
00:45:30,357 --> 00:45:31,690
זה נקרא שליחות קטלנית null.

1003
00:45:31,690 --> 00:45:32,856
שום דבר לא הולך להיות שם.

1004
00:45:32,856 --> 00:45:35,324
המחשב שלך לא עומד
להיות מאוד שמח איתך.

1005
00:45:35,324 --> 00:45:36,170
כן.

1006
00:45:36,170 --> 00:45:38,430
האם יש למישהו שאלות
במה שקורה?

1007
00:45:38,430 --> 00:45:39,679
זה שטח משותף, כדי למנוע.

1008
00:45:39,679 --> 00:45:40,712
כן.

1009
00:45:40,712 --> 00:45:45,777
>> קהל: האם לא הראשון
להחליק גם מחרוזת של 2?

1010
00:45:45,777 --> 00:45:46,360
ANDI פנג: מס '

1011
00:45:46,360 --> 00:45:49,610
אז בעצם, כש
אתה עושה מערך,

1012
00:45:49,610 --> 00:45:51,540
כי זכות הסוגר
שם, שכל number--

1013
00:45:51,540 --> 00:45:53,480
זה אומר לך איך
אלמנטים רבים שיש לי.

1014
00:45:53,480 --> 00:45:55,840
זה לא ממש אומר לי
שלי האינדקסים של כל דבר.

1015
00:45:55,840 --> 00:45:58,760
אז במקרה הזה, אני יודע שאני רוצה
לכתוב עם שלושה מקומות,

1016
00:45:58,760 --> 00:46:02,690
עם שלושה מקומות פיזיים ל
להחזיק כל מה שאני רוצה להחזיק.

1017
00:46:02,690 --> 00:46:04,510
אז זאת הסיבה המספר שלוש הוא שם.

1018
00:46:04,510 --> 00:46:06,560
עם זאת, אם אני רוצה
למעשה לגשת אליו,

1019
00:46:06,560 --> 00:46:11,220
אם אני רוצה לומר, printf
מספר הסוגר כיתה, אז

1020
00:46:11,220 --> 00:46:14,560
אתה הולך לשים למעשה
המדד הפיזי שם.

1021
00:46:14,560 --> 00:46:16,330
כן, שאלה טובה.

1022
00:46:16,330 --> 00:46:20,065
>> קהל: אז הוא פיזי
מדד אמור להיות [לא ברור]?

1023
00:46:20,065 --> 00:46:20,940
ANDI פנג: אני מצטער.

1024
00:46:20,940 --> 00:46:21,500
האם אתה יכול לדבר קצת?

1025
00:46:21,500 --> 00:46:24,208
>> קהל: אז הוא המדד הפיזי
[לא ברור] כל אחת מהתיבות?

1026
00:46:24,208 --> 00:46:25,260
[לא ברור]?

1027
00:46:25,260 --> 00:46:26,040
>> ANDI פנג: כן.

1028
00:46:26,040 --> 00:46:28,970
אז אני הולך לחזור לכאן.

1029
00:46:28,970 --> 00:46:31,120
תחשוב על כאן.

1030
00:46:31,120 --> 00:46:32,820
יש לנו מערך של גודל 3.

1031
00:46:32,820 --> 00:46:35,540
יש שלושה מקומות, כמו,
מצייני מיקום פיזיים בפה.

1032
00:46:35,540 --> 00:46:37,620
אבל הם בשם 0, 1, ו -2.

1033
00:46:37,620 --> 00:46:40,700
אז אם אני רוצה לגשת אליהם,
אופן שבו אני לגשת אליהם

1034
00:46:40,700 --> 00:46:43,480
הוא printf של מה שאני רוצה כאן.

1035
00:46:43,480 --> 00:46:45,485
היית צריך להדפיס
את שמו של זה,

1036
00:46:45,485 --> 00:46:47,610
כי אז המחשב
יודע, הו, אני צריך להסתכל

1037
00:46:47,610 --> 00:46:51,391
במערך זה למדד ה 0.

1038
00:46:51,391 --> 00:46:51,890
כן.

1039
00:46:51,890 --> 00:46:53,306
אבל הגודל שלו לא משתנה.

1040
00:46:53,306 --> 00:46:55,492
הגודל הוא 3, ללא קשר
איך אתה לתייג אותם.

1041
00:46:55,492 --> 00:46:58,321

1042
00:46:58,321 --> 00:46:58,820
אוקיי.

1043
00:46:58,820 --> 00:47:01,387
כולם טובים?

1044
00:47:01,387 --> 00:47:02,970
קהל: אז כל פעם שאני [לא ברור]?

1045
00:47:02,970 --> 00:47:06,357

1046
00:47:06,357 --> 00:47:06,940
ANDI פנג: אישור.

1047
00:47:06,940 --> 00:47:13,270
אז במקרה הזה, אנחנו לא באמת
להיכנס לזה עכשיו בקורס.

1048
00:47:13,270 --> 00:47:16,760
אבל יודע שstring-- כמו ש
אמר לפני, מחרוזת היא למעשה

1049
00:47:16,760 --> 00:47:18,440
מערך של תווים.

1050
00:47:18,440 --> 00:47:21,430
אז אם אני יוצר מערך
של מחרוזות, אני סוג של

1051
00:47:21,430 --> 00:47:24,430
יש מערך של מערך
של דמויות, נכון?

1052
00:47:24,430 --> 00:47:27,720
>> אז במקרה הזה, כי אני
יש מערך של מחרוזות,

1053
00:47:27,720 --> 00:47:31,340
אם היית קלט מילה באמת ארוכה,
שעדיין תופס רק חלל אחד,

1054
00:47:31,340 --> 00:47:33,230
כי זה מחרוזת אחת.

1055
00:47:33,230 --> 00:47:37,492
אבל אם היית חושב על
הדמויות של מערך זה,

1056
00:47:37,492 --> 00:47:40,450
אז זה תופס הרבה יותר
דמויות מכל המילים האחרות

1057
00:47:40,450 --> 00:47:41,372
הם.

1058
00:47:41,372 --> 00:47:42,830
לא ממש חשוב לעכשיו.

1059
00:47:42,830 --> 00:47:44,921
אבל זה רק באופן כללי
איך זה עובד.

1060
00:47:44,921 --> 00:47:49,750

1061
00:47:49,750 --> 00:47:50,560
>> אוקיי.

1062
00:47:50,560 --> 00:47:55,840
אז זה משהו שאני אתן לך לעשות
הרבה במהלך הסמסטר.

1063
00:47:55,840 --> 00:47:57,500
אני צריך לנוח הקול שלי.

1064
00:47:57,500 --> 00:47:59,530
אתם צריכים לעורר את עצמכם.

1065
00:47:59,530 --> 00:48:02,300
הרבה אתה כנראה
צריך לישון עכשיו.

1066
00:48:02,300 --> 00:48:05,960
אני מזין בעיות אקראיות
שבו אנו כתובענה או

1067
00:48:05,960 --> 00:48:09,480
עם בן זוג לידך הולכים
לבלות כמה דקות דנות

1068
00:48:09,480 --> 00:48:14,980
על איך היינו הולכים על פתרון
או יצירת תכנית כגון זו.

1069
00:48:14,980 --> 00:48:17,100
>> אז עכשיו, אנחנו רוצים
כדי ליצור program--

1070
00:48:17,100 --> 00:48:19,560
אנחנו הולכים לקרוא לזה
upper.c-- שגרים

1071
00:48:19,560 --> 00:48:24,787
מילה קטנה למעמד העליון
אותיות רישיות string--, מצטער.

1072
00:48:24,787 --> 00:48:26,370
מילה במחרוזות, מצטער, הוא נרדף.

1073
00:48:26,370 --> 00:48:28,370
אני הולך לשנות אותם
לאומר את אותו דבר.

1074
00:48:28,370 --> 00:48:32,270

1075
00:48:32,270 --> 00:48:33,499
>> כן.

1076
00:48:33,499 --> 00:48:34,540
קח כמה דקות.

1077
00:48:34,540 --> 00:48:37,130
זה לא חייב להיות
נכתב בכל שפה.

1078
00:48:37,130 --> 00:48:39,890
רק בקוד פסאודו קוד או
באופן הגיוני איך אפילו שהיינו

1079
00:48:39,890 --> 00:48:42,083
ללכת על עושה את בעיה כזו.

1080
00:48:42,083 --> 00:48:42,583
כן.

1081
00:48:42,583 --> 00:48:49,881

1082
00:48:49,881 --> 00:48:52,780
>> [שיחת SIDE]

1083
00:48:52,780 --> 00:49:18,680

1084
00:49:18,680 --> 00:49:22,130
>> אני גם שמתי לב שאתם can--
אני סוג של לראות כבר את התכנית.

1085
00:49:22,130 --> 00:49:24,600
אני מניח שהחוסר שלי
מצב מגיש הוא בעיה.

1086
00:49:24,600 --> 00:49:27,410
אבל זה בסדר.

1087
00:49:27,410 --> 00:49:30,410
>> [שיחת SIDE]

1088
00:49:30,410 --> 00:50:03,589

1089
00:50:03,589 --> 00:50:04,380
כן, בבקשה, חבר 'ה.

1090
00:50:04,380 --> 00:50:05,400
בואו לקבל ממתקים.

1091
00:50:05,400 --> 00:50:06,372
בואו לקבל ממתקים.

1092
00:50:06,372 --> 00:50:07,698
>> קהל: כן!

1093
00:50:07,698 --> 00:50:09,958
>> [שיחת SIDE]

1094
00:50:09,958 --> 00:50:16,101

1095
00:50:16,101 --> 00:50:18,100
ANDI פנג: כן, כן,
אני אתחיל לזרוק סוכריות

1096
00:50:18,100 --> 00:50:20,280
באנשים שלא לענות על שאלות.

1097
00:50:20,280 --> 00:50:22,260
אז אתה צריך כל שאלות התשובה.

1098
00:50:22,260 --> 00:50:24,895
או אני מניח שאנשים ש
אין לענות על שאלות.

1099
00:50:24,895 --> 00:50:26,070
כן, להיפך.

1100
00:50:26,070 --> 00:50:28,570
>> [שיחת SIDE]

1101
00:50:28,570 --> 00:51:13,399

1102
00:51:13,399 --> 00:51:14,274
קהל: [לא ברור]

1103
00:51:14,274 --> 00:51:17,300

1104
00:51:17,300 --> 00:51:18,340
>> ANDI פנג: כן.

1105
00:51:18,340 --> 00:51:19,340
כן.

1106
00:51:19,340 --> 00:51:22,840
>> [שיחת SIDE]

1107
00:51:22,840 --> 00:51:40,700

1108
00:51:40,700 --> 00:51:41,590
>> בסדר, הבחורים.

1109
00:51:41,590 --> 00:51:44,731
קח, כמו, 10 שניות יותר.

1110
00:51:44,731 --> 00:51:48,210
>> [שיחת SIDE]

1111
00:51:48,210 --> 00:52:10,600

1112
00:52:10,600 --> 00:52:11,750
>> אישור, בחורים.

1113
00:52:11,750 --> 00:52:14,920
אז לפני שאנחנו מתחילים מנסים
ממש פיזי לכתוב קוד,

1114
00:52:14,920 --> 00:52:20,650
הרגל טובה לפתח היא ש
אנחנו רוצים סוג הראשון של סיבה

1115
00:52:20,650 --> 00:52:22,737
בהיגיון איך היינו עושה את זה.

1116
00:52:22,737 --> 00:52:24,570
אתה רוצה לוודא,
לפני שאתה פיזי

1117
00:52:24,570 --> 00:52:27,210
להתחיל לנסות לקודד
במריו, שתבצע

1118
00:52:27,210 --> 00:52:28,870
בטוח שיש לך פסאודו הקוד שלך.

1119
00:52:28,870 --> 00:52:31,235
כי הוא לוקח אותך דרך
מה שאתה צריך כדי ליצור כל כך

1120
00:52:31,235 --> 00:52:33,360
כי, כשאתה פיזי
לכתוב התכנית שלך מאוחר יותר,

1121
00:52:33,360 --> 00:52:36,640
אתה יכול יותר טוב לתפוס שגיאות
בקוד והדברים כאלה שלך.

1122
00:52:36,640 --> 00:52:40,460
>> אז אנחנו הולכים רק כדי להתחיל
by-- באנגלית, בפסאודו קוד,

1123
00:52:40,460 --> 00:52:43,320
האם מישהו רוצה לתת לי
לי הסבר הגנרית

1124
00:52:43,320 --> 00:52:46,250
איך היינו ללכת על עושה את זה?

1125
00:52:46,250 --> 00:52:48,102
כן.

1126
00:52:48,102 --> 00:52:49,664
>> קהל: [לא ברור].

1127
00:52:49,664 --> 00:52:50,830
ANDI פנג: בטח, אין דאגות.

1128
00:52:50,830 --> 00:52:57,233
קהל: האם אתה יכול לשאול אותו לאו לשאול
מישהו כדי לקבל מחרוזת 1-- כן, מחרוזת,

1129
00:52:57,233 --> 00:52:58,160
ואז--

1130
00:52:58,160 --> 00:52:59,826
>> ANDI פנג: כן, אז זה הוא התחלה טובה.

1131
00:52:59,826 --> 00:53:01,972
אני אתחיל להקליד, מצטער, כמו שאתה מדבר.

1132
00:53:01,972 --> 00:53:02,471
אז--

1133
00:53:02,471 --> 00:53:05,698
>> קהל: --the אותיות קטנות
מספרים גבוהים יותר, נכון?

1134
00:53:05,698 --> 00:53:08,519
או אותיות קטנות
יש מספרים גבוהים?

1135
00:53:08,519 --> 00:53:09,310
ANDI פנג: בדיוק.

1136
00:53:09,310 --> 00:53:16,156
קהל: אז אנחנו לחסר
32 מכל מה [לא ברור].

1137
00:53:16,156 --> 00:53:28,600

1138
00:53:28,600 --> 00:53:29,870
>> ANDI פנג: נהדר.

1139
00:53:29,870 --> 00:53:35,020
אז יש לנו סוג של תחושה כללית
של איך לעבוד על בעיה זו.

1140
00:53:35,020 --> 00:53:40,060
בידיעה שיש לנו סוג של למדו
אופן שבו מחרוזות הפיזיות

1141
00:53:40,060 --> 00:53:43,320
מאוחסנים בזיכרון,
מה לעשות שאתה כבר

1142
00:53:43,320 --> 00:53:45,920
יודע שאתה הולך כנראה
צריך לכתוב בקוד שלך

1143
00:53:45,920 --> 00:53:48,288
כדי לעבור את המחרוזת?

1144
00:53:48,288 --> 00:53:49,259
>> קהל: ללולאה.

1145
00:53:49,259 --> 00:53:50,550
ANDI פנג: ללולאה, בדיוק.

1146
00:53:50,550 --> 00:53:56,540

1147
00:53:56,540 --> 00:53:57,220
גדול.

1148
00:53:57,220 --> 00:54:00,539
אז אנחנו סוג של יש לי הגנרית
פסאודו קוד הכתוב למטה

1149
00:54:00,539 --> 00:54:02,330
כי סוג של נותן
אתה מציין על איך אתה

1150
00:54:02,330 --> 00:54:03,900
יעבור על פתרון הבעיה.

1151
00:54:03,900 --> 00:54:06,150
עכשיו שיש לך את זה, אתה
תוכל לחזור אליו מאוחר יותר

1152
00:54:06,150 --> 00:54:08,233
כאשר אתה מנסה
למעשה לכתוב את הקוד שלך.

1153
00:54:08,233 --> 00:54:10,240
אז אנחנו באמת יכולים ללכת כאן.

1154
00:54:10,240 --> 00:54:25,130
ויש לי פונקציה שנקראת upper.c--
שם זה הוא-- רק תבנית ריקה

1155
00:54:25,130 --> 00:54:28,510
עכשיו שאתם הולכים ל
תעזור לי להבין על איך לכתוב

1156
00:54:28,510 --> 00:54:30,430
הקו הזה של code-- לא שורת קוד.

1157
00:54:30,430 --> 00:54:32,890
זה יהיה מספר שורות הקוד.

1158
00:54:32,890 --> 00:54:35,710
>> כאשר מתחיל כל סוג
של pset הריק, מה

1159
00:54:35,710 --> 00:54:37,418
הדבר הראשון שאני צריך
לזכור לעשות?

1160
00:54:37,418 --> 00:54:39,290
>> קהל: [לא ברור].

1161
00:54:39,290 --> 00:54:41,000
>> ANDI פנג: כן גדול.

1162
00:54:41,000 --> 00:54:41,500
כולל.

1163
00:54:41,500 --> 00:54:44,850

1164
00:54:44,850 --> 00:54:47,130
stdio.h.

1165
00:54:47,130 --> 00:54:49,640
לעתים קרובות זה הוא אחד מ
אנשי טעויות קלים ביותר

1166
00:54:49,640 --> 00:54:51,598
יעשה כשהם
כתיבה, היא שהם

1167
00:54:51,598 --> 00:54:54,180
תשכח לכלול
ספרייה חשובה שהם צריכים.

1168
00:54:54,180 --> 00:54:57,689
אז אם זה שעתי עבודה ואתה כמו,
אני לא יודע למה הקוד שלי לא עובד.

1169
00:54:57,689 --> 00:54:59,230
האם אתה יכול להגיד לי למה זה לא עובד?

1170
00:54:59,230 --> 00:55:00,730
אנחנו הולכים להגיד לך #include?

1171
00:55:00,730 --> 00:55:02,520
אתה צריך #include זה.

1172
00:55:02,520 --> 00:55:03,270
אוקיי.

1173
00:55:03,270 --> 00:55:07,230
>> אז יש לנו תקן קלט / פלט כאן.

1174
00:55:07,230 --> 00:55:10,740
האם זה רק הספרייה
אנחנו הולכים צריכים כאן?

1175
00:55:10,740 --> 00:55:12,681
מה עוד אנחנו הולכים לעשות?

1176
00:55:12,681 --> 00:55:13,180
מצטער.

1177
00:55:13,180 --> 00:55:14,562
מישהו פשוט לצעוק את זה?

1178
00:55:14,562 --> 00:55:15,666
>> קהל: [לא ברור].

1179
00:55:15,666 --> 00:55:16,666
ANDI פנג: הנה לך.

1180
00:55:16,666 --> 00:55:20,320

1181
00:55:20,320 --> 00:55:21,440
אוקיי.

1182
00:55:21,440 --> 00:55:26,070
ואיך אני הולך על הפעלת כל סוג
של פונקציה, כל סוג של פונקציה העיקרית

1183
00:55:26,070 --> 00:55:28,760
במסגרת התכנית שלנו?

1184
00:55:28,760 --> 00:55:30,020
Int הראשי.

1185
00:55:30,020 --> 00:55:34,531

1186
00:55:34,531 --> 00:55:35,030
אוקיי.

1187
00:55:35,030 --> 00:55:35,970
מה אני יכול לשים בתוך כאן?

1188
00:55:35,970 --> 00:55:37,640
מה הדבר הראשון שאתה רוצה לעשות?

1189
00:55:37,640 --> 00:55:39,910
אם אנחנו רוצים להגיע
מחרוזת מהמשתמש,

1190
00:55:39,910 --> 00:55:43,870
מה שאנחנו הולכים לעשות
לעשות בשורה הראשונה זה?

1191
00:55:43,870 --> 00:55:46,120
מצטער, אתם פשוט מרגישים
חופשי לדבר וקול רם.

1192
00:55:46,120 --> 00:55:47,123
רק לצעוק כל מה שיצא.

1193
00:55:47,123 --> 00:55:48,772
>> קהל: בקש מהמשתמש?

1194
00:55:48,772 --> 00:55:49,980
ANDI פנג: איך אנחנו עושים את זה?

1195
00:55:49,980 --> 00:55:51,873
Ask-- אני הולך להקליד "לשאול את המשתמש"?

1196
00:55:51,873 --> 00:55:52,600
>> קהל: printf.

1197
00:55:52,600 --> 00:55:54,341
>> ANDI פנג: אישור.

1198
00:55:54,341 --> 00:55:54,840
Printf.

1199
00:55:54,840 --> 00:55:57,372
מה אני רוצה printf?

1200
00:55:57,372 --> 00:55:58,776
>> קהל: סוג במשהו.

1201
00:55:58,776 --> 00:56:02,760

1202
00:56:02,760 --> 00:56:03,840
>> ANDI פנג: כמו ש?

1203
00:56:03,840 --> 00:56:05,430
חבר'ה, להעמיד פנים כאילו אני במחשב.

1204
00:56:05,430 --> 00:56:08,475
תגיד לי מבחינה פיזית בכל שלב
שאני צריך להקליד בפה?

1205
00:56:08,475 --> 00:56:09,600
האם אני עושה משהו לא בסדר?

1206
00:56:09,600 --> 00:56:10,743
אני צריך שהקלדת משהו?

1207
00:56:10,743 --> 00:56:11,690
>> קהל: אתה צריך ציטוטים.

1208
00:56:11,690 --> 00:56:12,380
>> ANDI פנג: אני צריך ציטוטים?

1209
00:56:12,380 --> 00:56:12,880
אוקיי.

1210
00:56:12,880 --> 00:56:15,520

1211
00:56:15,520 --> 00:56:16,297
אוקיי.

1212
00:56:16,297 --> 00:56:17,698
>> קהל: ואז קו חדש.

1213
00:56:17,698 --> 00:56:21,434

1214
00:56:21,434 --> 00:56:22,465
פסיק.

1215
00:56:22,465 --> 00:56:23,340
ANDI פנג: פסיק?

1216
00:56:23,340 --> 00:56:24,060
אוקיי.

1217
00:56:24,060 --> 00:56:24,560
טוב.

1218
00:56:24,560 --> 00:56:27,060
>> קהל: ואולי לציין
שאתה רוצה את זה באותיות קטנות?

1219
00:56:27,060 --> 00:56:30,120

1220
00:56:30,120 --> 00:56:31,415
>> ANDI פנג: נהדר.

1221
00:56:31,415 --> 00:56:33,540
אתם צוחקים עליי
שוכח לשים פסיק.

1222
00:56:33,540 --> 00:56:36,350
אני מבטיח לך איפשהו
בקורס מסוג זה,

1223
00:56:36,350 --> 00:56:38,260
אתה לא תשכח לשים
פסיק, וזה

1224
00:56:38,260 --> 00:56:41,116
ייקח לך שלוש שעות כדי להבין
מדוע הקוד שלך לא עובד.

1225
00:56:41,116 --> 00:56:42,240
זה קרה לכולנו.

1226
00:56:42,240 --> 00:56:43,950
זה כנראה לא יקרה לך.

1227
00:56:43,950 --> 00:56:46,352
קבל ברגל טובה של שימוש בנקודה-פסיק.

1228
00:56:46,352 --> 00:56:46,852
אוקיי.

1229
00:56:46,852 --> 00:56:49,010
>> קהל: האם אתה רוצה
לעשות הקו הנטוי ב?

1230
00:56:49,010 --> 00:56:50,398
>> ANDI פנג: בטח.

1231
00:56:50,398 --> 00:56:51,856
האם אתה רוצה לעשות הקו הנטוי ב?

1232
00:56:51,856 --> 00:56:53,020
>> קהל: כן.

1233
00:56:53,020 --> 00:56:54,330
>> ANDI פנג: נהדר.

1234
00:56:54,330 --> 00:56:54,830
אוקיי.

1235
00:56:54,830 --> 00:56:57,872
מה אני עושה עכשיו?

1236
00:56:57,872 --> 00:56:58,964
>> קהל: קבל מחרוזת.

1237
00:56:58,964 --> 00:56:59,880
ANDI פנג: קבל מחרוזת.

1238
00:56:59,880 --> 00:57:03,080

1239
00:57:03,080 --> 00:57:03,830
אז מה אני מקליד?

1240
00:57:03,830 --> 00:57:04,233
מישהו?

1241
00:57:04,233 --> 00:57:05,040
>> קהל: מחרוזת s.

1242
00:57:05,040 --> 00:57:05,873
>> ANDI פנג: מחרוזת s.

1243
00:57:05,873 --> 00:57:07,251
קהל: GetString.

1244
00:57:07,251 --> 00:57:09,000
ANDI פנג: מישהו,
אתה יכול להגיד לי איפה

1245
00:57:09,000 --> 00:57:12,000
GetString פונקציה זו מגיעה?

1246
00:57:12,000 --> 00:57:13,660
>> קהל: string.h.

1247
00:57:13,660 --> 00:57:15,256
>> ANDI פנג: string.h?

1248
00:57:15,256 --> 00:57:16,715
אתה חושב שזה מstring.h?

1249
00:57:16,715 --> 00:57:17,830
>> קהל: [לא ברור].

1250
00:57:17,830 --> 00:57:18,830
>> ANDI פנג: הנה לך.

1251
00:57:18,830 --> 00:57:21,280
זה מCS50.h.

1252
00:57:21,280 --> 00:57:24,530
אם אתה מבולבל תמיד על שם
קובץ ספרייה הוא או קובץ כותרת הוא,

1253
00:57:24,530 --> 00:57:28,450
Google, פשוטו כמשמעו, string.h,
ואני אגיד לך

1254
00:57:28,450 --> 00:57:30,450
מה הן כל הפונקציות
שנמצאים בstring.h.

1255
00:57:30,450 --> 00:57:31,340
אוקיי.

1256
00:57:31,340 --> 00:57:35,210
>> אז עכשיו שאני יצרתי מחרוזת
ויש לי לבקש מהמשתמש לזה,

1257
00:57:35,210 --> 00:57:38,770
אני כבר מאוחסן זה במשתנה
של שם, מה אני צריך לעשות עכשיו?

1258
00:57:38,770 --> 00:57:40,652
>> קהל: בדוק אם זה באותיות קטנות.

1259
00:57:40,652 --> 00:57:41,360
ANDI פנג: מצטער?

1260
00:57:41,360 --> 00:57:42,545
קהל: בדוק אם זה באותיות קטנות.

1261
00:57:42,545 --> 00:57:44,045
ANDI פנג: בסדר, בואו נעשה את זה.

1262
00:57:44,045 --> 00:57:45,857
איך אני עושה את זה?

1263
00:57:45,857 --> 00:57:47,940
למעשה, למטרות
של המעמד עכשיו,

1264
00:57:47,940 --> 00:57:50,330
אנחנו פשוט הולכים ל
מניח את כל מה ש

1265
00:57:50,330 --> 00:57:52,620
שהקלט שכבר כתוב באותיות קטנות.

1266
00:57:52,620 --> 00:57:55,430
אם אתה רוצה לבדוק, שהיית
רק להוסיף הצהרה מותנית

1267
00:57:55,430 --> 00:57:59,640
שבדק, שעבר
כל אלמנט במערך

1268
00:57:59,640 --> 00:58:02,540
ובדק אם זה
בין ערכים מסוימים.

1269
00:58:02,540 --> 00:58:05,627
אני שוכח מה המספר
ערכים של אותיות קטנות הם.

1270
00:58:05,627 --> 00:58:07,210
אתה יכול לבדוק את זה על שולחן ASCII.

1271
00:58:07,210 --> 00:58:08,800
אבל כן, זה נקודה טובה באמת.

1272
00:58:08,800 --> 00:58:11,758
אבל כרגע, אנחנו רק הולכים
להניח שכל המחרוזות שקלט

1273
00:58:11,758 --> 00:58:13,130
הם באותיות קטנות.

1274
00:58:13,130 --> 00:58:13,870
אוקיי.

1275
00:58:13,870 --> 00:58:18,069
>> אז איך הייתי הולך על
בעיה זו הבאה?

1276
00:58:18,069 --> 00:58:18,860
קהל: ללולאה.

1277
00:58:18,860 --> 00:58:19,340
ANDI פנג: ללולאה?

1278
00:58:19,340 --> 00:58:19,839
אוקיי.

1279
00:58:19,839 --> 00:58:20,847
תגיד לי מה להקליד.

1280
00:58:20,847 --> 00:58:25,230
>> קהל: לint i שווה 0.

1281
00:58:25,230 --> 00:58:27,230
>> ANDI פנג: אישור.

1282
00:58:27,230 --> 00:58:36,350
>> קהל: אה, בעצם, אז אתה
לעשות פסיק ולעשות n שווה strlen.

1283
00:58:36,350 --> 00:58:38,940
>> ANDI פנג: דבר כל כך חשוב
כי אני חושב שהיא שמה לב כאן

1284
00:58:38,940 --> 00:58:42,936
הוא שאנחנו לא חייבים לומר int
n בפעם השנייה שעשינו את זה.

1285
00:58:42,936 --> 00:58:45,060
רק יודע של
לולאה כשאתה מכריז,

1286
00:58:45,060 --> 00:58:47,934
אתה באמת לא צריך int של
בפעם השנייה שאתה עושה משתנה.

1287
00:58:47,934 --> 00:58:51,202
אתה יכול לומר strlen n.

1288
00:58:51,202 --> 00:58:52,620
>> קהל: סעיף.

1289
00:58:52,620 --> 00:58:53,510
>> ANDI פנג: שניות.

1290
00:58:53,510 --> 00:58:54,706
אוקיי.

1291
00:58:54,706 --> 00:58:58,370
>> קהל: אז פסיק.

1292
00:58:58,370 --> 00:59:00,130
>> ANDI פנג: בטח.

1293
00:59:00,130 --> 00:59:04,050
>> קהל: ואז [לא ברור] n.

1294
00:59:04,050 --> 00:59:07,480

1295
00:59:07,480 --> 00:59:09,460
אז אני ++.

1296
00:59:09,460 --> 00:59:11,780
>> ANDI פנג: נהדר.

1297
00:59:11,780 --> 00:59:12,280
בסדר.

1298
00:59:12,280 --> 00:59:14,690
מה אנחנו רוצים בתוך
זה ללולאה עכשיו?

1299
00:59:14,690 --> 00:59:17,820
זכור, אם אנחנו הולכים לרוץ דרך
מחרוזת ולהפעיל באמצעות מערך,

1300
00:59:17,820 --> 00:59:19,287
אנחנו רוצים לבדוק דברים בזה.

1301
00:59:19,287 --> 00:59:20,370
מה אנחנו הולכים צריכים?

1302
00:59:20,370 --> 00:59:23,070

1303
00:59:23,070 --> 00:59:26,900
זהו סוג של החלק מסובך עכשיו.

1304
00:59:26,900 --> 00:59:27,960
למישהו יש ניחוש?

1305
00:59:27,960 --> 00:59:34,160

1306
00:59:34,160 --> 00:59:34,690
>> אוקיי.

1307
00:59:34,690 --> 00:59:37,830
אז קודם כל, איך אנחנו אפילו לגשת?

1308
00:59:37,830 --> 00:59:41,610
איך אנחנו אפילו סימון ראשון לעשות או
לגשת אלמנט במערך?

1309
00:59:41,610 --> 00:59:42,920
איך אנחנו עושים את זה?

1310
00:59:42,920 --> 00:59:47,120
מה הסימון אנו משתמשים כדי לעשות את זה?

1311
00:59:47,120 --> 00:59:50,920
מה שמו של מערך זה נקרא?

1312
00:59:50,920 --> 00:59:52,400
זה נקרא ים, נכון?

1313
00:59:52,400 --> 00:59:54,850
>> זכור, כל מחרוזת היא תמיד מערך.

1314
00:59:54,850 --> 00:59:58,210
כל כך הסוגר אני, נכון?

1315
00:59:58,210 --> 01:00:01,360
כי זה את הערך הנוכחי
או ערך מדד אנחנו בודקים.

1316
01:00:01,360 --> 01:00:05,156
ואנחנו הולכים להגדיר ששווים
צריכה-- אנחנו רוצים ערך קטנה, נכון?

1317
01:00:05,156 --> 01:00:07,530
אנחנו רוצים להפוך את זה lower--
מצטער, אנחנו רוצים באותיות גדולות.

1318
01:00:07,530 --> 01:00:10,014
אנחנו רוצים להפוך את האותיות הקטנות
ערך לאותיות גדולה.

1319
01:00:10,014 --> 01:00:11,805
וכך like-- אני מצטער,
מה שמך?

1320
01:00:11,805 --> 01:00:12,580
>> קהל: היידי.

1321
01:00:12,580 --> 01:00:12,940
>> ANDI פנג: מצטער?

1322
01:00:12,940 --> 01:00:13,280
>> קהל: היידי.

1323
01:00:13,280 --> 01:00:13,988
>> ANDI פנג: היידי.

1324
01:00:13,988 --> 01:00:15,850
כמו היידי אמר
בתחילה, אנחנו כנראה

1325
01:00:15,850 --> 01:00:20,330
הולך צריך כל-- אנחנו
כנראה אצטרך לחסר

1326
01:00:20,330 --> 01:00:22,630
32 מכל מה שcharc הוא, נכון?

1327
01:00:22,630 --> 01:00:24,680
כי בASCII
שולחן, ההבדל

1328
01:00:24,680 --> 01:00:27,790
בין אות קטנה
ואות גדולה היא 32.

1329
01:00:27,790 --> 01:00:31,290
לכן, כאשר אנחנו עושים את זה, אנחנו כנראה
הולך רוצה להחסיר 32, נכון?

1330
01:00:31,290 --> 01:00:33,910
>> אז אנחנו הולכים לעשות שלי.

1331
01:00:33,910 --> 01:00:37,590

1332
01:00:37,590 --> 01:00:41,200
האם כולם מבינים למה עשיתי את זה?

1333
01:00:41,200 --> 01:00:45,760
כי עכשיו, במערך שלנו,
אנחנו בודקים את מדד ה 0, נכון?

1334
01:00:45,760 --> 01:00:49,190
ובמדד ה 0 ב
מחרוזת, זה התו הראשון.

1335
01:00:49,190 --> 01:00:51,820
ואופי שאנחנו הולכים
להניח שזה קטנה.

1336
01:00:51,820 --> 01:00:55,980
אם אנחנו רוצים לעשות את זה באותיות גדולות, אנחנו
צריך להחסיר 32 מהערך שלה,

1337
01:00:55,980 --> 01:00:58,620
כי בASCII שלנו
שולחן, ככה אנחנו מקבלים את זה

1338
01:00:58,620 --> 01:01:01,600
למשנה מקביל
ערך זה עושה את זה באותיות גדולות.

1339
01:01:01,600 --> 01:01:03,714
האם כולם מבינים את זה?

1340
01:01:03,714 --> 01:01:04,213
כן.

1341
01:01:04,213 --> 01:01:06,530
>> קהל: אתה יכול גם
אין אותיות קטנות minus--

1342
01:01:06,530 --> 01:01:08,080
>> ANDI פנג: כן, אז זה
ממש ממש טוב.

1343
01:01:08,080 --> 01:01:10,455
אני הולך לחזור לזה
שאלה אחרי שאנחנו עושים את זה.

1344
01:01:10,455 --> 01:01:11,060
כן.

1345
01:01:11,060 --> 01:01:13,940
ואז אם אני רוצה
לראות מה קורה,

1346
01:01:13,940 --> 01:01:16,180
אני כנראה הולך ל
רוצה להדפיס, נכון?

1347
01:01:16,180 --> 01:01:19,930
מישהו יגיד לי מה
אני רוצה להדפיס כאן.

1348
01:01:19,930 --> 01:01:29,160
>> קהל: printf אחוזים
קו נטוי ג [לא ברור].

1349
01:01:29,160 --> 01:01:33,570
זה הערך של i S [לא ברור].

1350
01:01:33,570 --> 01:01:34,614
>> ANDI פנג: שניות אני, מצטער?

1351
01:01:34,614 --> 01:01:35,530
קהל: [לא ברור].

1352
01:01:35,530 --> 01:01:38,550

1353
01:01:38,550 --> 01:01:39,550
ANDI פנג: אני לא יודע.

1354
01:01:39,550 --> 01:01:40,600
מה אתה חושב?

1355
01:01:40,600 --> 01:01:44,016
>> קהל: ובכן, אני wouldn't--
אני מניח שלא הייתי bring--

1356
01:01:44,016 --> 01:01:46,944
הייתי לוקח אותו
בפנים, כי [לא ברור].

1357
01:01:46,944 --> 01:01:49,726

1358
01:01:49,726 --> 01:01:51,392
ANDI פנג: הו, אתה היה עושה את זה?

1359
01:01:51,392 --> 01:01:53,867
קהל: כן.

1360
01:01:53,867 --> 01:01:56,700
ANDI פנג: בוא נשאיר את זה בדרך
זה, ואני אסביר מדוע בהמשך.

1361
01:01:56,700 --> 01:01:58,533
זכור, גם כאשר אתה
יש בעל מקום,

1362
01:01:58,533 --> 01:02:00,701
אתה רוצה לשים סוגריים סביבו.

1363
01:02:00,701 --> 01:02:01,200
בסדר.

1364
01:02:01,200 --> 01:02:04,810
כך זה צריך להיות פונקציה מוצקה כאן.

1365
01:02:04,810 --> 01:02:06,370
בואו להפעיל אותו ולראות אם זה הידור.

1366
01:02:06,370 --> 01:02:08,750
הפוך עליון.

1367
01:02:08,750 --> 01:02:09,250
או הו.

1368
01:02:09,250 --> 01:02:12,030

1369
01:02:12,030 --> 01:02:13,340
זה לא נראה טוב מדי.

1370
01:02:13,340 --> 01:02:14,507
למה זה קורה?

1371
01:02:14,507 --> 01:02:17,340
כמו בכל שגיאה, אתה רוצה ללכת
בחזרה ולהתחיל עם הראשון,

1372
01:02:17,340 --> 01:02:20,630
כי בדרך כלל גורמי שגיאה אחת
המון טעויות אחרות אחריו.

1373
01:02:20,630 --> 01:02:26,700
כאן אנו רואים upper.c: 18: 25, שאומר לי
שלי בתכנית זו בשם upper.c,

1374
01:02:26,700 --> 01:02:33,800
על קו 18, שגיאה שהכריזה במשתמע
ספרייה של פונקציות strlen עם סוג

1375
01:02:33,800 --> 01:02:36,330
בלה unassigned--, אני לא יודע
מה קורה אחרי ש.

1376
01:02:36,330 --> 01:02:39,990
>> כל מה שאומר לי עכשיו הוא
משהו שקורה strlen.

1377
01:02:39,990 --> 01:02:43,520
והמחשב מבולבל, כי
זה כמו, אני לא יודע מה הוא strlen?

1378
01:02:43,520 --> 01:02:45,520
מה עושה את זה כנראה
להגיד לך שאתה חסר?

1379
01:02:45,520 --> 01:02:46,490
>> קהל: אתה חסר [לא ברור].

1380
01:02:46,490 --> 01:02:47,630
>> ANDI פנג: אתה צודק.

1381
01:02:47,630 --> 01:02:49,510
בדיוק.

1382
01:02:49,510 --> 01:02:52,140
אז זה המקום שבו זה
חשוב לוודא

1383
01:02:52,140 --> 01:02:56,970
שכל פונקציה שאתה משתמש בשלך
קוד הוא שיש בכותרת הנכונה

1384
01:02:56,970 --> 01:02:59,660
להגיש לספרייה, או אחר
אתה הולך לקבל הרבה שגיאות

1385
01:02:59,660 --> 01:03:01,150
והקוד שלך לא הולך
לדעת מה קורה.

1386
01:03:01,150 --> 01:03:03,050
אז אנחנו הולכים לכוללים string.h כאן.

1387
01:03:03,050 --> 01:03:06,270
>> כעת, כאשר אנו מנסים לקמפל עליון.

1388
01:03:06,270 --> 01:03:08,410
לקמפל כראוי.

1389
01:03:08,410 --> 01:03:09,960
בואו להפעיל את התכנית.

1390
01:03:09,960 --> 01:03:12,000
אז להקליד משהו באותיות קטנה.

1391
01:03:12,000 --> 01:03:14,920
מה אתם רוצים להקליד?

1392
01:03:14,920 --> 01:03:16,546
צועק משהו.

1393
01:03:16,546 --> 01:03:17,920
בסדר, Charly פשוט הלך ב.

1394
01:03:17,920 --> 01:03:18,990
אנחנו הקלד את השם של Charly.

1395
01:03:18,990 --> 01:03:21,670

1396
01:03:21,670 --> 01:03:22,840
>> Charly באותיות קטנה.

1397
01:03:22,840 --> 01:03:27,742
ואני מקווה, אני מקווה, זה הוא
הולך לצעוק ולירוק

1398
01:03:27,742 --> 01:03:28,575
Charly באותיות גדולה.

1399
01:03:28,575 --> 01:03:30,830
יש!

1400
01:03:30,830 --> 01:03:33,430
אין לכולם להבין כיצד
הלכתי על פתרון זה?

1401
01:03:33,430 --> 01:03:36,190
הדרך שאני יכול
לתפעל באמצעות מספרים שלמים

1402
01:03:36,190 --> 01:03:39,410
כדי לפתור משהו ש
אני רוצה לעשות במחרוזות,

1403
01:03:39,410 --> 01:03:44,390
בגלל תווים ומספרים שלמים יכולים
הפניה באותה הדרך, כי

1404
01:03:44,390 --> 01:03:45,540
מיפוי ASCII.

1405
01:03:45,540 --> 01:03:52,890
>> אז לחזור לנקודה שלך, אם אני
רציתי לשים כאן במקום 32

1406
01:03:52,890 --> 01:03:58,959
אותיות רישיות מינוס אותיות קטנות בדיוק כמו
ש, שיעבוד באותה מידה גם,

1407
01:03:58,959 --> 01:04:01,750
כי זה פשוט רק
הבדל בין שני ערכים אלה.

1408
01:04:01,750 --> 01:04:09,570
אם אני רוצה לעשות Charly again-- זה.

1409
01:04:09,570 --> 01:04:10,320
אוי לא.

1410
01:04:10,320 --> 01:04:11,820
אני חושב שהלכתי בדרך הלא נכונה, כן?

1411
01:04:11,820 --> 01:04:13,260
>> קהל: [לא ברור] אותיות קטנות.

1412
01:04:13,260 --> 01:04:14,260
>> ANDI פנג: הנה לך.

1413
01:04:14,260 --> 01:04:22,380

1414
01:04:22,380 --> 01:04:22,880
כן.

1415
01:04:22,880 --> 01:04:24,920
ומתוך יורק Charly.

1416
01:04:24,920 --> 01:04:28,020
כדי להיות זהיר כאשר
אתה הפחתת ערכים

1417
01:04:28,020 --> 01:04:30,400
לזכור איזה מהם הוא
יותר מאשר אחרים.

1418
01:04:30,400 --> 01:04:35,220
לדוגמא, עד כאן שכחתי
שאותיות קטנות הוא למעשה

1419
01:04:35,220 --> 01:04:38,540
גדול מא רישיות אז כש
ניסיתי להפחית אותם בדרך אחרת

1420
01:04:38,540 --> 01:04:40,600
מסביב, יש לי 32 שליליים.

1421
01:04:40,600 --> 01:04:42,800
וזה היה כמו המחשב שלי,
אני לא יודע מה זה.

1422
01:04:42,800 --> 01:04:45,810
זה הסתברות רק חלק אקראי
ערך שאינו טוב מאוד.

1423
01:04:45,810 --> 01:04:48,760
וכדי לוודא שאתה
הפחתה באורך הנכון

1424
01:04:48,760 --> 01:04:52,831
כדי למצוא את הדמות שאתה רוצה.

1425
01:04:52,831 --> 01:04:53,330
אוקיי.

1426
01:04:53,330 --> 01:04:58,550
מבולבל מישהו על איך אנחנו
הלך על כתיבת פונקציה זו?

1427
01:04:58,550 --> 01:04:59,180
אוקיי.

1428
01:04:59,180 --> 01:05:04,830
אז בעצם, פונקציה כבר
קיים בctype.h הספרייה בשם.

1429
01:05:04,830 --> 01:05:06,417
ctype.h נקרא של הספרייה.

1430
01:05:06,417 --> 01:05:08,500
פונקציה זו היא למעשה
כבר כתב לך.

1431
01:05:08,500 --> 01:05:10,820
זה נקרא לעליון.

1432
01:05:10,820 --> 01:05:13,027
>> וכך למטרות של
pset זה, אתה הולך

1433
01:05:13,027 --> 01:05:15,860
כדי לגלות שאתה באמת רוצה להשתמש
הרבה פונקציות הכלולות

1434
01:05:15,860 --> 01:05:17,390
בתוך ספריית ctype.

1435
01:05:17,390 --> 01:05:21,040
לעליון, להוריד, הוא עליון, הוא
lower-- אלה הם כל הפונקציות

1436
01:05:21,040 --> 01:05:24,914
שתוכל להשתמש מאוד,
מהר מאוד בקוד שלך ש

1437
01:05:24,914 --> 01:05:26,080
עושה בדיוק מה שזה עושה.

1438
01:05:26,080 --> 01:05:28,941
כתבנו איך להמיר
מחרוזת לאותיות גדולה.

1439
01:05:28,941 --> 01:05:31,440
אבל זה הוא למעשה הקוד
שמישהו אחר כתב

1440
01:05:31,440 --> 01:05:33,800
וכי אתה יכול לגשת ל
באמצעות פונקציה שונה.

1441
01:05:33,800 --> 01:05:34,300
כן?

1442
01:05:34,300 --> 01:05:39,570
>> קהל: אז אתה פשוט להעתיק של שם
ולעשות את זה לכל אות ואות?

1443
01:05:39,570 --> 01:05:42,070
>> ANDI פנג: כן, כי אני לא
אכפת הערכים.

1444
01:05:42,070 --> 01:05:44,540
אני פשוט אכפת שההבדל
ביניהם הוא 32, נכון?

1445
01:05:44,540 --> 01:05:48,210
ההבדל בין אותיות קטנות
B ו- B באותיות גדולות הוא גם 32.

1446
01:05:48,210 --> 01:05:50,860
וההבדל בין ג
ו- C באותיות גדולות הוא תמיד 32.

1447
01:05:50,860 --> 01:05:53,235
>> אני רק צריך לדאוג
הבדל בין שתיים,

1448
01:05:53,235 --> 01:05:56,666
כי כל המכתבים
בצע את אותו הדפוס, נכון?

1449
01:05:56,666 --> 01:05:58,540
אם יש לי את ההבדל
בין אחד מהם,

1450
01:05:58,540 --> 01:06:01,050
אני יודע מה ההבדל
בין כולם הוא.

1451
01:06:01,050 --> 01:06:01,740
שאלה טובה.

1452
01:06:01,740 --> 01:06:04,090
כן.

1453
01:06:04,090 --> 01:06:06,660
כולם טובים?

1454
01:06:06,660 --> 01:06:09,080
אוקיי.

1455
01:06:09,080 --> 01:06:09,580
OOP.

1456
01:06:09,580 --> 01:06:14,380

1457
01:06:14,380 --> 01:06:15,270
>> אוקיי.

1458
01:06:15,270 --> 01:06:20,310
אז רעיון אחר זה
הולך להיות מאוד שימושי כמו שאתה

1459
01:06:20,310 --> 01:06:22,570
תמשיך לפתח
הקוד שלך הוא הרעיון הזה

1460
01:06:22,570 --> 01:06:25,430
יצירת פונקציות או הפשטה.

1461
01:06:25,430 --> 01:06:28,479
אז עכשיו, כולנו לקחנו אלגברה.

1462
01:06:28,479 --> 01:06:31,770
באלגברה, אתה לומדים שיש
הדבר הנפלא הזה שנקרא פונקציה

1463
01:06:31,770 --> 01:06:35,300
מכונה, שבו אם אתה
סוג אחד של קלט מספר,

1464
01:06:35,300 --> 01:06:38,720
הוא פועל באמצעות הפונקציה הנפלאה הזה
ואת אבא פלט שונה, נכון?

1465
01:06:38,720 --> 01:06:42,220
בקוד, אותו הדבר קורה
בכל סוג של פונקציה.

1466
01:06:42,220 --> 01:06:48,230
>> אז אני יכול מבחינה פיזית
לכתוב בגוף של הקוד שלי שלי

1467
01:06:48,230 --> 01:06:52,357
הצהרה העיקרית שבעצם עושה
כל מה שהגוף של הקוד עושה.

1468
01:06:52,357 --> 01:06:54,940
אבל מחוץ לזה, אני יכול גם
לכתוב פונקציות רבות ושונות

1469
01:06:54,940 --> 01:06:56,320
כי לעשות דברים רבים ושונים.

1470
01:06:56,320 --> 01:06:58,570
לדוגמא, יש לנו כבר
התחיל להשתמש בחלק מהם.

1471
01:06:58,570 --> 01:07:00,610
Printf-- שהוא
פונקציה שמישהו אחר

1472
01:07:00,610 --> 01:07:02,870
כבר כתב ש
אנחנו יכולים לקרוא בקוד שלנו.

1473
01:07:02,870 --> 01:07:05,410
לupper-- במקרה זה,
upper-- היא פונקציה אחרת

1474
01:07:05,410 --> 01:07:07,330
אנחנו כבר נכתבו ש
יכול לקרוא בקוד שלנו.

1475
01:07:07,330 --> 01:07:09,520
ואז אני מניח שהסיבה לעשות
אפילו יש לנו פונקציות?

1476
01:07:09,520 --> 01:07:12,100
למה אנחנו לא רק פלופ זה
כולנו באותה שורת קוד?

1477
01:07:12,100 --> 01:07:13,730
זה עושה את זה קל עבור כולם.

1478
01:07:13,730 --> 01:07:19,200
>> ובכן, את ההיגיון מאחורי זה
הוא, קודם כל, ארגון.

1479
01:07:19,200 --> 01:07:21,880
זה ממש מעצבן הולך
באמצעות הקוד של מישהו

1480
01:07:21,880 --> 01:07:25,110
ותפקיד אחד כמו printf.

1481
01:07:25,110 --> 01:07:28,570
אם אתם ממש ידעו מה
printf הפונקציה כרוך לכתוב,

1482
01:07:28,570 --> 01:07:30,530
זה, כמו, 1000 שורות קוד.

1483
01:07:30,530 --> 01:07:32,357
>> אם בכל פעם שאני רוצה
לprintf משהו,

1484
01:07:32,357 --> 01:07:35,440
הייתי צריך לכתוב 1,000 שורות של קוד,
זה יהיה ממש מעצבן לקרוא,

1485
01:07:35,440 --> 01:07:36,290
נכון?

1486
01:07:36,290 --> 01:07:38,860
זו הסיבה שיש לנו רק
נוצר פונקציה מופשטת זה

1487
01:07:38,860 --> 01:07:41,670
שיש לנו כבר מישהו
אחר כתב במקום אחר.

1488
01:07:41,670 --> 01:07:44,920
ובכל פעם שאנחנו צריכים להשתמש בו ב
הקוד שלנו, אנחנו רק צריכים להגיד printf.

1489
01:07:44,920 --> 01:07:48,070
וכי הוא מסוגל להשתמש בפונקציה
מישהו אחר כתב בקוד שלנו.

1490
01:07:48,070 --> 01:07:51,020
זה עושה את זה קל יותר
הארגוני לקרוא קוד.

1491
01:07:51,020 --> 01:07:53,460
>> שנית, זה פישוט.

1492
01:07:53,460 --> 01:07:56,750
זה מפשט את הצעדים שיש לנו
לקחת כדי לפתור את הבעיה שלנו.

1493
01:07:56,750 --> 01:07:59,300
Printf, פונקציות כמו printf,
פונקציות כמו לעליון

1494
01:07:59,300 --> 01:08:03,560
כל הדברים שמאפשרים לנו
לפשט את הקוד שלנו כלפי מטה, כך שזה יותר קל.

1495
01:08:03,560 --> 01:08:05,830
והדבר האחרון הוא שימוש חוזר.

1496
01:08:05,830 --> 01:08:08,710
>> אז העובדה שיש לנו
printf פונקציה שנקראת

1497
01:08:08,710 --> 01:08:11,990
שאנחנו יכולים לקרוא רבים ושונים
פעמים ומאפשרת לה להיות לשימוש חוזר.

1498
01:08:11,990 --> 01:08:14,980
אם הייתי לכתוב printf,
אני כותב את זה רק פעם אחת.

1499
01:08:14,980 --> 01:08:16,439
היא קיימת רק שבמקום אחד.

1500
01:08:16,439 --> 01:08:19,890
אם אני רוצה לעשות את זה שוב, הייתי עושה
יש להעתיק ולהדביק את כל זה

1501
01:08:19,890 --> 01:08:21,760
בשורה השנייה שלי קוד.

1502
01:08:21,760 --> 01:08:24,880
זו הסיבה שאם אנו יוצרים פונקציה
שקיים מחוץ העיקרי שלנו,

1503
01:08:24,880 --> 01:08:26,880
אנחנו רק יכולים לקרוא ל
שלו ולהשתמש בו בכל פעם ש

1504
01:08:26,880 --> 01:08:29,604
אנחנו צריכים כל כך שזה הרבה יותר קל
עבורנו כתוכניות לכתוב.

1505
01:08:29,604 --> 01:08:32,220

1506
01:08:32,220 --> 01:08:35,549
>> אז הדרך שאנחנו למעשה לכתוב
פונקציה דומה מאוד, נכון?

1507
01:08:35,549 --> 01:08:37,590
זהו סוג של הראשון
למשל באשר נשלח

1508
01:08:37,590 --> 01:08:42,830
ראה לקחת פונקציה בסגנון
שונה מהחלל המרכזי int שלנו.

1509
01:08:42,830 --> 01:08:46,779
במקרה זה, אם אני רוצה
לכתוב פונקציה שנקראת Q, נכון?

1510
01:08:46,779 --> 01:08:49,370
>> וערך int כאן
הוא אומר לי כל,

1511
01:08:49,370 --> 01:08:51,649
מה שאני רוצה זה
לתפקד לחזור אליי?

1512
01:08:51,649 --> 01:08:54,484
אם אני רוצה קובייה שלם,
אני הולך לרוצה קלט.

1513
01:08:54,484 --> 01:08:55,525
אלו הם הפרמטרים.

1514
01:08:55,525 --> 01:08:58,490
אני הולך לתשומות ערך של int הסוג.

1515
01:08:58,490 --> 01:09:01,300
ואני הולך לחזור
ערך סוג אחר של int.

1516
01:09:01,300 --> 01:09:03,050
וכאן, כפי שאתה
ניתן לראות, כל מה שאני עושה

1517
01:09:03,050 --> 01:09:07,300
הוא עִקוּב מה הקלט שלי הוא
כפלט שלי והחזיר אותו.

1518
01:09:07,300 --> 01:09:10,790
>> אז כל פונקציה זו עושה היא
לוקח איזה מספר שלם.

1519
01:09:10,790 --> 01:09:14,979
זה מכפיל אותו בעצמו פעמיים
כך שהקוביות בתוקף.

1520
01:09:14,979 --> 01:09:17,729
ואז זה חוזר
מה הפלט שהוא.

1521
01:09:17,729 --> 01:09:20,540
אז במקרה הזה, זה שתי שורות של
קוד שהיה לנו לכתוב נוסף.

1522
01:09:20,540 --> 01:09:22,880
אבל אם אנחנו רוצים לקרוא
על זה מספר פעמים,

1523
01:09:22,880 --> 01:09:26,210
זה הרבה יותר קל להקליד כי אחד
קו ימין כאן זה בקובייה מ

1524
01:09:26,210 --> 01:09:28,830
צריך לעבור מספר רב של פעמים.

1525
01:09:28,830 --> 01:09:34,180
>> לכן הדרך שבעצם כל
עיצוב לכל סוג של פונקציה

1526
01:09:34,180 --> 01:09:36,420
הוא הולך להתקיים הוא כמו כאן.

1527
01:09:36,420 --> 01:09:38,659
אז יש לנו את שם הפונקציה.

1528
01:09:38,659 --> 01:09:39,950
במקרה זה, זה נקרא קובייה.

1529
01:09:39,950 --> 01:09:42,033
ואנחנו שם את זה קובייה כי
זה קל לזכור.

1530
01:09:42,033 --> 01:09:44,220
אתה יכול שם זה מרובע ו
בעצם יכול להיות קוביות זה.

1531
01:09:44,220 --> 01:09:45,500
לא משנה.

1532
01:09:45,500 --> 01:09:48,020
רק שם שאתה
הקצאת הפונקציה שלך.

1533
01:09:48,020 --> 01:09:51,660
>> זכות זו כאן, int, היא
סוג של הפרמטר שאתה צריך.

1534
01:09:51,660 --> 01:09:54,149
אז מה עושה בפונקציה זו
צריך כדי לפעול?

1535
01:09:54,149 --> 01:09:55,990
ובכן, הוא צריך קלט.

1536
01:09:55,990 --> 01:09:56,704
אני שם את זה קלט.

1537
01:09:56,704 --> 01:09:58,120
אתה יכול שם זה מה שאתה רוצה.

1538
01:09:58,120 --> 01:10:00,500
אבל אני צריך משהו מסוג int.

1539
01:10:00,500 --> 01:10:03,730
זה הולך לבצע בפועל
כל מה שבתוך מכאן,

1540
01:10:03,730 --> 01:10:04,990
הגוף של הפונקציה.

1541
01:10:04,990 --> 01:10:07,847
ולאחר מכן את סוג ההחזרה
ממש כאן, int-- זה

1542
01:10:07,847 --> 01:10:09,680
כל זה אומר לי ש
פונקציה זו היא

1543
01:10:09,680 --> 01:10:11,250
הולך לחזור אליי בint.

1544
01:10:11,250 --> 01:10:14,460
אז זה הולך לקחת בint, ו
זה הולך לתת לך בחזרה int.

1545
01:10:14,460 --> 01:10:17,750
האם כולם מבינים איך
עיצוב מסוג זה עובד?

1546
01:10:17,750 --> 01:10:18,250
מגניב.

1547
01:10:18,250 --> 01:10:24,690

1548
01:10:24,690 --> 01:10:25,740
>> אוקיי.

1549
01:10:25,740 --> 01:10:31,770
אז אל תהיה מודאג אם זה נראה
זכות מופשטת קצת עכשיו.

1550
01:10:31,770 --> 01:10:33,450
זה משהו שנדברנו על.

1551
01:10:33,450 --> 01:10:36,310
אנחנו לצלול עמוק יותר ב
בשלב מאוחר יותר בקורס.

1552
01:10:36,310 --> 01:10:41,170
הדרך שכל סוג של רמה גבוהה יותר
הפשטה של ​​העבודה את הדברים האלה

1553
01:10:41,170 --> 01:10:43,530
הוא ש, בזיכרון, ב
המחשב, הכל שלך

1554
01:10:43,530 --> 01:10:47,660
מאוחסן בסוג זה
של מחסנית, אני אגיד.

1555
01:10:47,660 --> 01:10:49,070
>> אז לשם בראש.

1556
01:10:49,070 --> 01:10:50,861
אני לא יודע אם אתה
אתם יכולים לראות שכן.

1557
01:10:50,861 --> 01:10:52,590
אני אנסה להתקרב.

1558
01:10:52,590 --> 01:10:55,111
כאן בראש, אנחנו
יש לי הטקסט הפיזי

1559
01:10:55,111 --> 01:10:57,860
ממה שהמחשב הוא interpreting--
כל האפסים ואחדים ש

1560
01:10:57,860 --> 01:10:59,540
קיימים בתוך המחשב שלנו.

1561
01:10:59,540 --> 01:11:03,390
ואז יש לנו אותחל
נתונים נתונים ולא מאותחלים,

1562
01:11:03,390 --> 01:11:05,340
מה שאנו מכנים משתנים גלובליים.

1563
01:11:05,340 --> 01:11:08,200
אז משתנים שקיימים
בכל התוכניות

1564
01:11:08,200 --> 01:11:11,815
ועל פני כולו שלך,
בעצם, קוד.

1565
01:11:11,815 --> 01:11:13,940
אל דאגה, אם אתם נמצאים
סוג של לא ברור על זה.

1566
01:11:13,940 --> 01:11:16,060
זה לא ממש משנה עכשיו.

1567
01:11:16,060 --> 01:11:18,680
>> ולאחר מכן יש לנו מה זה
נקרא ערימה בערימה.

1568
01:11:18,680 --> 01:11:21,140
תחשוב על ערימה, פשוטו כמשמעו, כ
בדיוק כמו ערימה של דברים,

1569
01:11:21,140 --> 01:11:23,098
ערימת שונה
דברים נדחפו על גבי

1570
01:11:23,098 --> 01:11:27,870
של כל אחד אחר שמאחסנים שונים
משתנים ותחביר בקוד שלך.

1571
01:11:27,870 --> 01:11:31,460
ואז כאן בתחתית מאוד,
יש לנו את משתני הסביבה

1572
01:11:31,460 --> 01:11:35,480
של מה שאתה מבצע ב
רק הקו הקטן שלך של קוד.

1573
01:11:35,480 --> 01:11:40,510
>> ואנחנו רק הולכים להגדיל
במצד הערימה בפועל.

1574
01:11:40,510 --> 01:11:43,880
אז כאן, אם היינו כדי להתקרב
בתחום זה רק על הערימה,

1575
01:11:43,880 --> 01:11:45,140
זה מה שזה נראה.

1576
01:11:45,140 --> 01:11:48,590
וזה בעצם די חשוב
כאשר אתם מדברים על פונקציות,

1577
01:11:48,590 --> 01:11:52,330
בגלל הודעה ש
זיכרון של המחשב שלך

1578
01:11:52,330 --> 01:11:55,600
הוא אחסון משתנה
והפונקציות

1579
01:11:55,600 --> 01:11:58,790
והפרמטרים של שני
פונקציה והמשתנים העיקריים שלך

1580
01:11:58,790 --> 01:12:00,190
במקומות שונים.

1581
01:12:00,190 --> 01:12:03,390
>> אז עכשיו, הוא עיקרי
הפונקציה הממשית

1582
01:12:03,390 --> 01:12:04,780
שאתה מבצע בקוד.

1583
01:12:04,780 --> 01:12:08,050
הפרמטרים שלו יש לך מאוחסנים כאן
והמשתנים המקומיים שלה מאוחסנים כאן.

1584
01:12:08,050 --> 01:12:12,270
משתנה מקומי רק אומר כל משתנים
שקיימים רק בתוך הפונקציה ש.

1585
01:12:12,270 --> 01:12:15,610
ועל גבי זה, יש לך את זה
פונקציה נפרדת בשם קובייה.

1586
01:12:15,610 --> 01:12:18,240
אתה צריך זה פרמטרים
כמו גם מקומיים אלה.

1587
01:12:18,240 --> 01:12:21,540
>> ואתה יכול הסיבה
רואה כאן הוא שמה

1588
01:12:21,540 --> 01:12:25,030
קורה כאשר לוקחת בקובייה
ערך מהפונקציה העיקרית שלך

1589
01:12:25,030 --> 01:12:27,640
הוא שלמעשה זה העתקה שמעל.

1590
01:12:27,640 --> 01:12:31,470
אז אם אני רוצה קובייה
2 ולחזור 8, ש2

1591
01:12:31,470 --> 01:12:33,730
הוא הוזן למעשה
כפרמטר וזה

1592
01:12:33,730 --> 01:12:37,690
הועתק על כך שיש לך את זה הקיים
בשני מקומות שונים בזיכרון.

1593
01:12:37,690 --> 01:12:40,520
ואתה צריך להיות מאוד זהיר
על זכירה שאחד מאותם

1594
01:12:40,520 --> 01:12:42,520
אתה בעצם מניפולציה.

1595
01:12:42,520 --> 01:12:47,170
ודוגמה למה שקרה
זה יהיה מאוד, מאוד רע

1596
01:12:47,170 --> 01:12:48,050
קיים כאן.

1597
01:12:48,050 --> 01:12:50,760

1598
01:12:50,760 --> 01:12:58,650
>> אז כאן, יש לי, בתאוריה,
תכנית ממש כאן, פונקציה עיקרי

1599
01:12:58,650 --> 01:13:02,180
כי אני מכריז int x שווה 1.

1600
01:13:02,180 --> 01:13:04,505
אני מכריז y int אחר שווה 2.

1601
01:13:04,505 --> 01:13:06,380
ואז אני מפעיל אותו
באמצעות פונקציה זו

1602
01:13:06,380 --> 01:13:09,647
החלפה נקראת, שבו אני מניח ש
זה החלפת שני הערכים.

1603
01:13:09,647 --> 01:13:11,480
ואז אני הולך ל
להדפיס אותם, נכון?

1604
01:13:11,480 --> 01:13:13,220
זה מה שאני רוצה לעשות תכנית זו.

1605
01:13:13,220 --> 01:13:15,180
>> אז בואו ארד ותסתכל.

1606
01:13:15,180 --> 01:13:18,200
אז אם אני באמת לכתוב שונה
פונקציה, כפי שניתן לראות,

1607
01:13:18,200 --> 01:13:19,750
יש לנו הפונקציה העיקרית שלנו כאן.

1608
01:13:19,750 --> 01:13:22,860
ואז יש לנו שלנו
פונקציה שנייה כאן.

1609
01:13:22,860 --> 01:13:24,520
החלפה מבוטלת.

1610
01:13:24,520 --> 01:13:27,090
Void רק אומר שזה
לא הולך לחזור כל דבר.

1611
01:13:27,090 --> 01:13:28,930
שם הפונקציה הוא
נקרא החלפה, וזה

1612
01:13:28,930 --> 01:13:33,730
הולך שני משתני הצריכה, int ו
int ב, מ[ לא ברור] הפונקציה שלך.

1613
01:13:33,730 --> 01:13:39,010
>> אז בעצם כאן, אנחנו
עובר x ו- y לפונקציה זו.

1614
01:13:39,010 --> 01:13:40,760
ואם היינו
ליצור זה-- ולכן אנחנו רוצים

1615
01:13:40,760 --> 01:13:42,420
כדי ליצור ערך זמני, נכון?

1616
01:13:42,420 --> 01:13:43,930
אנחנו הולכים להקצות של.

1617
01:13:43,930 --> 01:13:45,388
ואז הוא הולך ב החברה שווה.

1618
01:13:45,388 --> 01:13:47,660
ו- B הולך להיות חזרה
שבו הערך הזמני היה,

1619
01:13:47,660 --> 01:13:51,070
אשר הוא, כי כאשר
אתה רוצה להחליף דברים,

1620
01:13:51,070 --> 01:13:52,320
אתה לא יכול פשוט רוצה להחליף אותם.

1621
01:13:52,320 --> 01:13:54,360
>> אתה צריך לשמור את אחד
כאן, כך שהוא זוכר

1622
01:13:54,360 --> 01:13:56,485
מה שהוא, כי ברגע ש
אתה להחליף אחד, אתה שוכח

1623
01:13:56,485 --> 01:13:58,200
מה שהערך המקורי היה, נכון?

1624
01:13:58,200 --> 01:14:00,990
אז בתאוריה, תכנית זו
צריך לעבוד, נכון?

1625
01:14:00,990 --> 01:14:03,630
אם אני רוצה להחליף
שני, הם צריכים להחליף.

1626
01:14:03,630 --> 01:14:05,490
אז בואו להפעיל אותו ולראות אם זה עובד.

1627
01:14:05,490 --> 01:14:11,130

1628
01:14:11,130 --> 01:14:16,940
>> אז כפי שאתם יכולים לראות, x
היה פעם 1 ו- y היה פעם 2.

1629
01:14:16,940 --> 01:14:21,475
ואם אני להדפיס אותו,
x הוא עדיין 1 ו- y הוא 2.

1630
01:14:21,475 --> 01:14:25,970
הממ, נראה שתכנית זו לא להיות
עובד בדרך שאני רוצה שזה יעבוד.

1631
01:14:25,970 --> 01:14:29,950
האם מישהו רוצה לקחת זריקה ב
מנחש למה זה קורה?

1632
01:14:29,950 --> 01:14:34,430
זה קשור לדרך
שדברים שונים

1633
01:14:34,430 --> 01:14:38,172
מאוחסן במקומות שונים בזיכרון.

1634
01:14:38,172 --> 01:14:39,377
>> אוקיי.

1635
01:14:39,377 --> 01:14:41,960
אז אתם לא צריכים לדאוג
יותר מדי על זה עכשיו.

1636
01:14:41,960 --> 01:14:46,610
אבל יודע שהקובייה של מקומי
משתנים היו A ו- B,

1637
01:14:46,610 --> 01:14:49,230
כי כאן בתפקוד שלנו,
אנחנו כבר הכריזו וב

1638
01:14:49,230 --> 01:14:53,570
כמשתנים שקיימים
בתוך קובייה, פונקציה ש.

1639
01:14:53,570 --> 01:14:59,490
אבל כפי שאתה יכול לראות, את הפרמטרים ש
זה לוקח בהיו מאוחסן כאן.

1640
01:14:59,490 --> 01:15:01,370
אבל לא היינו ממש
חוזר כל דבר.

1641
01:15:01,370 --> 01:15:03,120
אנחנו לא באמת משתנים x ו- y.

1642
01:15:03,120 --> 01:15:04,440
אנחנו רק שינוי וב.

1643
01:15:04,440 --> 01:15:08,340
>> אנחנו העתקתי x ו- y ל
משהו שנקרא A ו- B.

1644
01:15:08,340 --> 01:15:11,092
אבל אנחנו אף פעם לא באמת
מניפולציות x ו- y את עצמם.

1645
01:15:11,092 --> 01:15:12,800
האם אתם רואים
איך זה קורה?

1646
01:15:12,800 --> 01:15:16,140
האם שאנחנו פשוט העתקנו אותו
מעל, אבל יש לנו לא שמרתי למעשה

1647
01:15:16,140 --> 01:15:18,030
אחר שבו הם היו בזיכרון.

1648
01:15:18,030 --> 01:15:20,127
>> ואז עכשיו המחשב
מחפש, הו, לי

1649
01:15:20,127 --> 01:15:21,960
לרוץ את הדבר הזה דרך
הפונקציה הנחמדה הזה.

1650
01:15:21,960 --> 01:15:23,690
אבל x ו- y הם עדיין x ו- y.

1651
01:15:23,690 --> 01:15:26,240
שום דבר לא קרה לי
שלהם בשל העובדה

1652
01:15:26,240 --> 01:15:28,340
כי פרמטרים אלה
ומשתנים מקומיים

1653
01:15:28,340 --> 01:15:30,150
מאוחסנים בשונה
מקום בזיכרון.

1654
01:15:30,150 --> 01:15:32,030
וזה ברמה גבוהה יותר
מושג שנוסיף ל

1655
01:15:32,030 --> 01:15:34,300
תתחיל לראות בהמשך הקורס.

1656
01:15:34,300 --> 01:15:36,950
אבל רק יודע שזה הוא
בעיה שיכול לקרות

1657
01:15:36,950 --> 01:15:41,400
ושאנחנו למצוא דרכים כיצד
להתמודד עם זה בשלב מאוחר יותר בקורס.

1658
01:15:41,400 --> 01:15:41,900
אוקיי.

1659
01:15:41,900 --> 01:15:47,750

1660
01:15:47,750 --> 01:15:48,250
בסדר.

1661
01:15:48,250 --> 01:15:51,780
אז הרעיון האחרון אנחנו
באמת הולך לכסות

1662
01:15:51,780 --> 01:15:53,880
זה הולך להיות שימושי
לpset השבוע

1663
01:15:53,880 --> 01:15:56,060
הם מה שנקראו
שורת פקודת טיעונים.

1664
01:15:56,060 --> 01:16:00,820
אז הלך רוב בהרצאתו ב
סוג של קצר על איך העבודה הבאות.

1665
01:16:00,820 --> 01:16:02,770
בעיקרו של דבר יודע ש
כאשר אתה כותב

1666
01:16:02,770 --> 01:16:06,280
כמו פונקציה העיקרית, כאשר אנו
כתב פונקציות לפני בעבר,

1667
01:16:06,280 --> 01:16:07,804
היו לנו החלל מרכזי int.

1668
01:16:07,804 --> 01:16:10,470
והסיבה שהיו לנו חלל יש
בגלל התוכניות שלנו לא

1669
01:16:10,470 --> 01:16:12,520
צריך ערכי קלט לרוץ, נכון?

1670
01:16:12,520 --> 01:16:16,020
כשרצתי מריו, אני לא צריך
בעצם פשוט להקליד משהו

1671
01:16:16,020 --> 01:16:16,970
כשרצתי מריו.

1672
01:16:16,970 --> 01:16:20,170
אני יכול לבקש מהמשתמש בהמשך.

1673
01:16:20,170 --> 01:16:22,450
אבל זה לא תמיד המקרה.

1674
01:16:22,450 --> 01:16:24,980
>> לדוגמא, בזה
הבעיה של השבוע קובעת,

1675
01:16:24,980 --> 01:16:28,365
אתה הולך להישאל ש, ב
בנוסף להפעלת התכנית שלך,

1676
01:16:28,365 --> 01:16:30,990
אתה הולך רוצה קלט
דברים מסוימים בישר כמו שאתה

1677
01:16:30,990 --> 01:16:32,050
להפעיל את התכנית שלך.

1678
01:16:32,050 --> 01:16:34,720
לכן הדרך שאנחנו עושים זה נקראת
טיעון שורת הפקודה, ש

1679
01:16:34,720 --> 01:16:37,280
זה כמו ויכוח
אתה יכול קלט ישירות

1680
01:16:37,280 --> 01:16:39,260
כפי שאתה מנסה להפעיל את התכנית שלך.

1681
01:16:39,260 --> 01:16:44,680
>> אז הסימון לכך,
זה נראה די מורכב,

1682
01:16:44,680 --> 01:16:47,320
אבל זה באמת לא כל כך
קשה. אז int main--

1683
01:16:47,320 --> 01:16:48,910
זה רק הפונקציה העיקרית שלך.

1684
01:16:48,910 --> 01:16:52,110
לסוגר argv מחרוזת פסיק argc.

1685
01:16:52,110 --> 01:16:56,040
אז כל מה שאמר הוא שזה
int כל שargc-- אומר לך

1686
01:16:56,040 --> 01:17:00,560
הוא שאותם הם מספר
טיעוני המחשב צריך לצפות.

1687
01:17:00,560 --> 01:17:03,130
>> אז דבר אחד שבאמת
חשוב לשמור על מסלול של

1688
01:17:03,130 --> 01:17:07,080
הוא השם הפיזי של התכנית שלך
ספירה כאחד טיעונים אלה.

1689
01:17:07,080 --> 01:17:11,080
אז אם אני רוצה שיהיה לי תכנית
לרוץ בתוספת שורת הפקודה נוספת אחד

1690
01:17:11,080 --> 01:17:13,310
ויכוח, אני בעצם
תצטרך שני.

1691
01:17:13,310 --> 01:17:15,080
Argc בעצם הולך להיות שתיים.

1692
01:17:15,080 --> 01:17:18,010
ולאחר מכן argv המחרוזת
bracket-- כל מה שהוא עושה,

1693
01:17:18,010 --> 01:17:20,410
זה נותן לי
מערך של מחרוזות זה

1694
01:17:20,410 --> 01:17:24,870
הולך רק כדי להציג ולאחסן את מה ש
כל טיעוני שורת הפקודה האלה.

1695
01:17:24,870 --> 01:17:34,090
>> כך למשל, אם אני רוצה לקבל את זה
תכנית, ./copy infile outfile, נכון?

1696
01:17:34,090 --> 01:17:37,330
זה רק פקודה לינוקס טיפוסית.

1697
01:17:37,330 --> 01:17:38,830
מה בעצם הוא argc?

1698
01:17:38,830 --> 01:17:41,320
כמה טיעוני שורת הפקודה
יש בעצם בזה?

1699
01:17:41,320 --> 01:17:45,130
כל זה עושה הוא ליצור עותק של
infile של שמו של קובץ אחד

1700
01:17:45,130 --> 01:17:47,070
והוא מעתיק אותו ל
קובץ אחר, נכון?

1701
01:17:47,070 --> 01:17:48,700
זה כל מה שזה עושה.

1702
01:17:48,700 --> 01:17:53,080
כפי שניתן לראות, אני עושה את זה בשורה אחת
מבלי להזדקק לתכנית.

1703
01:17:53,080 --> 01:17:55,380
>> מה הוא argc שלנו במקרה זה?

1704
01:17:55,380 --> 01:17:58,968
כמה טיעונים יש לנו?

1705
01:17:58,968 --> 01:17:59,634
קהל: שלוש?

1706
01:17:59,634 --> 01:18:01,200
ANDI פנג: יש לנו שלושה, בדיוק.

1707
01:18:01,200 --> 01:18:05,030
אז זה מאוד אינטואיטיבי ל
פשוט חושב שזה פשוט

1708
01:18:05,030 --> 01:18:06,290
infile וoutfile.

1709
01:18:06,290 --> 01:18:10,190
אבל יודע ששם הפיזי של
תכנית שאתה מפעיל ספירה כאחד.

1710
01:18:10,190 --> 01:18:13,220
אז במקרה הזה, argc הוא למעשה שלוש.

1711
01:18:13,220 --> 01:18:15,860
מה דעתך על, מה הוא argv 0?

1712
01:18:15,860 --> 01:18:18,180
זכור, כל
טיעוני שורת הפקודה

1713
01:18:18,180 --> 01:18:20,500
היו מאוחסן במערך של מחרוזות.

1714
01:18:20,500 --> 01:18:24,140
אז אם אני מנסה לגשת אליו, מה ש
היה argv הסוגר 0 לתת לי?

1715
01:18:24,140 --> 01:18:25,364
>> קהל: [לא ברור].

1716
01:18:25,364 --> 01:18:26,155
ANDI פנג: בדיוק.

1717
01:18:26,155 --> 01:18:28,550
זה היה נותן לי נקודה
לקצץ עותק, כי זה

1718
01:18:28,550 --> 01:18:31,070
האלמנט ה 0,
האלמנט הראשון של המערך שלי.

1719
01:18:31,070 --> 01:18:33,236
מה לגבי argv 1?

1720
01:18:33,236 --> 01:18:33,945
>> קהל: infile.

1721
01:18:33,945 --> 01:18:35,070
ANDI פנג: infile, בדיוק.

1722
01:18:35,070 --> 01:18:36,272
מה לגבי argv 2?

1723
01:18:36,272 --> 01:18:37,022
קהל: outfile.

1724
01:18:37,022 --> 01:18:38,190
ANDI פנג: outfile.

1725
01:18:38,190 --> 01:18:39,290
זה קצת מסובך עכשיו.

1726
01:18:39,290 --> 01:18:42,630
מה אתם חושבים argv
3 הולכים להיות נותנים לי

1727
01:18:42,630 --> 01:18:45,522
אם ניסיתי להדפיס את זה?

1728
01:18:45,522 --> 01:18:48,260
>> קהל: [לא ברור]?

1729
01:18:48,260 --> 01:18:50,164
>> ANDI פנג: האם יש לך את יד?

1730
01:18:50,164 --> 01:18:50,663
כן.

1731
01:18:50,663 --> 01:18:51,550
>> קהל: חלופי.

1732
01:18:51,550 --> 01:18:52,341
>> ANDI פנג: בדיוק.

1733
01:18:52,341 --> 01:18:55,440
אז לזכור בהרצאה ש
יש בסוף משהו גזע

1734
01:18:55,440 --> 01:18:56,640
בשם שליחות קטלנית null?

1735
01:18:56,640 --> 01:18:58,890
אנחנו נכנסים לזה גם
נוסף על בכיתה.

1736
01:18:58,890 --> 01:19:02,472
אבל יודע שבסימון,
דרך המחשב שלך

1737
01:19:02,472 --> 01:19:04,430
יודע שזה הסוף
של המערך הוא שזה

1738
01:19:04,430 --> 01:19:07,310
מכניס נקרא null משהו
שליחות קטלנית או מקף אפס.

1739
01:19:07,310 --> 01:19:12,047
>> אז אם אתה מנסה לגשת לargv 3,
אתה הולך להכות מקף זה 0.

1740
01:19:12,047 --> 01:19:13,630
זה אפילו יותר משאלה מכשילה.

1741
01:19:13,630 --> 01:19:17,020
מה לגבי argv 4?

1742
01:19:17,020 --> 01:19:20,920
אז זה שליחות קטלנית null עבר,
עבר גבולות המערך שלנו.

1743
01:19:20,920 --> 01:19:24,380
מה אתה חושב הולך
קורה כאשר אנחנו מנסים לעשות את זה?

1744
01:19:24,380 --> 01:19:25,842
>> קהל: [לא ברור]?

1745
01:19:25,842 --> 01:19:26,550
ANDI פנג: מצטער?

1746
01:19:26,550 --> 01:19:28,025
אומר שקצת יותר חזק?

1747
01:19:28,025 --> 01:19:29,086
>> קהל: [לא ברור].

1748
01:19:29,086 --> 01:19:29,710
ANDI פנג: כן.

1749
01:19:29,710 --> 01:19:32,420
שהוא שמו של
אזור סביר להניח שתקבל.

1750
01:19:32,420 --> 01:19:36,610
אבל יודע שargv 4--
המאפשר לך גישה ל

1751
01:19:36,610 --> 01:19:38,610
מקומות במחשב שלך
זיכרון שאתה באמת

1752
01:19:38,610 --> 01:19:41,650
לא צריך להיות נוגעים ללב, כי
נכון עכשיו אתה יודע מה argv הוא.

1753
01:19:41,650 --> 01:19:46,220
אתה יודע שזה מערך של גודל 3
שיש עותק נקודה, infile וoutfile.

1754
01:19:46,220 --> 01:19:50,200
>> אם אתה מנסה ללכת כל כך הרבה מעבר לזה
שאתה עבר שליחות קטלנית null,

1755
01:19:50,200 --> 01:19:53,050
המחשב שלך יש כנראה
משהו מאוחסן בargv 4.

1756
01:19:53,050 --> 01:19:55,790
ואתה באמת לא צריך להיות
אפשר גישה לargv 4,

1757
01:19:55,790 --> 01:19:58,130
בגלל שיש לך קובץ
ממשלה ואתה רק

1758
01:19:58,130 --> 01:19:59,790
אפשר גישה לשלושת מדפים אלה.

1759
01:19:59,790 --> 01:20:02,870
אבל אם אתה מנסה להגיע הרבה מעבר ל
המדף של איפה אתה מורשה,

1760
01:20:02,870 --> 01:20:04,930
אתה הולך להתחיל להתעסק עם
דברים אחרים בזיכרון של המחשב שלך.

1761
01:20:04,930 --> 01:20:06,690
זה הולך להיות ממש, ממש רע.

1762
01:20:06,690 --> 01:20:07,440
אז פשוט יודע את זה.

1763
01:20:07,440 --> 01:20:10,370
להיות זהיר מאוד, כי אתה
לא רק באופן אקראי להתחיל

1764
01:20:10,370 --> 01:20:14,772
גישה לאלמנטים במערך ש
לא היו במה שאתה רוצה ליצור.

1765
01:20:14,772 --> 01:20:17,114
כן.

1766
01:20:17,114 --> 01:20:18,430
>> אוקיי.

1767
01:20:18,430 --> 01:20:26,360
אז אנחנו הולכים לעשות עוד
דוגמא מסוף כאן.

1768
01:20:26,360 --> 01:20:27,300
אוקיי.

1769
01:20:27,300 --> 01:20:29,900
אז רוב במהירות בהרצאה
היום האחר הלך

1770
01:20:29,900 --> 01:20:35,040
דרך דוגמא זו, שבו הוא
argv היה int int argc העיקרי המחרוזת

1771
01:20:35,040 --> 01:20:39,090
סוגריים, שאומר לי שאני
הולך להיות טיעוני שורת הפקודה.

1772
01:20:39,090 --> 01:20:41,860
>> יש לו, אם argc שווה
שווה 2-- לזכור,

1773
01:20:41,860 --> 01:20:45,070
שווה שווים משמעות השוואה.

1774
01:20:45,070 --> 01:20:47,980
אם זה שווה 2, אז אני
הולך להדפיס שלום,

1775
01:20:47,980 --> 01:20:51,190
מה הראשון
אלמנט של המערך הוא.

1776
01:20:51,190 --> 01:20:54,100
הדפסה אחרת, שלום עולם.

1777
01:20:54,100 --> 01:20:56,300
מה זה הולך
יקרה בעצם?

1778
01:20:56,300 --> 01:21:00,570
מישהו יכול להסביר רק ב
אנגלית מה התכנית הזו עושה?

1779
01:21:00,570 --> 01:21:01,272
כן.

1780
01:21:01,272 --> 01:21:08,160
>> קהל: אם מישהו הקליד בפקודה
ואמר את השם הראשון והאחרון שלהם,

1781
01:21:08,160 --> 01:21:12,096
זה לא פשוט להדפיס
ראשון אחד ולומר, שלום,

1782
01:21:12,096 --> 01:21:14,090
מה השם הפרטי שלך הוא.

1783
01:21:14,090 --> 01:21:15,410
>> ANDI פנג: בסדר, בוא להפעיל אותו.

1784
01:21:15,410 --> 01:21:22,470
כך למשל, אם אני היה לעשות
קובץ זה לעשות שלום צריכה-- שלום

1785
01:21:22,470 --> 01:21:24,500
צריכה-- מה אתה רוצה שאני קלט?

1786
01:21:24,500 --> 01:21:25,900
>> קהל: ראשון ואחרון שם.

1787
01:21:25,900 --> 01:21:27,280
>> ANDI פנג: פרטים אישיים?

1788
01:21:27,280 --> 01:21:28,180
החדרים?

1789
01:21:28,180 --> 01:21:29,690
>> קהל: כן.

1790
01:21:29,690 --> 01:21:33,490
>> ANDI פנג: מישהו יכול להגיד לי
שלי עכשיו, מה הוא argc?

1791
01:21:33,490 --> 01:21:35,630
בדיוק שם?

1792
01:21:35,630 --> 01:21:36,290
אופס, מצטער.

1793
01:21:36,290 --> 01:21:37,920
תן לי לחזור.

1794
01:21:37,920 --> 01:21:40,740
כמה טיעוני שורת הפקודה
הן-- אתם באמת לא יכולים לראות.

1795
01:21:40,740 --> 01:21:43,760
אבל אני אנסה להתמקד ב.

1796
01:21:43,760 --> 01:21:44,290
אני מנסה.

1797
01:21:44,290 --> 01:21:45,414
כן, יש שלוש, נכון?

1798
01:21:45,414 --> 01:21:48,750
זה קו נטוי נקודת שלום,
זה אנדי, וזה פנג.

1799
01:21:48,750 --> 01:21:51,870
>> אז מה אתם חושבים שזה
תכנית הולכת להיות הדפסה החוצה?

1800
01:21:51,870 --> 01:21:55,550

1801
01:21:55,550 --> 01:21:56,060
אה.

1802
01:21:56,060 --> 01:21:57,120
אה סליחה.

1803
01:21:57,120 --> 01:21:57,810
שם הלא נכון.

1804
01:21:57,810 --> 01:22:03,630

1805
01:22:03,630 --> 01:22:06,130
זה להדפיס אותו, הלו עולם.

1806
01:22:06,130 --> 01:22:09,603
האם מישהו רוצה להסביר
מדוע זה קורה?

1807
01:22:09,603 --> 01:22:10,103
כן?

1808
01:22:10,103 --> 01:22:11,019
>> קהל: [לא ברור].

1809
01:22:11,019 --> 01:22:14,439

1810
01:22:14,439 --> 01:22:15,230
ANDI פנג: בדיוק.

1811
01:22:15,230 --> 01:22:19,940
אז הנה, הם על תנאי
כלומר, אם argc שווה שווה 2.

1812
01:22:19,940 --> 01:22:23,650
אז רק במקרה שיש
שני טיעוני שורת הפקודה.

1813
01:22:23,650 --> 01:22:25,850
אז אני הולך להדפיס,
שלום, מה שזה לא.

1814
01:22:25,850 --> 01:22:28,210
אבל אחר, אני הולך
להדפיס רק, שלום עולם.

1815
01:22:28,210 --> 01:22:30,040
אז מישהו רוצה
לתת לי דוגמא

1816
01:22:30,040 --> 01:22:35,050
איך אני יוכל לבעצם
קבל את זה כדי להדפיס את הערך של argv 1?

1817
01:22:35,050 --> 01:22:38,600
>> מה הייתי צריך קלט כאן?

1818
01:22:38,600 --> 01:22:39,840
רק דבר אחד, נכון?

1819
01:22:39,840 --> 01:22:42,900
בגלל שלום הנקודה לכבר
ספירה כטענה הראשונה.

1820
01:22:42,900 --> 01:22:43,930
יש לי רק אחד יותר.

1821
01:22:43,930 --> 01:22:46,470
אז נקודה שלום אם אני פשוט עושה את אנדי.

1822
01:22:46,470 --> 01:22:47,270
שלום, אנדי.

1823
01:22:47,270 --> 01:22:49,186
האם כולם מבינים
מדוע זה קורה?

1824
01:22:49,186 --> 01:22:49,602
כן.

1825
01:22:49,602 --> 01:22:52,500
>> קהל: אז את החלל שבין
line-- הפקודה הוא [לא ברור] זה?

1826
01:22:52,500 --> 01:22:56,247

1827
01:22:56,247 --> 01:22:56,830
ANDI פנג: מס '

1828
01:22:56,830 --> 01:23:03,810
אז המרחב בשורת הפקודה
טיעון, x, לספר המחשב

1829
01:23:03,810 --> 01:23:06,820
שזה הוא ההתחלה של מחרוזת חדשה.

1830
01:23:06,820 --> 01:23:11,130
אז argv מחרוזת כאן-- זה חנויות
כל הטענות שלך שורת הפקודות

1831
01:23:11,130 --> 01:23:13,110
במחרוזות.

1832
01:23:13,110 --> 01:23:17,420
וכך המקום בשורת הפקודה
argument-- כל מה שעושה הוא להגיד לך,

1833
01:23:17,420 --> 01:23:21,030
זה בסופו של מיתר אחד
וזה זמן להמשיך הלאה למשנהו.

1834
01:23:21,030 --> 01:23:21,990
>> כן.

1835
01:23:21,990 --> 01:23:23,530
זה די חשוב ל
pset, בגלל שאתה

1836
01:23:23,530 --> 01:23:24,613
הולך להיות בדיקה אלה.

1837
01:23:24,613 --> 01:23:29,300
אז האם מישהו יש
שאלות על זה?

1838
01:23:29,300 --> 01:23:30,016
בסדר מגניב.

1839
01:23:30,016 --> 01:23:30,515
כן?

1840
01:23:30,515 --> 01:23:35,008
>> הקהל: אז הסיבה שהיית
לשים Calc טיעון השלם במקום

1841
01:23:35,008 --> 01:23:40,059
של [לא ברור] יהיה כאשר אתה רוצה
להקליד מידע נוסף ל

1842
01:23:40,059 --> 01:23:41,030
[לא ברור]?

1843
01:23:41,030 --> 01:23:42,090
>> ANDI פנג: כן, בדיוק.

1844
01:23:42,090 --> 01:23:45,370
תוכניות מסוימות מחייבות
לקלט טיעון שורת הפקודה

1845
01:23:45,370 --> 01:23:47,732
שהוא עובר ושבמשתמש בזה.

1846
01:23:47,732 --> 01:23:49,035
כן.

1847
01:23:49,035 --> 01:23:50,410
קהל: אז מה אם [לא ברור]?

1848
01:23:50,410 --> 01:23:55,440

1849
01:23:55,440 --> 01:23:58,870
>> ANDI פנג: ובכן, לעשות את מה שיש לי
לשנות אז בתכנית שלי?

1850
01:23:58,870 --> 01:23:59,870
>> קהל: רק 3.

1851
01:23:59,870 --> 01:24:12,460

1852
01:24:12,460 --> 01:24:15,020
>> ANDI פנג: למה זה
קורה, אתה חושב?

1853
01:24:15,020 --> 01:24:18,940
>> קהל: כי [לא ברור].

1854
01:24:18,940 --> 01:24:22,370
>> קהל: היית צריך
לשנות את זה ל 2 [לא ברור].

1855
01:24:22,370 --> 01:24:23,484
>> קהל: 1 ו -2.

1856
01:24:23,484 --> 01:24:24,650
ANDI פנג: 1 ו -2, בדיוק.

1857
01:24:24,650 --> 01:24:29,150
אז במקרה הזה, אתה כנראה היית
רוצה להיות שני printf statements--

1858
01:24:29,150 --> 01:24:32,601
אחד שמודפס argv 1 ו
אחד שמודפס argv 2.

1859
01:24:32,601 --> 01:24:33,100
כאן.

1860
01:24:33,100 --> 01:24:34,516
אני באמת יכול לעשות את זה ממש מהר.

1861
01:24:34,516 --> 01:24:46,720

1862
01:24:46,720 --> 01:24:47,320
הנה לך.

1863
01:24:47,320 --> 01:24:48,287
אה.

1864
01:24:48,287 --> 01:24:49,370
לא בדיוק מה שרצית.

1865
01:24:49,370 --> 01:24:52,590
אבל אם אתם להתעסק עם
העיצוב, זה ייצא.

1866
01:24:52,590 --> 01:24:54,981
כן.

1867
01:24:54,981 --> 01:24:55,480
מגניב.

1868
01:24:55,480 --> 01:24:57,670
אני יודע שאנחנו קצת קצרים בזמן.

1869
01:24:57,670 --> 01:25:02,469
אבל אני רק הולך לבלות במהירות
דקות זוג עוברות helpful--

1870
01:25:02,469 --> 01:25:03,760
קהל: יש לך שתי דקות.

1871
01:25:03,760 --> 01:25:05,010
ANDI פנג: יש לי שתי דקות?

1872
01:25:05,010 --> 01:25:06,340
תודה.

1873
01:25:06,340 --> 01:25:09,180
כמה טיפים pset מהירים.

1874
01:25:09,180 --> 01:25:13,100
אז לpset זה, אני מאוד ממליץ,
כמו שאמרתי, כולם לקרוא את המפרט.

1875
01:25:13,100 --> 01:25:16,804
אתה כותב שלוש programs-- אחד
נקרא initials.c, אחד בשם caesar.c,

1876
01:25:16,804 --> 01:25:17,720
vigenere.c נקרא אחד.

1877
01:25:17,720 --> 01:25:20,465

1878
01:25:20,465 --> 01:25:22,340
כמה טיפים חשובים ש
אתם באמת רוצים

1879
01:25:22,340 --> 01:25:25,040
כדי לשמור על בmind-- כך
יש פונקציה זו

1880
01:25:25,040 --> 01:25:27,770
נקרא atoi-- כמו שאני אוהב לומר, טרואה.

1881
01:25:27,770 --> 01:25:29,520
לא ברור אם זה
למעשה איך אתה אומר את זה.

1882
01:25:29,520 --> 01:25:32,510
אבל כל זה עושה, זה מזין.

1883
01:25:32,510 --> 01:25:34,320
הוא ממיר מחרוזת לint.

1884
01:25:34,320 --> 01:25:37,490
אז מייצג ASCII לי שלם.

1885
01:25:37,490 --> 01:25:40,310
זה פשוט המרת ASCII
ערכים לinteger ערכים.

1886
01:25:40,310 --> 01:25:44,510
אז לזכור argv, המערך שחנויות
כל הפקודות שלך בשורה arguments--

1887
01:25:44,510 --> 01:25:46,300
הוא מאחסן את כולם כמחרוזות.

1888
01:25:46,300 --> 01:25:50,010
ולכן אם אתה רוצה להיות מסוגל
יש אחד מהם הפך לשלם,

1889
01:25:50,010 --> 01:25:52,750
אתה הולך לי
להשתמש ערך זה כאן.

1890
01:25:52,750 --> 01:25:56,690
>> מודולו, כמו שאנחנו מכוסים
מוקדם יותר היום בכיתה,

1891
01:25:56,690 --> 01:25:59,550
מאפשר לך להיות
שאר מה שיש לך.

1892
01:25:59,550 --> 01:26:03,620
אז אם יש לנו באמת, באמת
מספרים גדולים בקיסר,

1893
01:26:03,620 --> 01:26:06,117
מה אם יש לנו את הסוף
של מחרוזת של Vigenere?

1894
01:26:06,117 --> 01:26:08,450
איך אתה הולך להיות מסוגל
כדי לקבל את זה כדי לעטוף?

1895
01:26:08,450 --> 01:26:11,330
אם אני מכה z ואני רוצה
זה לחזור ל,

1896
01:26:11,330 --> 01:26:13,650
איך אני הולך לקבל
כי כדי לעטוף?

1897
01:26:13,650 --> 01:26:15,960
כנראה רוצה להשתמש
מודולו שם איפשהו.

1898
01:26:15,960 --> 01:26:19,190
>> שנית, לגלוש סביב
הספרייה שלך. ctype.h.

1899
01:26:19,190 --> 01:26:20,680
זה ספרייה חדשה שיש לנו.

1900
01:26:20,680 --> 01:26:25,270
אתה תמצא הרבה באמת, באמת
isupper functions-- שימושי, islower,

1901
01:26:25,270 --> 01:26:27,681
toupper, tolower, isalpha, וכולי.

1902
01:26:27,681 --> 01:26:30,680
כל הפונקציות שתהיינה מאוד שימושי
כאשר אתה מנסה להבין,

1903
01:26:30,680 --> 01:26:33,780
היא הדמות הזאת אות קטנה?

1904
01:26:33,780 --> 01:26:35,730
כיצד ניתן להמיר את זה
מחרוזת לאותיות גדולה?

1905
01:26:35,730 --> 01:26:38,146
כל הדברים האלה יהיו מאוד,
מועיל מאוד לpset.

1906
01:26:38,146 --> 01:26:42,720

1907
01:26:42,720 --> 01:26:45,500
אוקיי.

1908
01:26:45,500 --> 01:26:49,644
>> שעתי עבודה הלילה הם 8:00 עד
11:00 בכיתה צהבהב מחר

1909
01:26:49,644 --> 01:26:51,310
כמו גם יום רביעי בלילה וביום חמישי.

1910
01:26:51,310 --> 01:26:53,280
שעות פעילות משרד הן בנחלת כלל.

1911
01:26:53,280 --> 01:26:56,180
מאוד ממליץ לך חבר '
כל להתחיל מייד,

1912
01:26:56,180 --> 01:27:00,490
כי אתה לא רוצה להיות ש
ילד יש יום חמישי בלילה שבעיות

1913
01:27:00,490 --> 01:27:03,870
הגשת pset ו
כמו, אני לא יודע מה לעשות.

1914
01:27:03,870 --> 01:27:05,870
התחלתי, סיימתי, הגשתי.

1915
01:27:05,870 --> 01:27:09,737
נסה לתת לעצמך כמה חדר,
כי בבעיות קוד תמיד להתרחש.

1916
01:27:09,737 --> 01:27:11,570
אתה רוצה לוודא
שאתה נותן את עצמך

1917
01:27:11,570 --> 01:27:14,810
הרבה זמן כדי להיות מסוגל
כדי להשלים את psets.

1918
01:27:14,810 --> 01:27:15,310
מגניב.

1919
01:27:15,310 --> 01:27:16,720
אני להסתובב כאן.

1920
01:27:16,720 --> 01:27:18,226
>> קהל: האם באינטרנט זה כבר?

1921
01:27:18,226 --> 01:27:20,850
ANDI פנג: אני לא יודע אם זה
באינטרנט כבר, אבל זה יהיה.

1922
01:27:20,850 --> 01:27:23,500
אני להסתובב כאן אם מישהו
יש כל שאלות כבר.

1923
01:27:23,500 --> 01:27:25,390
תודה שבאת.

1924
01:27:25,390 --> 01:27:27,105