1
00:00:00,000 --> 00:00:07,070
[Powered by Google Translate] [♪ ♪ זמזום]

2
00:00:07,070 --> 00:00:10,380
אז כדי להכיר לך את מה שיש לי על המסך;

3
00:00:10,380 --> 00:00:12,710
זה האחד הכלים שפתחנו במשך הקיץ;

4
00:00:12,710 --> 00:00:15,530
זה נקרא CS50 Spaces,

5
00:00:15,530 --> 00:00:18,860
וזה היישום שלנו שיתוף פעולת הקידוד

6
00:00:18,860 --> 00:00:20,180
שאנחנו הולכים להשתמש בחלקים.

7
00:00:20,180 --> 00:00:22,470
זה די מגניב.

8
00:00:22,470 --> 00:00:26,040
האם מישהו מכם ראה CS50 טווח עדיין?

9
00:00:26,040 --> 00:00:29,760
בואו ימשכו אותי שבכרטיסייה אחרת.

10
00:00:29,760 --> 00:00:33,440
Run.cs50.net

11
00:00:33,440 --> 00:00:36,230
כך

12
00:00:36,230 --> 00:00:39,700
אם אתה הולך לrun.cs50.net,

13
00:00:39,700 --> 00:00:43,030
אתה יכול לראות את זה בדרך שלך לדפדפן

14
00:00:43,030 --> 00:00:45,940
למעשה קוד - לכתוב קוד C,

15
00:00:45,940 --> 00:00:47,460
ולאחר מכן להפעיל אותו,

16
00:00:47,460 --> 00:00:50,960
כך שזה גם הידורו, מנהל אותו, לאחר מכן מחזיר את הפלט אליך,

17
00:00:50,960 --> 00:00:53,350
אז זה סוג של דרך מגניבה לניסוי

18
00:00:53,350 --> 00:00:56,060
עם חלק מהקוד שעובר על דוד בהרצאות

19
00:00:56,060 --> 00:00:58,640
ואנחנו נותנים לעל קבוצות בעייתיות

20
00:00:58,640 --> 00:01:01,900
מבלי למעשה לפטר את המכשיר.

21
00:01:01,900 --> 00:01:04,489
>> אז מה עושה Spaces זה שונה מזה

22
00:01:04,489 --> 00:01:07,450
אם לחזור לכרטיסייה זו,

23
00:01:07,450 --> 00:01:11,580
רווחים הם CS50 ריצה, כמו שאתה רואה כאן,

24
00:01:11,580 --> 00:01:15,380
אם אנחנו לגלול שוב ומסתכלים על הצד השני של החלון, אבל,

25
00:01:15,380 --> 00:01:18,130
אתם רואים נכונים שאני האדם היחיד במרחב הזה,

26
00:01:18,130 --> 00:01:21,030
אבל מה שאני הולך לעשות הוא לשאול אתכם להצטרף אל החלל הזה איתי

27
00:01:21,030 --> 00:01:24,590
וכולנו נגיע לקוד באותו החלון קטן,

28
00:01:24,590 --> 00:01:26,070
לשתף קוד אחד עם השני,

29
00:01:26,070 --> 00:01:28,900
ולדבר על ההבדלים בין הקוד שלנו.

30
00:01:28,900 --> 00:01:31,530
אז זה סוג של דבר מגניב -

31
00:01:31,530 --> 00:01:35,770
כך להצטרף, אם תבקר בקישור זה ממש כאן בראש

32
00:01:35,770 --> 00:01:38,980
כי אני כבר מסומן,

33
00:01:38,980 --> 00:01:53,860
אתה יכול פשוט להקליד apps.cs50.net/spaces/vqcspSnO.

34
00:01:53,860 --> 00:01:56,610
>> בסדר, אז כדי להתחיל,

35
00:01:56,610 --> 00:01:59,720
אני הולך לתת לך קצת מסיור זה.

36
00:01:59,720 --> 00:02:01,720
אנחנו הולכים לעשות כמה קידוד קטן ומטופש עם זה בהתחלה,

37
00:02:01,720 --> 00:02:06,200
רק כדי שכולם מקבל קצת תחושה של מה זה כאילו,

38
00:02:06,200 --> 00:02:09,000
אבל מה שעשיתי -

39
00:02:09,000 --> 00:02:11,830
או מה שאני עומד לעשות כאן הוא -

40
00:02:11,830 --> 00:02:13,480
אני הולך לקחת את הקוד שכתבתי כאן,

41
00:02:13,480 --> 00:02:15,800
וכפי שאתם רואים עכשיו הוא ריק;

42
00:02:15,800 --> 00:02:17,090
זה לא עושה כלום.

43
00:02:17,090 --> 00:02:21,080
זה רק קוד צלחת דוד, אנחנו קוראים לזה.

44
00:02:21,080 --> 00:02:23,820
עם קצת כדי לעשות את התגובה.

45
00:02:23,820 --> 00:02:27,850
אני הולך לשמור אותו על ידי להכות על הכפתור השמור הזה.

46
00:02:27,850 --> 00:02:30,190
ומה שעושה זה

47
00:02:30,190 --> 00:02:34,400
הדגיש אותו כאן בקצרה - שקופסה ירוקה הגרסה לשמור,

48
00:02:34,400 --> 00:02:37,570
ועכשיו, אם אתה מחפש אותי בשטח,

49
00:02:37,570 --> 00:02:40,340
אתה לוחץ על השם שלי,

50
00:02:40,340 --> 00:02:43,370
אתה יכול לראות שיש לי גרסה זו ממש כאן,

51
00:02:43,370 --> 00:02:45,490
אם תלחץ על עדכון ו,

52
00:02:45,490 --> 00:02:48,240
זה יהיה לטעון קוד שלתוך החלל שלך, מדי.

53
00:02:50,510 --> 00:02:54,160
>> אז יש כל טעון שקוד לתוך השטח שלהם?

54
00:02:54,160 --> 00:02:57,810
בסדר, אם יש לך עדיין לא, אתם מוזמנים לעשות זאת,

55
00:02:57,810 --> 00:03:01,120
ואז מה שאני רוצה אתם לעשות בזה קצת כדי לעשות את הסעיף

56
00:03:01,120 --> 00:03:05,940
הוא כותב קצת באמצעות printf על עצמך,

57
00:03:05,940 --> 00:03:08,310
כך למשל, הייתי כותב

58
00:03:08,310 --> 00:03:12,270
printf ("קורא לי נייט");

59
00:03:15,140 --> 00:03:17,700
ואז הייתי כותב

60
00:03:17,700 --> 00:03:21,660
"סיימתי את הלימודים בשנת 2009

61
00:03:21,660 --> 00:03:24,440
מסטנפורד "

62
00:03:26,050 --> 00:03:28,390
ואני אשמח לשמוע על

63
00:03:28,390 --> 00:03:30,270
באיזו שנה אתה בבית הספר,

64
00:03:30,270 --> 00:03:33,910
בין אם אתה במכללה או בית הספר לעסקים

65
00:03:33,910 --> 00:03:36,130
או אחר בבית ספר הרווארד,

66
00:03:36,130 --> 00:03:39,200
מה אתה לומד אם זה ידוע עדיין;

67
00:03:39,200 --> 00:03:41,290
אם זה לא ידוע, זה מגניב לגמרי.

68
00:03:41,290 --> 00:03:45,170
אני לא אחליט עד שהייתי מאוחר בשנה השנייה שלי.

69
00:03:46,910 --> 00:03:49,210
ואז גם אני אשמח לדעת

70
00:03:49,210 --> 00:03:51,610
שום דבר מטורף שאתה רוצה לספר לי או

71
00:03:51,610 --> 00:03:54,790
משהו על הכיתה או סתם כל דבר אחר.

72
00:03:56,930 --> 00:04:00,370
לאחר שתסיים לכתוב את זה עם מעט printf שלך,

73
00:04:00,370 --> 00:04:03,480
אם תוכל לחסוך את התיקון או יותר נכון

74
00:04:03,480 --> 00:04:06,080
ודא תחילה שתוכל להפעיל אותו

75
00:04:06,080 --> 00:04:10,640
ושזה מדפיס את בדיוק מה שאתה רוצה זה להדפיס,

76
00:04:14,050 --> 00:04:16,399
ואז אם אתה הולך קדימה ולשמור גרסה כי

77
00:04:16,399 --> 00:04:21,600
באמצעות הלחצן הגרסות השמורים, בחור הראשון וקטן זה כאן,

78
00:04:24,080 --> 00:04:27,340
ואנחנו די נלך דרך ולעשות הקדמה קטנה ככה.

79
00:04:27,340 --> 00:04:30,150
אז אתה צריך רק צריך ללחוץ על כפתור Play,

80
00:04:30,150 --> 00:04:32,550
אשר עד כאן בצד השמאל למעלה,

81
00:04:32,550 --> 00:04:35,340
כך כפתור Play זה בצד השמאל למעלה יהיה

82
00:04:35,340 --> 00:04:39,050
לשלוח את הקוד שלך לשרת שלנו שבו היא מקבלת לוקטה ואז לרוץ.

83
00:04:40,600 --> 00:04:43,300
אז מה זה די משוגע על זה

84
00:04:43,300 --> 00:04:46,550
קוד זה ממש לא פועל במחשב שלך;

85
00:04:46,550 --> 00:04:49,290
זה בעצם שנשלח אל מעבר לאינטרנט.

86
00:04:49,290 --> 00:04:51,240
>> איך זה הולך, שרלוט?

87
00:04:51,240 --> 00:04:54,810
>> אני - בסדר. אני - אני חושב שאני

88
00:04:54,810 --> 00:04:57,330
לאחר קשיי שמירתו

89
00:04:57,330 --> 00:05:00,530
בשרת כזה שהיא יכולה - אני יכול להפעיל את התכנית.

90
00:05:02,090 --> 00:05:05,780
ואז כשאני מנסה להפעיל אותו, זה אומר שיש שגיאה.

91
00:05:05,780 --> 00:05:08,850
הוכרז כוירוס, שהוא לא שם יותר.

92
00:05:08,850 --> 00:05:11,860
אה, בואו נראים, אתה יכול להכות שוב על שמור?

93
00:05:11,860 --> 00:05:13,770
אני רואה את זה על המסך.

94
00:05:13,770 --> 00:05:15,120
עכבר >>, בסדר, אז זה מה שיש לי.

95
00:05:15,120 --> 00:05:19,430
ואני לא יודע למה זה לא נותן לי לנהל אותה.

96
00:05:22,990 --> 00:05:24,990
אה, אוקיי, מצטער.

97
00:05:27,930 --> 00:05:31,220
האם אתה יכול להסביר למה - מה לא היה בסדר - מה שלא עובד איתו?

98
00:05:31,220 --> 00:05:34,760
>> כן, כי אני לא רואה שיש שורה אחרונה בו יש עדיין משתנה

99
00:05:34,760 --> 00:05:37,700
שלא הכריז, שאני לא מתכוון לזה להיות שם.

100
00:05:37,700 --> 00:05:38,730
כן, מושלם!

101
00:05:38,730 --> 00:05:40,390
>> עכשיו אם אני שומר אותו, אני חושב שזה צריך לעבוד.

102
00:05:40,390 --> 00:05:42,970
עכשיו, לאחר שהצלת אותו, זה עובד; מדהים.

103
00:05:42,970 --> 00:05:44,570
>> אז כן, כמו שאנחנו הולכים בדרך -

104
00:05:44,570 --> 00:05:46,690
אז מה קורה,

105
00:05:46,690 --> 00:05:49,130
אני רק הולך לחזור על זה למצלמה.

106
00:05:49,130 --> 00:05:51,760
מה שקרה היה שזה משתנה זה

107
00:05:51,760 --> 00:05:54,310
נשאר באחרי - אני מניח שמחקת כמה דברים אחרים

108
00:05:54,310 --> 00:05:56,670
איפה אתה תוכרז כ,

109
00:05:56,670 --> 00:05:59,560
וכך זה היה זורק את הדברים ולא נותן לך להפעיל אותו.

110
00:05:59,560 --> 00:06:02,540
אז זה בדיוק מה שאנחנו רוצים לעשות בסעיף

111
00:06:02,540 --> 00:06:05,690
הוא שאנשים ינסו לכתוב חלקים שונים של קוד,

112
00:06:05,690 --> 00:06:08,490
הידורו, לראות מה עובד, מה לא לראות,

113
00:06:08,490 --> 00:06:10,730
ואז די לדבר על הדברים האלה, כי אלה הם נקודות שמעד

114
00:06:10,730 --> 00:06:12,850
אני עדיין נתקל,

115
00:06:12,850 --> 00:06:15,470
אני עדיין - אני עושה המון דברים טיפשיים כל הזמן,

116
00:06:15,470 --> 00:06:17,820
ואני לא יודע למה זה לא עובד,

117
00:06:17,820 --> 00:06:22,960
אז בואו להרים את הגרסה של שרלוט 3,

118
00:06:23,980 --> 00:06:25,380
ושנריץ את זה.

119
00:06:25,380 --> 00:06:28,950
>> אז כשאני רצתי, עכשיו שיש לי הקוד שלה לכאן

120
00:06:28,950 --> 00:06:31,450
אני יכול להתמקד ב, לחץ על כפתור ההפעלה,

121
00:06:31,450 --> 00:06:33,680
העלאות אותו, בונה אותו, מנהלות אותו,

122
00:06:33,680 --> 00:06:36,980
אומר שזה רץ בהצלחה, ואם אני לגלול למטה,

123
00:06:36,980 --> 00:06:39,440
לראות שרלוט היא זוטרה באדמס הבית,

124
00:06:39,440 --> 00:06:42,720
פסיכולוגיה, משנית בכלכלה; מדהימה.

125
00:06:42,720 --> 00:06:44,310
נהדר לפגוש אותך!

126
00:06:44,310 --> 00:06:46,550
מדהים.

127
00:06:46,550 --> 00:06:49,670
אוקיי, ימשיך, בואו נלך לדניאל,

128
00:06:49,670 --> 00:06:52,710
ללכת לגרסה 3,

129
00:06:52,710 --> 00:06:54,180
לקמפל, לרוץ;

130
00:06:54,180 --> 00:06:56,680
למה שלא תספרו לנו קצת על עצמך, דניאל?

131
00:06:56,680 --> 00:06:59,380
>> מתקשר אליי דן.

132
00:06:59,380 --> 00:07:01,920
אני הולך לבית הספר לעסקים על פני מכם,

133
00:07:01,920 --> 00:07:05,020
ואני היה במארינס לפני כאן,

134
00:07:05,020 --> 00:07:08,020
וכל זה חדש לי, אז כן.

135
00:07:08,020 --> 00:07:11,060
אל תרגיש רע, אני בת 30 ואני לא יודע כל הדברים האלה.

136
00:07:11,060 --> 00:07:13,800
מדהים; תודה, דן!

137
00:07:13,800 --> 00:07:17,300
בסדר, יש לנו עוד דניאל.

138
00:07:17,300 --> 00:07:20,930
אתה הולך לפי דניאל - יהיה לך להציג את עצמך, דניאל?

139
00:07:20,930 --> 00:07:22,260
>> >> בטח, אני דניאל.

140
00:07:22,260 --> 00:07:24,330
אני בכיתת י 'במאת'ר עכשיו.

141
00:07:24,330 --> 00:07:25,840
כשאני מתרכז בממשלה,

142
00:07:25,840 --> 00:07:28,760
אבל אני רוצה לקחת את CS50 כי שמעתי ביקורות מצוינות על המעמד

143
00:07:28,760 --> 00:07:30,750
ואף פעם לא ניסיתי לפני CS.

144
00:07:30,750 --> 00:07:34,680
גלול למטה ולהראות את זה - מגניב.

145
00:07:36,330 --> 00:07:39,090
ההעברה ב, ג'ארד.

146
00:07:39,090 --> 00:07:41,990
איך זה הולך?

147
00:07:41,990 --> 00:07:43,430
>> טוב, מה שלומך?

148
00:07:43,430 --> 00:07:47,520
כפי שאתה יכול לראות, אני concentrator פילוסופיה זוטרה באליוט,

149
00:07:47,520 --> 00:07:50,260
במקור מדרום קליפורניה,

150
00:07:50,260 --> 00:07:53,100
ואני מעוניין לקחת CS50 כי אני אוהב את ההיגיון שלה,

151
00:07:53,100 --> 00:07:57,420
ונראה ממש מגניב לעשות דברים במחשב, ולכן.

152
00:07:57,420 --> 00:07:59,570
מדהים; שם בדרום קליפורניה אתה?

153
00:07:59,570 --> 00:08:02,340
>> כשעה מ[ לא ברור], עיר קטנה [לא ברור].

154
00:08:02,340 --> 00:08:04,850
אה, כן, האבא שלי נולד Redlands.

155
00:08:04,850 --> 00:08:07,060
דברים מגניבים.

156
00:08:07,060 --> 00:08:12,130
>> בסדר, ג'ימי, איך זה הולך, ג'ימי?

157
00:08:12,130 --> 00:08:15,130
>> טוב, מה שלומך?

158
00:08:15,130 --> 00:08:16,040
עושה די טוב!

159
00:08:16,040 --> 00:08:17,710
ספר לנו על עצמך.

160
00:08:17,710 --> 00:08:20,840
>> אני בכיתת ט ', ואני לא לגמרי בטוח מה אני לומד בחוג

161
00:08:20,840 --> 00:08:22,820
אבל אני די אני נוטה לכיוון כלכלה.

162
00:08:22,820 --> 00:08:25,680
כמו דניאל לפניי, אף פעם לא עשיתי כל CS, אבל זה נשמע די מגניב.

163
00:08:25,680 --> 00:08:28,120
אני במקור משיקגו.

164
00:08:28,120 --> 00:08:31,640
מדהים. אז לבדוק את התדפיס שלו כאן.

165
00:08:31,640 --> 00:08:34,630
רציתי לשאול, האם בהדפסה יצאה כפי שציפית?

166
00:08:34,630 --> 00:08:37,650
>> לא, שכחתי להדפיס שורה חדשה.

167
00:08:37,650 --> 00:08:41,270
אני באמת שכחתי שגם כשכתבתי את הקטע שלי

168
00:08:41,270 --> 00:08:43,090
בפעם הראשונה, יותר מדי.

169
00:08:43,090 --> 00:08:46,330
זה סוג של כאב לזכור לשים אותם באופן ידני.

170
00:08:46,330 --> 00:08:50,560
זה יהיה נחמד אם הוא רק יודע שזה מה שרצית.

171
00:08:50,560 --> 00:08:53,630
>> אוקיי, קלי.

172
00:08:53,630 --> 00:08:56,050
וואו, יש לנו 2 Kellys; 2 דניאלס, 2 Kellys.

173
00:08:56,050 --> 00:09:00,490
אז קלי - אתה הולך על ידי רן קלי?

174
00:09:00,490 --> 00:09:03,870
אוקיי, מדהים.

175
00:09:03,870 --> 00:09:07,270
או קלי, אני מתכוון.

176
00:09:07,270 --> 00:09:10,260
>> אז כן, כך אני קלי.

177
00:09:10,260 --> 00:09:12,930
אני בכיתת י 'בPfoho.

178
00:09:12,930 --> 00:09:17,000
יש לי דואר אלקטרוני היום כי עדיין יש לי 7 שבועות להכריז על הריכוז שלי,

179
00:09:17,000 --> 00:09:20,940
אז אני מנסה לא לחשוב על זה,

180
00:09:20,940 --> 00:09:24,090
ואני אוהב אפייה, ריצה, וCraisins.

181
00:09:24,090 --> 00:09:29,110
אין לי ניסיון עם רוב של CS;

182
00:09:29,110 --> 00:09:32,700
למדתי את עצמי לבנות אתרי אינטרנט כשהייתי ממש צעיר,

183
00:09:32,700 --> 00:09:35,750
אבל אני חושב שכנראה למדתי את עצמי טועה הרבה פעמים.

184
00:09:35,750 --> 00:09:39,260
אני מקווה שאני אלמד קצת יותר

185
00:09:39,260 --> 00:09:41,450
ו-- כן.

186
00:09:41,450 --> 00:09:44,100
>> מדהים, טובה, תודה לך.

187
00:09:44,100 --> 00:09:47,190
בואו נלך לקלי האחר;

188
00:09:47,190 --> 00:09:48,880
אין לי שום דבר - לא אתה אומר משהו בפה?

189
00:09:48,880 --> 00:09:51,880
>> [לא ברור]

190
00:09:51,880 --> 00:09:56,180
הנה זה!

191
00:09:56,180 --> 00:09:58,120
מתוק!

192
00:09:58,120 --> 00:10:01,400
>> בסדר, אז אני קלי.

193
00:10:01,400 --> 00:10:03,980
אני סטודנטית לתואר הראשונה שנה.

194
00:10:03,980 --> 00:10:05,560
אני לומד בחוג שכל, מוח, וחינוך.

195
00:10:05,560 --> 00:10:07,940
אני סיימתי את הלימודים במכללת פרנקלין ומרשל בשנת 2008

196
00:10:07,940 --> 00:10:10,840
עם מגמות בפסיכולוגיה וסוציולוגיה

197
00:10:10,840 --> 00:10:13,120
וקטין בצרפתית.

198
00:10:13,120 --> 00:10:15,330
אני לוקח CS50

199
00:10:15,330 --> 00:10:18,080
כי אני מעוניין לקבל דוקטורט במדעי המוח

200
00:10:18,080 --> 00:10:21,220
ואני מרגישה שזה יעזור לי להבין את הטכנולוגיות בשימוש.

201
00:10:21,220 --> 00:10:23,150
מדהים.

202
00:10:26,980 --> 00:10:29,390
ההעברה ב, מיקאלה.

203
00:10:29,390 --> 00:10:31,640
האם זה הגייה נכונה?

204
00:10:31,640 --> 00:10:32,990
אוקיי, מדהים.

205
00:10:32,990 --> 00:10:34,640
>> >> אני Mikhaila.

206
00:10:34,640 --> 00:10:36,870
אני בכיתת י 'בבית קירקלנד,

207
00:10:36,870 --> 00:10:39,950
וכשאני מתרכז בהנדסת מכונות.

208
00:10:39,950 --> 00:10:43,180
אני באמת אוהב את הרכיבה על אופניים, שנבניתי על אופניים בקיץ הזה.

209
00:10:43,180 --> 00:10:46,140
אני לוקח את CS, בעצם,

210
00:10:46,140 --> 00:10:48,350
כדרישת ריכוז,

211
00:10:48,350 --> 00:10:52,550
אבל אתה יודע, אני חושב שזה עדיין סוג מגניב של כיתת הנדסה.

212
00:10:52,550 --> 00:10:55,150
מדהים - שנבנית על אופניים בקיץ הזה?

213
00:10:55,150 --> 00:10:56,730
>> כן.

214
00:10:56,730 --> 00:10:58,900
וואו, כמו מסגרת וכל זה?

215
00:10:58,900 --> 00:11:00,120
>> אהה (חיובי).

216
00:11:00,120 --> 00:11:01,530
וואו, זה ממש מגניב.

217
00:11:01,530 --> 00:11:06,370
>> [שיחה בלתי נשמעת מחוץ למצלמה]

218
00:11:06,370 --> 00:11:10,000
[שחוק]

219
00:11:12,640 --> 00:11:14,200
כן, זה היה כל כך ארוך.

220
00:11:14,200 --> 00:11:16,730
אתה אף פעם לא יודע, נכון?

221
00:11:16,730 --> 00:11:19,420
ובכן, מגניב; תודה כן, Mikhaila.

222
00:11:19,420 --> 00:11:21,390
>> בסדר, המסים.

223
00:11:21,390 --> 00:11:23,280
מסי >> שמי; אני בכיתת ט ',

224
00:11:23,280 --> 00:11:25,500
אז זה אומר שאני לא יודע כלום!

225
00:11:25,500 --> 00:11:29,180
אני רוצה להתרכז באסטרופיזיקה.

226
00:11:29,180 --> 00:11:31,220
בCS50,

227
00:11:31,220 --> 00:11:33,350
אני מרגיש כמו בהחלט לעזור עם זה.

228
00:11:33,350 --> 00:11:37,750
עובדה מוזרה לי היא שאני כבאי ארצי מוסמך.

229
00:11:37,750 --> 00:11:39,960
וואו!

230
00:11:39,960 --> 00:11:42,440
איך זה קרה?

231
00:11:42,440 --> 00:11:45,570
>> אני השתתפתי אקדמיה

232
00:11:45,570 --> 00:11:49,000
ועברתי גיהינום במשך הרבה שבועות

233
00:11:49,000 --> 00:11:51,200
וקבלתי האישור שלי.

234
00:11:51,200 --> 00:11:54,090
וואו, מזל טוב!

235
00:11:54,090 --> 00:11:57,280
זה הישג לא קטן, זה בטוח.

236
00:11:57,280 --> 00:11:59,070
אוקיי, אז עכשיו אנחנו נעשה אותי.

237
00:11:59,070 --> 00:12:01,290
אני הבא בתור בשורה.

238
00:12:01,290 --> 00:12:04,510
אני - להפעיל אותו.

239
00:12:04,510 --> 00:12:07,580
>> אז השם שלי הוא נייט.

240
00:12:07,580 --> 00:12:11,160
אני היה בכיתה של 2009 בסטנפורד.

241
00:12:11,160 --> 00:12:13,840
אני היה במערכות סמלים גדולות,

242
00:12:13,840 --> 00:12:17,370
בדומה למוח, המוח, ריכוז ההתנהגות כאן,

243
00:12:17,370 --> 00:12:19,300
אבל זה סוג של שילוב של

244
00:12:19,300 --> 00:12:22,350
מדעי מחשב, בלשנות, פסיכולוגיה ופילוסופיה.

245
00:12:22,350 --> 00:12:26,600
סוג של - כן, הרבה דברים מוזרים, אבל זה היה נהדר,

246
00:12:26,600 --> 00:12:29,880
ואז אני גם עשיתי את המאסטר שלי במדעי מחשב שם,.

247
00:12:29,880 --> 00:12:33,250
אז אני חדש הרווארד השנה.

248
00:12:33,250 --> 00:12:35,750
אני באמת רוצה להגיע להוראה.

249
00:12:35,750 --> 00:12:39,860
אני ביליתי את 4 השנים האחרונות בשיעורי מדעי מחשב ת"א ing סטנפורד

250
00:12:39,860 --> 00:12:43,370
וכן הדוד ירשה לי לבוא,

251
00:12:43,370 --> 00:12:45,550
ואני אעזור בCS50,

252
00:12:45,550 --> 00:12:47,890
אז אני עושה את זה כל זמן, אני לא בלימודים.

253
00:12:47,890 --> 00:12:50,330
זה היה כיף.

254
00:12:50,330 --> 00:12:53,130
אני מקווה שזה ימשיך להיות כיף, אני בטוח שכן.

255
00:12:53,130 --> 00:12:56,040
>> בסדר, סם.

256
00:13:01,910 --> 00:13:05,470
>> השם שלי הוא סם; אני תלמיד שנה השנייה במכללה, בחוק באופן ספציפי.

257
00:13:05,470 --> 00:13:10,110
העיקרי שלי יהיה ההיסטוריה של מדע, מן הסתם, וVes משני,

258
00:13:10,110 --> 00:13:13,240
והצבע האהוב עליי הוא צהוב.

259
00:13:18,790 --> 00:13:21,100
אין צורך לשפוט או משהו, אבל זה צבע טוב!

260
00:13:21,100 --> 00:13:24,780
וסטלה.

261
00:13:24,780 --> 00:13:26,980
>> היי, אני סטלה; אני בכיתת ט 'באפור.

262
00:13:26,980 --> 00:13:30,070
אין לי מושג מה אני כבר מרוכז בעדיין,

263
00:13:30,070 --> 00:13:32,500
כך CS50 היה רק ​​סוג של אקראי,

264
00:13:32,500 --> 00:13:34,220
וזה מעניין.

265
00:13:34,220 --> 00:13:36,080
למעשה כיף, ג'ימי היה חבר הרווארד הראשונה שלי,

266
00:13:36,080 --> 00:13:38,360
כי אנחנו משני שיקגו.

267
00:13:38,360 --> 00:13:42,450
מגניבה, וגרייס - שאמור להיות אחד לא באמת נחמד, נכון?

268
00:13:42,450 --> 00:13:45,220
>> חשבתי [לא ברור].

269
00:13:45,220 --> 00:13:46,690
אה, כן.

270
00:13:46,690 --> 00:13:51,210
[צ'אט מצלמה מחוץ לבלתי נשמע /]

271
00:13:51,210 --> 00:13:54,420
אוקיי, אני עדיין לומד, עדיין לומד.

272
00:13:54,420 --> 00:13:57,800
>> אז יש לנו משהו אחר זה די מעניין כאן.

273
00:13:59,600 --> 00:14:02,870
כן, אני רק תוהה, האם יש לך רעיון שקורה כאן?

274
00:14:02,870 --> 00:14:05,890
אתה יודע איך לפרש את זה?

275
00:14:05,890 --> 00:14:13,340
>> אני היה אמור לשים פסיק אחרי כל שורה האחת.

276
00:14:13,340 --> 00:14:16,370
זה סוג של כאב.

277
00:14:16,370 --> 00:14:19,100
לפעמים הפסיק האלה יכול להיות כאב אמיתי לאתר.

278
00:14:19,100 --> 00:14:21,420
אז מתברר כי

279
00:14:21,420 --> 00:14:22,820
תכנית המיוחדת שאנחנו משתמשים בזה לשנה

280
00:14:22,820 --> 00:14:26,670
לקמפל קוד C שלנו נקרא קלאנג,

281
00:14:26,670 --> 00:14:29,460
והסיבה שהתחלנו להשתמש קלאנג השנה -

282
00:14:29,460 --> 00:14:32,030
כי אנחנו לא השתמשנו בתכנית שבעבר;

283
00:14:32,030 --> 00:14:35,710
אנחנו מנצלים אחד את השני בשם GCC זה באמת פופולרי -

284
00:14:35,710 --> 00:14:38,420
קלאנג בעצם נותן לך הודעות שגיאה שהגיונית.

285
00:14:38,420 --> 00:14:41,420
זה אומר "צפוי": "אחרי ביטוי",

286
00:14:41,420 --> 00:14:45,260
והוא אפילו אומר לך את הביטוי לאחר שהיה זקוק לי פסיק.

287
00:14:45,260 --> 00:14:47,830
אז אתה לתקן את זה?

288
00:14:47,830 --> 00:14:48,930
>> כן, ממש עכשיו.

289
00:14:48,930 --> 00:14:52,040
מדהים; תודיע לי ואנחנו למשוך אותו למעלה, ושנריץ את זה.

290
00:14:52,040 --> 00:14:55,830
אבל כן, לשים נקודה ופסיק באלה הוא סוג של כאב.

291
00:14:55,830 --> 00:14:59,580
>> אני סדרתי את זה, אז אני חושב שזה צריך לעבוד.

292
00:14:59,580 --> 00:15:02,760
מדהים - 3 מהדורות.

293
00:15:02,760 --> 00:15:05,250
זה נראה כמו זה.

294
00:15:05,250 --> 00:15:08,580
בסדר, אז עכשיו אם אנחנו מפעילים את זה,

295
00:15:08,580 --> 00:15:11,020
שם זה הולך.

296
00:15:11,020 --> 00:15:13,830
דברים מגניבים.

297
00:15:13,830 --> 00:15:15,340
>> בסדר.

298
00:15:15,340 --> 00:15:18,230
אז תודה על עושה את זה.

299
00:15:18,230 --> 00:15:20,210
זה נהדר לפגוש אתכם.

300
00:15:20,210 --> 00:15:22,880
מה אנחנו הולכים לעשות עכשיו זה להשקיע קצת הבא

301
00:15:22,880 --> 00:15:24,740
די לצלול לתוך בעיות הסעיף

302
00:15:24,740 --> 00:15:27,550
שבאו מהבעיה להגדיר מהשבוע

303
00:15:27,550 --> 00:15:29,920
ואנחנו נעשה את זה עבור רוב הסעיפים

304
00:15:29,920 --> 00:15:32,110
לשאר הטווח,

305
00:15:32,110 --> 00:15:35,580
ואז נחסוך 15 האחרונים, 20 דקות בערך

306
00:15:35,580 --> 00:15:38,490
לדבר על הבעיה להגדיר את עצמו

307
00:15:38,490 --> 00:15:41,420
ואז פשוט על כל שאלה אחרת שיש לך באופן כללי על הכיתה.

308
00:15:43,380 --> 00:15:45,670
עם זאת, מה לעשות שאנחנו באמת רוצים

309
00:15:45,670 --> 00:15:49,390
ראשון לדעת שהשתתפות

310
00:15:49,390 --> 00:15:51,500
שימוש בחומר Spaces,

311
00:15:51,500 --> 00:15:53,500
לזרוק בקוד, לזרוק בהצעות,

312
00:15:53,500 --> 00:15:56,500
וכשמדבר על דברים כמו ההפסקה הזו,

313
00:15:56,500 --> 00:15:58,360
או לא עובדים, רק בגלל שאלו דברים ש

314
00:15:58,360 --> 00:16:00,870
אני יודע שאני נתקלתי

315
00:16:00,870 --> 00:16:03,180
כשהתחלתי קידוד,

316
00:16:03,180 --> 00:16:05,490
ובאמת היו די מתסכלים בזמנים

317
00:16:05,490 --> 00:16:08,690
כי אם זה כמו 2:00 לפני סט הבעיה שלך נובע,

318
00:16:08,690 --> 00:16:11,330
כך - רק בשביל גילוי,

319
00:16:11,330 --> 00:16:14,590
אני לא התחלתי את תכנות עד שהיה בשנה שנייה במכללה.

320
00:16:14,590 --> 00:16:17,360
זה היה סוג של דבר זה מוזר, לא ידוע

321
00:16:17,360 --> 00:16:20,360
שמעתי שהיה די מגניב

322
00:16:20,360 --> 00:16:23,590
ושמעתי גם שזה יכול להיות ממש קוץ בתחת

323
00:16:23,590 --> 00:16:27,610
אם ברצונך להצטרף פסיק וזה הטעות היחידה שמחזיקה את התכנית שלך מעבודה

324
00:16:27,610 --> 00:16:30,890
ומונע ממך ללכת לישון,

325
00:16:30,890 --> 00:16:32,650
אז בהחלט,

326
00:16:32,650 --> 00:16:34,020
אם יש לך שאלות כאלה,

327
00:16:34,020 --> 00:16:37,060
אם יש לך חששות כאלה, תודיע לי,

328
00:16:37,060 --> 00:16:40,050
בגלל שאני רוצה לעשות זה ניסיון טוב בשבילכם.

329
00:16:40,050 --> 00:16:44,620
>> אז אתם חייבים להוריד את כל הבעיה להגדיר עדיין?

330
00:16:44,620 --> 00:16:47,160
די יודע איפה זה? אוקיי.

331
00:16:47,160 --> 00:16:51,490
אז תיסע לcs50.net, כי אין לי את זה על חשבון זה,

332
00:16:51,490 --> 00:16:54,110
למשוך את הקבוצות הבעייתיות,

333
00:16:54,110 --> 00:16:57,940
למשוך את קבוצת הבעיה 2, ואנחנו מסתכלים המהדורה הסטנדרטית כיום.

334
00:16:57,940 --> 00:17:01,190
אנחנו נמשוך את המפרט כאן.

335
00:17:02,640 --> 00:17:04,420
לגלול למטה.

336
00:17:06,790 --> 00:17:11,109
אז אנחנו הולכים להתחיל לחפש בקטע זה של שאלות.

337
00:17:14,069 --> 00:17:16,710
האם אתם צפיתם במכנסיים קצרים האלה עדיין?

338
00:17:16,710 --> 00:17:18,329
אוקיי.

339
00:17:18,329 --> 00:17:21,329
אז יש מכנסיים קצרים על לולאות,

340
00:17:21,329 --> 00:17:24,700
אשר נעשה על ידי טומי, אחד מהחברים להוראת הראש.

341
00:17:24,700 --> 00:17:27,230
יש אחת בהיקפו,

342
00:17:27,230 --> 00:17:30,530
אני מאמין שנעשיתי על ידי עמית הוראה אחרת בשם דוד

343
00:17:30,530 --> 00:17:33,400
ואז אחד על קיסר הצפנה גם נעשה על ידי דוד.

344
00:17:33,400 --> 00:17:35,550
הם די מגניבים.

345
00:17:35,550 --> 00:17:37,770
האם אתם כבר צופים את התחתונים שלהם עד כה?

346
00:17:37,770 --> 00:17:39,270
מה נשמעו הם הייתם?

347
00:17:39,270 --> 00:17:41,490
מועיל? אוקיי, טוב לדעת.

348
00:17:41,490 --> 00:17:44,210
אם הם לא, אתה יכול לומר זאת.

349
00:17:46,290 --> 00:17:49,870
אבל לפני שאתה עושה,

350
00:17:49,870 --> 00:17:52,600
הייתם, אנשים הסתכלו על השאלות הללו

351
00:17:52,600 --> 00:17:55,430
בכלל?

352
00:17:55,430 --> 00:17:57,480
>> בואו נדבר על זה קצת.

353
00:17:57,480 --> 00:18:00,600
אז אנחנו כבר הצגנו מעל בשבועות האחרונים

354
00:18:00,600 --> 00:18:02,480
בהרצאה

355
00:18:02,480 --> 00:18:04,910
מספר הלולאות שונות.

356
00:18:04,910 --> 00:18:06,140
יש ללולאה,

357
00:18:06,140 --> 00:18:09,570
לולאה בזמן, ואז עשה תוך הלולאה,

358
00:18:09,570 --> 00:18:13,100
ובהרצאה, אנחנו כבר מדברים הרבה על

359
00:18:13,100 --> 00:18:16,010
כמה הלולאות האלה הן כל

360
00:18:16,010 --> 00:18:18,320
די דומה בהרבה דרכים,

361
00:18:18,320 --> 00:18:21,210
ואתה יכול לעשות הרבה יותר מאותם דברים עם לולאה בזמן

362
00:18:21,210 --> 00:18:23,260
שאתה יכול עם לולאה ל.

363
00:18:23,260 --> 00:18:26,300
אתה פשוט צריך להשתמש בסוג של השילובים הנכונים של משתנים וכאלה.

364
00:18:26,300 --> 00:18:28,680
וכך באמת

365
00:18:28,680 --> 00:18:31,200
ההבדל האמיתי בין כל הלולאות הוא כי

366
00:18:31,200 --> 00:18:33,620
לפעמים הם יותר שימושיים

367
00:18:33,620 --> 00:18:36,930
כדי להשתמש בם בפעם אחת מאשר במועד אחר.

368
00:18:36,930 --> 00:18:39,340
>> כך למשל,

369
00:18:39,340 --> 00:18:42,260
הלולאה בזמן השונה מעשה תוך לולאה.

370
00:18:42,260 --> 00:18:45,680
האם כולם מרגישים שהם צריכים לטפל טובים בכאשר

371
00:18:45,680 --> 00:18:48,650
עשה תוך לולאה היא יותר

372
00:18:48,650 --> 00:18:50,990
שימושי או מה ההבדל?

373
00:18:50,990 --> 00:18:53,410
>> אני חושב שההבדל הוא עשה תוך לולאה

374
00:18:53,410 --> 00:18:56,960
פועל - אני לא יודע בדיוק מה היא הטרמינולוגיה,

375
00:18:56,960 --> 00:18:59,750
אבל הסדרה של פונקציות בתוך הלולאה.

376
00:18:59,750 --> 00:19:02,020
הם באופן אוטומטי - זה עושים ריצות שלה לפחות

377
00:19:02,020 --> 00:19:05,390
לפני שהוא בודק את מצבו, או הלולאה בזמן רק להפעיל אותו כש

378
00:19:05,390 --> 00:19:08,290
זה פועל ברציפות - אם המצב הוא להיות מרוצה.

379
00:19:08,290 --> 00:19:11,010
כן, האם זה הגיוני?

380
00:19:11,010 --> 00:19:14,200
>> בואו נסתכל קצת קוד.

381
00:19:14,200 --> 00:19:16,930
אז רק כדי לחזור על השאלה,

382
00:19:16,930 --> 00:19:19,230
או בתשובה, ולא;

383
00:19:19,230 --> 00:19:22,050
התשובה הייתה כי

384
00:19:22,050 --> 00:19:25,850
בעוד לולאה תבדוק אם המצב

385
00:19:25,850 --> 00:19:27,440
שציינתם הוא נפגש

386
00:19:27,440 --> 00:19:31,320
לפני שהיא מפעילה את הגוף של הלולאה בפעם הראשונה,

387
00:19:31,320 --> 00:19:35,000
אילו עשה תוך לולאה תפעל באופן אוטומטי בגוף של הלולאה,

388
00:19:35,000 --> 00:19:38,450
זה מה שאנחנו קוראים לו - זה מוזר מינוח,

389
00:19:38,450 --> 00:19:41,460
אבל אם אי פעם אמרתי שכל דבר שאינו הגיוני, יגיד לי -

390
00:19:41,460 --> 00:19:45,360
גוף הלולאה הוא שדברים שאתה מכניס בין הסוגריים המסולסלים.

391
00:19:45,360 --> 00:19:47,840
ועשה תוך לולאה,

392
00:19:47,840 --> 00:19:50,220
שהגוף להידרס לפחות פעם אחת,

393
00:19:50,220 --> 00:19:54,460
ואז מקבל את המצב נבדק לפני שהיא מפעילה כל פעם ברציפות.

394
00:19:54,460 --> 00:19:56,580
>> כך שלמעשה, סם,

395
00:19:56,580 --> 00:20:00,820
אכפת לך כתיבה פשוטה תוך לולאה

396
00:20:00,820 --> 00:20:02,840
במרחב?

397
00:20:02,840 --> 00:20:05,600
>> איך אתה די אוהב

398
00:20:05,600 --> 00:20:07,060
להפוך חדש ...?

399
00:20:07,060 --> 00:20:09,220
אני פשוט מוחק כל מה שיש לך בפנים.

400
00:20:09,220 --> 00:20:11,300
כן, רק לנקות אותו.

401
00:20:11,300 --> 00:20:14,510
>> ובכן, אני מאמין שיש לי זה -

402
00:20:14,510 --> 00:20:16,640
איזה מהם אתה רוצה, בזמן, או שאתה רוצה ...?

403
00:20:16,640 --> 00:20:19,350
כן, פשוט בזמן נכון, להדפיס משהו.

404
00:20:21,050 --> 00:20:23,140
ובואו נראים.

405
00:20:23,140 --> 00:20:25,850
אלכסנדר, הבין שמעולם לא הציג לך.

406
00:20:25,850 --> 00:20:27,510
>> אה, זה בסדר.

407
00:20:27,510 --> 00:20:30,760
האם אתה - אתה יכול לקודד את עשה תוך לולאה עבורנו?

408
00:20:30,760 --> 00:20:32,520
>> כן, אני אנסה.

409
00:20:32,520 --> 00:20:34,370
בסדר, אנחנו פשוט למשוך את אלה שעל המסך,

410
00:20:34,370 --> 00:20:38,240
כך שיש סוג של ידית מהם ההבדלים.

411
00:20:38,240 --> 00:20:41,280
>> אז הנה מה שסאם עשה.

412
00:20:41,280 --> 00:20:44,460
יש לו מספר שלם הנקרא i

413
00:20:44,460 --> 00:20:47,480
שהוא מאותחל ל 17.

414
00:20:47,480 --> 00:20:51,570
ואז הוא אומר בזמן (אני int = 17)

415
00:20:51,570 --> 00:20:54,230
printf ("קורא לי סם".);

416
00:20:54,230 --> 00:20:57,300
אז מה קורה כאשר אנו מפעילים את הקוד הזה?

417
00:20:57,300 --> 00:21:00,340
יש שגיאה, מה השגיאה אומרת?

418
00:21:00,340 --> 00:21:02,890
בואו נמשוך אותו ולדבר על זה.

419
00:21:02,890 --> 00:21:05,040
אירעה שגיאה, זה אומר.

420
00:21:05,040 --> 00:21:07,400
בואו לגלול למטה.

421
00:21:07,400 --> 00:21:09,460
אז זה נתן לנו את השגיאה, והיא אמרה,

422
00:21:09,460 --> 00:21:12,690
"היי, אני מצפה ביטוי".

423
00:21:12,690 --> 00:21:16,180
זה די מובן.

424
00:21:19,160 --> 00:21:23,140
כן, בדיוק כך - ושוב,

425
00:21:23,140 --> 00:21:27,140
יהיה עוד באג קטן שנתפוס בשנייה בלבד.

426
00:21:27,140 --> 00:21:31,800
אבל זה עוד אחד מאותם סוג של דברי טרמינולוגיה מוזרים,

427
00:21:31,800 --> 00:21:36,150
כך אני int = 17 זה

428
00:21:36,150 --> 00:21:39,290
אין ביטוי.

429
00:21:39,290 --> 00:21:41,220
מה זה נראה כמו שהוא עושה הוא שזה

430
00:21:41,220 --> 00:21:43,410
הכרזה שלמה בשמי

431
00:21:43,410 --> 00:21:45,540
והגדיר אותו שווה ל 17

432
00:21:45,540 --> 00:21:48,780
או, לייתר דיוק, לשים 17 שבint בשם i.

433
00:21:50,560 --> 00:21:53,350
וזה לא הגיוני

434
00:21:53,350 --> 00:21:55,790
בהקשר של הלולאה בזמן הזה.

435
00:21:55,790 --> 00:21:58,190
זה אכן הגיוני, כפי שנראה,

436
00:21:58,190 --> 00:22:01,250
בהקשר של ללולאה, כי להצהרות לולאה אין להתחיל

437
00:22:01,250 --> 00:22:05,800
עם זה לint i שווה משהו

438
00:22:05,800 --> 00:22:07,830
וממשיך.

439
00:22:07,830 --> 00:22:09,500
>> אז עשה לך -

440
00:22:09,500 --> 00:22:12,630
לתקן משהו, בסדר.

441
00:22:12,630 --> 00:22:15,270
הנה זה מתחיל; מדהים.

442
00:22:15,270 --> 00:22:17,920
אז עכשיו דברים נראים קצת אחרים.

443
00:22:17,920 --> 00:22:19,030
כמה דברים השתנו.

444
00:22:19,030 --> 00:22:21,300
האם אתה יכול לספר לנו מה הדברים השתנו?

445
00:22:21,300 --> 00:22:24,950
>> הוצאתי int, כך שאין הכרזה [לא ברור] במקום מטלה.

446
00:22:24,950 --> 00:22:28,770
סימן שוויון אחד, שמתי 2 שלטים שווים, כלומר שווים.

447
00:22:28,770 --> 00:22:30,560
מדהים.

448
00:22:30,560 --> 00:22:33,320
כן, אז מה שסאם עשה היה שהוא הוציא את int

449
00:22:33,320 --> 00:22:35,770
שהיה כאן קודם לכן,

450
00:22:35,770 --> 00:22:39,340
כך שאם אני רק מסתכל על זה - זה מה שהיה קודם לכן, הוא אמר int,

451
00:22:39,340 --> 00:22:41,970
שמצהיר על זה - אז לקחתי את הסוג.

452
00:22:41,970 --> 00:22:44,710
יש, מחרוזת int, char, קצרה,

453
00:22:44,710 --> 00:22:47,380
אלה נקראים סוגים.

454
00:22:47,380 --> 00:22:49,510
אז אתה הוצאת את הסוג

455
00:22:49,510 --> 00:22:51,580
ולאחר מכן בעבר,

456
00:22:51,580 --> 00:22:54,190
היה לו רק אחת סימן השוויון

457
00:22:54,190 --> 00:22:57,300
ומה שהוא אמר היה בעייתי בעניין הזה היה

458
00:22:57,300 --> 00:22:59,580
כאשר יש לך 1 סימן שווה,

459
00:22:59,580 --> 00:23:01,780
זה אופרטור השמה.

460
00:23:01,780 --> 00:23:04,930
שלא בוחן את השאלה אם 2 דברים שווים.

461
00:23:04,930 --> 00:23:07,920
כי בעצם זה הגדרת משהו שווה למשהו.

462
00:23:07,920 --> 00:23:11,110
אנחנו מכניסים את המספר 17 אליי משתנה.

463
00:23:11,110 --> 00:23:13,850
אז כדי לעשות את זה סוג של השוואה,

464
00:23:13,850 --> 00:23:16,430
אתה צריך להשתמש כפול שווה,

465
00:23:16,430 --> 00:23:19,640
וזה סוג של דבר מוזר

466
00:23:19,640 --> 00:23:22,760
אך היא טעות נפוצה למדי.

467
00:23:23,980 --> 00:23:27,830
אז דבר אחד אני מוכן להצביע, אם לא אכפת לך,

468
00:23:27,830 --> 00:23:30,610
הוא שב

469
00:23:30,610 --> 00:23:33,210
תפקידנו כאן בעיקרי int,

470
00:23:33,210 --> 00:23:36,740
אתה רואה שהגוף של הפונקציה שלנו

471
00:23:36,740 --> 00:23:39,810
מקוזז מהצד השמאלי

472
00:23:39,810 --> 00:23:42,400
על ידי 4 ברווחים או בכרטיסייה.

473
00:23:42,400 --> 00:23:44,730
הסיבה שאנחנו עושים את זה

474
00:23:44,730 --> 00:23:47,000
רק לשם נוחות קריאה.

475
00:23:47,000 --> 00:23:51,620
כפי שניתן לראות בלולאה בזמן של סם כאן,

476
00:23:51,620 --> 00:23:53,120
הוא לא לשנן כלל,

477
00:23:53,120 --> 00:23:55,390
וזה לא משפיע על הפונקציונליות של הקוד.

478
00:23:55,390 --> 00:23:57,860
הוא יפעל בדיוק אותו הדבר.

479
00:23:57,860 --> 00:24:00,950
>> כך למשל, אם אנו מגיעים לפסגה כאן

480
00:24:00,950 --> 00:24:02,680
ולחץ על כפתור Play שלנו, זה יהיה לבנות אותו,

481
00:24:02,680 --> 00:24:04,470
זה יהיה להפעיל אותו,

482
00:24:04,470 --> 00:24:06,700
ומה יקרה?

483
00:24:06,700 --> 00:24:08,360
למה זה עדיין אומר לרוץ?

484
00:24:08,360 --> 00:24:10,560
>> כי זה ימשיך לחזור על היי.

485
00:24:10,560 --> 00:24:12,900
בדיוק, ולמה זה ממשיך לחזור על היי?

486
00:24:12,900 --> 00:24:15,850
מכיוון שלעולם לא משתנה >> השלם, כך שזה תמיד 17.

487
00:24:15,850 --> 00:24:18,030
כן, בדיוק, ולכן

488
00:24:18,030 --> 00:24:20,970
בואו נראים, אחרי - מזכיר לי שוב את שמך?

489
00:24:20,970 --> 00:24:24,020
ג'ימי. אז ג'ימי אמר כי

490
00:24:24,020 --> 00:24:27,340
מהסיבה זו חוזרת על היי שוב ושוב

491
00:24:27,340 --> 00:24:30,510
בגלל המצב הזה הוא תמיד נכון.

492
00:24:30,510 --> 00:24:33,270
אנחנו אף פעם לא משנים את הערך של i.

493
00:24:33,270 --> 00:24:36,170
אנחנו אף פעם לא לשנות את התוכן של מה שמאוחסן באותו משתנה.

494
00:24:36,170 --> 00:24:39,180
לכן בשלב זה יש לנו את השגיאה ש

495
00:24:39,180 --> 00:24:42,170
התכנית שלך שנוצרה יותר מדי תפוקה,

496
00:24:42,170 --> 00:24:45,100
אם אנחנו לגלול למטה וסוג של מבט במה שקורה כאן ו,

497
00:24:45,100 --> 00:24:49,160
אתה יכול לראות שזה היי, היי, היי, היי, היי, היי, היי לכל אורך הדרך.

498
00:24:49,160 --> 00:24:51,200
מדהים.

499
00:24:51,200 --> 00:24:53,750
>> אז סוג של חזרה לנקודה המקורית

500
00:24:53,750 --> 00:24:57,020
כי לאחר הכניסה כאן

501
00:24:57,020 --> 00:25:00,110
בגוף הלולאה בזמן לא השפיע על כלום.

502
00:25:00,110 --> 00:25:03,050
התכנית עדיין רצה בסדר גמורה.

503
00:25:03,050 --> 00:25:06,790
באופן טיפוסי לסגנון טוב -

504
00:25:06,790 --> 00:25:10,210
וזה משהו שאנחנו מחפשים בסטי הבעיה שלך -

505
00:25:10,210 --> 00:25:13,930
אנו מבקשים ממך לשנן את זה על ידי 4 מקומות, שבו אתה יכול לעשות

506
00:25:13,930 --> 00:25:16,440
רק על ידי לחיצה על מקש TAB

507
00:25:16,440 --> 00:25:18,860
או על ידי הצבה ידנית ב 4 מקומות בעצמך.

508
00:25:21,880 --> 00:25:25,050
מגניב, אוקיי אז בואו נלך אחורה ולהסתכל על

509
00:25:25,050 --> 00:25:30,460
אלכסנדר יעשה-הזמן.

510
00:25:30,460 --> 00:25:32,980
>> רק די התקשה קצת.

511
00:25:32,980 --> 00:25:34,390
אוקיי, גם בואו לעבוד דרכו.

512
00:25:34,390 --> 00:25:36,400
האם זה מגניב?

513
00:25:36,400 --> 00:25:37,430
>> כן.

514
00:25:37,430 --> 00:25:39,200
>> אוקיי, אז הנה זה בא.

515
00:25:39,200 --> 00:25:41,010
זה קוד שכתב אלכסנדר.

516
00:25:41,010 --> 00:25:43,410
האם אתה הולך על ידי אלכס - בסדר.

517
00:25:43,410 --> 00:25:46,380
אז הנה הקוד שאלכס כתב.

518
00:25:46,380 --> 00:25:50,500
אז, יש לנו ההכרזה הראשית שלנו כאן,

519
00:25:50,500 --> 00:25:54,410
ולאחר מכן יש לנו משתנה השלם הזה שנקרא אני

520
00:25:54,410 --> 00:25:57,320
הכרזה ממש כאן.

521
00:25:57,320 --> 00:26:01,060
יש לנו משפט לעשות

522
00:26:01,060 --> 00:26:04,600
ואז שוב את הגופה עם פלטות אלה,

523
00:26:04,600 --> 00:26:06,520
אז זה הגוף של עשה תוך -

524
00:26:06,520 --> 00:26:09,210
תנו לי להתמקד בזה בכך שזה יהיה קריא יותר -

525
00:26:09,210 --> 00:26:12,730
ובגוף, שאנחנו מנסים להדפיס "זה הגוף",

526
00:26:12,730 --> 00:26:14,300
אני + +,

527
00:26:14,300 --> 00:26:17,710
כך להגדיל את התוכן שלי ולעשות את זה

528
00:26:17,710 --> 00:26:19,470
עד שאני הופך להיות 3,

529
00:26:19,470 --> 00:26:22,440
ואז התכנית שלנו מסתיימת.

530
00:26:22,440 --> 00:26:24,680
>> אז מה קורה כאשר אנו מפעילים תכנית זו?

531
00:26:24,680 --> 00:26:27,580
>> ציפיתי מזהה.

532
00:26:27,580 --> 00:26:32,070
אוקיי, אז לבנות, להפעיל, מתרחשת שגיאה.

533
00:26:32,070 --> 00:26:34,820
מה קורה?

534
00:26:34,820 --> 00:26:37,060
אנו לגלול למטה כאן,

535
00:26:37,060 --> 00:26:40,260
אנחנו מקבלים דבר, נראה קצת המסתורי הזה,

536
00:26:40,260 --> 00:26:43,930
צפוי פסיק לאחר הכרזה ברמה עליונה.

537
00:26:43,930 --> 00:26:46,620
זה קצת מוזר.

538
00:26:46,620 --> 00:26:50,990
האם יש למישהו מושג על מה שאולי קרה?

539
00:26:53,080 --> 00:26:54,640
דיי מוזר, כן.

540
00:26:54,640 --> 00:26:57,640
>> [לא ברור] יוכרז מחוץ לסוגריים?

541
00:26:57,640 --> 00:27:03,480
אז האם זה לא יחול אז כאשר אתה משתמש בסוגריים?

542
00:27:03,480 --> 00:27:07,390
אז הוא הצהיר שהבחור הזה שמחוץ לסוגריים?

543
00:27:09,670 --> 00:27:12,240
אה, החבר 'ה האלה - הסוגריים המסולסלים?

544
00:27:12,240 --> 00:27:13,850
>> כן.

545
00:27:13,850 --> 00:27:15,310
כן, בדיוק.

546
00:27:15,310 --> 00:27:17,120
אז מתברר כי

547
00:27:17,120 --> 00:27:21,550
אתה לא ממש יכול להצהיר על משתנה כאן ככה.

548
00:27:23,750 --> 00:27:26,690
מה שאולי היה מנסה לעשות היה -

549
00:27:26,690 --> 00:27:30,110
לחתוך אותו משם -

550
00:27:30,110 --> 00:27:34,330
אתה יכול גם לשים אותו בתוך הסוגריים המסולסלים ממש כאן

551
00:27:34,330 --> 00:27:37,400
או אלטרנטיבה אחרת

552
00:27:37,400 --> 00:27:40,350
הוא לשים אותו מחוץ לחלוטין.

553
00:27:42,480 --> 00:27:46,610
ולכן אלה - תלוי איפה אתה שם את ההצהרה למעשה

554
00:27:46,610 --> 00:27:48,550
שממשתנים שלמים,

555
00:27:48,550 --> 00:27:53,540
אתה יכול לקבל 2 סוגים מאוד שונים של משתנים;

556
00:27:53,540 --> 00:27:55,100
כאשר זה מחוץ לראשי,

557
00:27:55,100 --> 00:27:58,240
זה מה שאנו מכנים משתנים גלובליים.

558
00:27:58,240 --> 00:28:00,070
זה מחוץ לתחום של כל אחת מהפונקציות -

559
00:28:00,070 --> 00:28:03,420
זה לא בתוך פונקציה -

560
00:28:03,420 --> 00:28:07,050
ואילו אם אנחנו שמים אותו בתוך ראשיים,

561
00:28:07,050 --> 00:28:10,000
רוצים ממש כאן, אז זה נקרא משתנה מקומי,

562
00:28:10,000 --> 00:28:13,830
בגלל שזה מקומי להיקף ראשי.

563
00:28:13,830 --> 00:28:16,720
ונדברנו קצת יותר על מה ההבדלים

564
00:28:16,720 --> 00:28:20,970
בין 2 סוגים ולמה אתה משתמש בסוגים שונים של משתנים,

565
00:28:20,970 --> 00:28:23,040
אך לעת עתה,

566
00:28:23,040 --> 00:28:25,070
אתה פשוט יכול לשמור את כל המשתנים מקומיים,

567
00:28:25,070 --> 00:28:28,320
משום שאין לנו כל צורך במשתנים גלובליים.

568
00:28:28,320 --> 00:28:31,390
>> אוקיי, אז זה דבר אחד ממש שם.

569
00:28:31,390 --> 00:28:34,680
בואו ננסה לרוץ בזה שוב, לראות מה קורה.

570
00:28:37,420 --> 00:28:40,270
הפעלה, מקבל את הודעת שגיאה אחרת.

571
00:28:40,270 --> 00:28:43,320
קרב קצת, מה אנחנו מקבלים?

572
00:28:45,110 --> 00:28:50,000
אנחנו מקבלים את זה אחרי הסוגריים צפויים לעשות / זמן.

573
00:28:53,660 --> 00:28:55,260
יש לך רעיונות מה קורה? דן?

574
00:28:55,260 --> 00:28:58,880
>> האם בזמן אז סוגריים ולאחר מכן -

575
00:28:58,880 --> 00:29:01,990
אני לא יודע אם אתה צריך redeclare int,

576
00:29:01,990 --> 00:29:04,980
אבל לעשות בזמן (i <3).

577
00:29:04,980 --> 00:29:06,930
בדיוק, כן.

578
00:29:06,930 --> 00:29:08,830
אז מתברר שדן זה בדיוק נכון.

579
00:29:08,830 --> 00:29:11,230
אנחנו לא צריכים לשים סוג זה כאן שוב.

580
00:29:11,230 --> 00:29:14,440
במקום זאת, יכול להרוג את הסוג

581
00:29:14,440 --> 00:29:17,220
ופשוט לעשות את זה.

582
00:29:19,270 --> 00:29:21,640
בסדר.

583
00:29:21,640 --> 00:29:24,950
אני להתקרב בחזרה החוצה, לנסות את זה עוד פעם אחת.

584
00:29:26,360 --> 00:29:29,580
תראה ש; הוא פועל בהצלחה.

585
00:29:29,580 --> 00:29:33,260
אם אנחנו לגלול למטה, "זה הגוף" הדפיס 3 פעמים.

586
00:29:33,260 --> 00:29:35,820
זה די מתוק.

587
00:29:35,820 --> 00:29:38,670
כל הכבוד, כל כבוד, חבר 'ה.

588
00:29:38,670 --> 00:29:41,080
כל הכבוד.

589
00:29:41,080 --> 00:29:43,250
איך זה הולך כל כך רחוק?

590
00:29:43,250 --> 00:29:46,200
קצב הגון?

591
00:29:46,200 --> 00:29:49,200
אוקיי, מגניב.

592
00:29:49,200 --> 00:29:52,590
>> אז, כפי שאנו סוג של חזרה לשאלה המקורית,

593
00:29:52,590 --> 00:29:55,430
- ועכשיו אם אנחנו רואים את ההבדל,

594
00:29:55,430 --> 00:29:58,240
אתה רואה את זה בעשה תוך הלולאה הזו,

595
00:29:58,240 --> 00:30:00,030
המצב מגיע אחרון.

596
00:30:00,030 --> 00:30:02,530
אז כפי שהמחשב קורא את התכנית

597
00:30:02,530 --> 00:30:06,050
מאז תוכניות C מבוצעות סוג של בסדר עוקבים זה,

598
00:30:06,050 --> 00:30:09,450
איפה הם, פשוטו כמשמעו, להתחיל עם השורה הראשונה של ראשי,

599
00:30:09,450 --> 00:30:13,450
ואז להפעיל קו 6, קו 7, 8 קו, קו 9,

600
00:30:13,450 --> 00:30:16,150
שורה 10, השורה 11,

601
00:30:16,150 --> 00:30:18,440
את כל הדברים האלה בראש ממש כאן

602
00:30:18,440 --> 00:30:20,020
הולך יתבצע פעם אחת

603
00:30:20,020 --> 00:30:23,350
לפני שבכלל לבדוק את המצב הזה כדי לראות

604
00:30:23,350 --> 00:30:26,240
אם לא אני - או את התוכן שלי, ולא -

605
00:30:26,240 --> 00:30:29,750
הם פחות מהמספר 3.

606
00:30:29,750 --> 00:30:33,300
ורק אם ברגע שאנחנו מגיעים לקו 12,

607
00:30:33,300 --> 00:30:36,260
את התוכן שלי הם פחות מ 3

608
00:30:36,260 --> 00:30:39,150
נעשינו בפועל לקפוץ חזרה לקו 7

609
00:30:39,150 --> 00:30:41,140
ואז לחזור על התהליך,

610
00:30:41,140 --> 00:30:44,620
ואז לבדוק את המצב שוב ושוב ושוב.

611
00:30:44,620 --> 00:30:47,440
>> אז אנחנו יכולים לעמת את זה

612
00:30:47,440 --> 00:30:50,240
עם - התקרבות בחזרה החוצה,

613
00:30:50,240 --> 00:30:56,500
לגלול למטה לגרסתו של סם,

614
00:30:56,500 --> 00:31:00,760
אנחנו הולכים להסתכל על זה, השתנה מעט, כך שזה כבר לא לולאה אינסופית -

615
00:31:00,760 --> 00:31:03,570
היכן אם להתמקד,

616
00:31:03,570 --> 00:31:06,300
אנו רואים כי מאחר שתכנית זו מתבצעת,

617
00:31:06,300 --> 00:31:09,120
זה הולך להכריז אני int הראשון,

618
00:31:09,120 --> 00:31:12,030
להגדיר את התוכן שלי להיות על 0,

619
00:31:12,030 --> 00:31:15,820
ואז זה מכה את המצב תוך הלולאה הראשונה,

620
00:31:15,820 --> 00:31:19,210
לכן במקרה זה, הגוף הזה, זה וprintf ("היי") אני + +

621
00:31:19,210 --> 00:31:21,630
אפילו לא יבצע

622
00:31:21,630 --> 00:31:24,310
אלא אם כן אני הוא למעשה פחות או שווה ל 2.

623
00:31:24,310 --> 00:31:26,750
אז אם אני הוא 3, למשל,

624
00:31:26,750 --> 00:31:28,840
אם להגדיר זאת כאן

625
00:31:28,840 --> 00:31:32,160
שווה ל 4 - או שאני אעשה 3, כי אמרתי 3 -

626
00:31:32,160 --> 00:31:34,890
ולאחר מכן להפעיל אותו,

627
00:31:34,890 --> 00:31:38,320
זה יהיה לבנות, הוא יכול לרוץ בסדר גמור,

628
00:31:38,320 --> 00:31:40,530
אבל זה לא ממש להדפיס כל דבר,

629
00:31:40,530 --> 00:31:43,030
כי זה שנכשל במבחן למקרה הראשון.

630
00:31:44,780 --> 00:31:47,530
אז בכיתה, אנחנו די דברנו על למה-תוך הלולאות האלה

631
00:31:47,530 --> 00:31:49,800
שימושיים לפעמים

632
00:31:49,800 --> 00:31:53,140
ומדוע אנחנו נשתמש בה בניגוד ללולאה בזמן.

633
00:31:53,140 --> 00:31:56,450
>> האם יש - אין יש לכם הצעות כלשהן

634
00:31:56,450 --> 00:31:59,090
למה עשה תוך לולאה עשויה להיות שימושית יותר?

635
00:31:59,090 --> 00:32:02,560
>> ובכן, אני חושב לעשות, ואילו לולאות הן אם אתה רוצה קלט משתמש,

636
00:32:02,560 --> 00:32:05,020
כי ככה אתה יכול לתת להם

637
00:32:05,020 --> 00:32:07,780
לשים משהו בפעם אחת: אם זה נכון,

638
00:32:07,780 --> 00:32:09,300
אנחנו יכולים לעבור לשאר התכנית,

639
00:32:09,300 --> 00:32:11,250
אבל אם זה לא נכון, אז אתה ממשיך לשאול את המשתמש

640
00:32:11,250 --> 00:32:13,250
עד שאתה שם את הקלט הנכון.

641
00:32:13,250 --> 00:32:14,260
כן, בדיוק - בדיוק,

642
00:32:14,260 --> 00:32:16,840
כך עשה תוך הלולאה שימושית

643
00:32:16,840 --> 00:32:18,930
כי כאשר הנחיה לקלט מהמשתמש

644
00:32:18,930 --> 00:32:23,000
כי אתה צריך לקבל הקלט של המשתמש לפני שאתה באמת יכול לבדוק את זה.

645
00:32:23,000 --> 00:32:27,330
אז ב1 pset, בpset 2,

646
00:32:27,330 --> 00:32:29,650
לאן אתה להציג עבור קלט משתמש הרבה,

647
00:32:29,650 --> 00:32:31,200
זה דבר נוח לשימוש

648
00:32:31,200 --> 00:32:33,740
בניגוד לרק בעוד לולאה פשוטה.

649
00:32:33,740 --> 00:32:36,780
אם אתה משתמש בלולאה בזמן, אתה יכול לעשות את אותו דבר -

650
00:32:36,780 --> 00:32:38,750
אתה יכול לעשות את אותו דבר עם לולאה בזמן

651
00:32:38,750 --> 00:32:40,580
כפי שאתה עושה עם עשה תוך לולאה.

652
00:32:40,580 --> 00:32:43,380
אתה פשוט צריך להיות סוג של תהליך כפול זה

653
00:32:43,380 --> 00:32:47,010
בו אתה מקבל את הקלט ראשון ולאחר מכן להתחיל הלולאה בזמן שלך.

654
00:32:47,010 --> 00:32:49,800
אילו עשה תוך לולאה, אתה רק צריך לכתוב את זה פעם אחת

655
00:32:49,800 --> 00:32:52,430
וזה הרבה יותר נקי.

656
00:32:52,430 --> 00:32:54,650
>> בסדר.

657
00:32:55,970 --> 00:32:57,330
יש שאלות?

658
00:32:59,350 --> 00:33:01,380
הגיוני?

659
00:33:01,380 --> 00:33:06,200
>> התשואה 0 - זה פשוט סוג של דוכן או שזה -?

660
00:33:06,200 --> 00:33:08,960
כן, כדי שנוכל -

661
00:33:08,960 --> 00:33:11,960
ובכן, אנחנו נתחיל לכסות את זה קצת יותר מאוחר

662
00:33:11,960 --> 00:33:13,290
אבל מתברר כי

663
00:33:13,290 --> 00:33:15,720
0 תמורה זה שאנחנו מכניסים

664
00:33:15,720 --> 00:33:19,090
בסוף העיקרי כל הזמן -

665
00:33:19,090 --> 00:33:21,980
אתה די יכול פשוט לקחת את זה כדבר שאנחנו עושים

666
00:33:21,980 --> 00:33:24,930
לעת עתה.

667
00:33:24,930 --> 00:33:28,860
מה שהתחלנו לדבר על עם פונקציות

668
00:33:28,860 --> 00:33:31,600
סוג של בסוף השבוע שעבר ולאחר מכן שוב השבוע

669
00:33:31,600 --> 00:33:33,550
הוא שפונקציה

670
00:33:33,550 --> 00:33:37,680
לוקח תשומות שהם הדברים האלה בתוך הסוגריים;

671
00:33:37,680 --> 00:33:41,690
אלה הם 2 כניסות, הוויכוחים או פרמטרים שלנו,

672
00:33:41,690 --> 00:33:44,540
מה הם גם קראו לפונקציה העיקרית שלנו,

673
00:33:44,540 --> 00:33:48,510
ואז פונקציה מייצרת תפוקה

674
00:33:48,510 --> 00:33:51,290
שאנו קוראים לי ערך החזרה.

675
00:33:51,290 --> 00:33:56,260
ואת ערך ההחזרה במקרה של עיקרי הוא זה int,

676
00:33:56,260 --> 00:33:58,320
השלם הזה,

677
00:33:58,320 --> 00:34:01,160
וכמו שאתה אומר לי פונקציה, "היי, זה מה שהתפוקה שלך

678
00:34:01,160 --> 00:34:05,840
הוא הולך להיות, "הוא במילה" שיבה ",

679
00:34:05,840 --> 00:34:07,960
שמילת מפתח, ולא,

680
00:34:07,960 --> 00:34:11,000
וכך חוזרים ראשי 0

681
00:34:11,000 --> 00:34:13,389
או פלט עיקרי 0

682
00:34:13,389 --> 00:34:15,139
מקובל בתוכניות C

683
00:34:15,139 --> 00:34:18,110
בגלל חזרת 0 מ האמצעי עיקרי ש

684
00:34:18,110 --> 00:34:21,600
"היי, הכל מבוצע עם התכנית שלי בסדר הגמורה."

685
00:34:21,600 --> 00:34:24,639
אם היו עלינו לשים משהו אחר מאשר 0,

686
00:34:24,639 --> 00:34:27,440
כמו 1, לדוגמה,

687
00:34:27,440 --> 00:34:31,080
המשמש לתגיד מי שדרס תכנית זו

688
00:34:31,080 --> 00:34:33,540
משהו שהשתבש.

689
00:34:35,739 --> 00:34:39,989
אז כפי שאנו מקבלים יותר מעורבים עם חומר על הסמסטר,

690
00:34:39,989 --> 00:34:42,670
אם אתה אי פעם תיאלץ לומר,

691
00:34:42,670 --> 00:34:46,650
"אופס, אתה יודע, משהו השתבש בתכנית זו,"

692
00:34:46,650 --> 00:34:49,409
ולא שיש התרסקות התכנית שלי, אני רוצה להודיע

693
00:34:49,409 --> 00:34:52,310
הרץ של התכנית שלי שמשהו השתבש,

694
00:34:52,310 --> 00:34:54,530
אתה יכול להשתמש בשווי תמורה,

695
00:34:54,530 --> 00:34:57,230
כפי שאנו קוראים לזה, זה לא 0.

696
00:35:00,180 --> 00:35:02,240
>> כך יהיה לנו כיסוי שקצת יותר

697
00:35:02,240 --> 00:35:05,480
ברגע שאנחנו נכנסים לפונקציות.

698
00:35:05,480 --> 00:35:09,030
זה סוג של היגיון?

699
00:35:09,030 --> 00:35:11,240
אוקיי.

700
00:35:11,240 --> 00:35:13,530
פונקציות הן סוג של מוזר -

701
00:35:13,530 --> 00:35:17,270
אני חושב שלאנשים שיש להם הרבה רקע במתמטיקה,

702
00:35:17,270 --> 00:35:20,100
זה מגיע קצת יותר בקלות,

703
00:35:20,100 --> 00:35:22,540
במיוחד אם יש לך רקע מתמטי מופשט יותר קצת

704
00:35:22,540 --> 00:35:24,240
ואתה רגיל לדבר על פונקציות

705
00:35:24,240 --> 00:35:27,370
וכל הסוג כזה של דברים.

706
00:35:28,590 --> 00:35:30,610
אבל אנחנו ננסה ולכסות אותם

707
00:35:30,610 --> 00:35:33,280
וללכת לאט וברור כפי שהם באים.

708
00:35:34,730 --> 00:35:37,870
כמו כן, argc int כל זה,

709
00:35:37,870 --> 00:35:41,090
char * argv [],

710
00:35:41,090 --> 00:35:44,960
לעכשיו, אתה יכול גם לקחת את זה כצלחת דוד.

711
00:35:46,650 --> 00:35:49,050
אנחנו כבר התחלנו לכסות את אלה קצת בהרצאה

712
00:35:49,050 --> 00:35:53,060
כאשר אנו מדברים על טיעונים שמקבלים שמועברים לתוכניות בשורת הפקודה,

713
00:35:53,060 --> 00:35:55,700
אבל בסטי הבעיה שלך והתוכניות שלך,

714
00:35:55,700 --> 00:35:58,760
זה לגמרי בסדר, רק כדי לכתוב מבוטל ולשמור את זה פשוט.

715
00:35:58,760 --> 00:36:01,490
ומה החלל הזה פירוש הדבר הוא כי

716
00:36:01,490 --> 00:36:04,630
"היי, עיקרי הוא לא הולך לקבל כל תשומות;

717
00:36:04,630 --> 00:36:07,440
זו רק תכנית שאנחנו הולכים רק לרוץ.

718
00:36:07,440 --> 00:36:09,320
אנחנו לא הולכים לתת לו כל מידע נוסף

719
00:36:09,320 --> 00:36:12,420
בכל פעם שאנחנו מתחילים אותו בריצה ".

720
00:36:14,730 --> 00:36:16,600
אז לעת עתה, אתה יכול לעשות את זה;

721
00:36:16,600 --> 00:36:19,710
אתה גם יכול גם להשמיט את ה 0 התמורה

722
00:36:19,710 --> 00:36:22,650
בסוף התוכניות שלך והם ירוצו בסדר גמורים,

723
00:36:22,650 --> 00:36:26,150
אבל אני ממליץ פשוט לשמור שבי

724
00:36:26,150 --> 00:36:28,320
בכמה שבועות, תתחילו לסוג של

725
00:36:28,320 --> 00:36:31,340
למשוך בחזרה את המכסה קצת ולהבין יותר על

726
00:36:31,340 --> 00:36:34,380
כל אותם החלקים נעים קצת שונים.

727
00:36:34,380 --> 00:36:38,160
>> בסדר, עכשיו בואו נדבר על השאלה השנייה שלנו כאן.

728
00:36:38,160 --> 00:36:43,190
אז מה זה "מזהה לא מוצהר" בדרך כלל מצביע

729
00:36:43,190 --> 00:36:46,040
אם outputted ידי קלאנג?

730
00:36:46,040 --> 00:36:49,290
אני חושב שאנחנו יכולים לראות שכבר היום.

731
00:36:51,170 --> 00:36:54,370
מישהו יכול לתת סיכום של מה זה אומר?

732
00:36:54,370 --> 00:36:57,680
בואו נראים, קלי - אחד ממשפחת קלי.

733
00:37:02,580 --> 00:37:05,300
אז >> -

734
00:37:05,300 --> 00:37:07,080
כן, מה עושה -

735
00:37:07,080 --> 00:37:10,140
>> אני חושב שכשאתה, כמו, לא מצהיר את המשתנים ואתה מנסה להשתמש בו.

736
00:37:10,140 --> 00:37:13,310
כן, בדיוק, בדיוק.

737
00:37:13,310 --> 00:37:15,250
אז אם אי פעם תראה את הפלט הזה

738
00:37:15,250 --> 00:37:17,690
כאשר אתה מנסה לקמפל את התכנית שלך,

739
00:37:17,690 --> 00:37:19,470
בדיוק כמו קלי אמר,

740
00:37:19,470 --> 00:37:24,210
זה אומר שאתה בשימוש במשתנה שלא הצהיר,

741
00:37:24,210 --> 00:37:28,460
כך שאם אני חוזר לשטח שלנו,

742
00:37:28,460 --> 00:37:31,150
ואני עושה משהו כמו

743
00:37:31,150 --> 00:37:34,800
printf (

744
00:37:34,800 --> 00:37:38,260
"שלום% s")

745
00:37:40,070 --> 00:37:42,440
ולנסות ולמלא שב% s

746
00:37:42,440 --> 00:37:45,640
עם משתנה של זה שלא הצהיר בכל מקום

747
00:37:45,640 --> 00:37:48,330
ואני מנסה להפעיל אותו,

748
00:37:48,330 --> 00:37:51,330
תראה למה אני יורד בתחתית זה ממש כאן:

749
00:37:51,330 --> 00:37:54,010
"שימוש של" מזהה לא מוצהר ";

750
00:37:54,010 --> 00:37:57,710
זה רק אומר שאתה לא הכרזת המשתנה שלך.

751
00:37:57,710 --> 00:38:00,750
אותו דבר קורה אם

752
00:38:00,750 --> 00:38:05,240
יש לך X ואתה מנסה ולאחסן אותו ב7

753
00:38:05,240 --> 00:38:08,720
ואני לא הכרזתי X.

754
00:38:08,720 --> 00:38:10,200
אני מקבל שאותה שגיאה:

755
00:38:10,200 --> 00:38:13,480
"שימוש" x "מזהה לא מוצהר".

756
00:38:16,390 --> 00:38:18,250
>> בסדר,

757
00:38:18,250 --> 00:38:21,720
כך קיסר ההצפנה, לא להיות מאוד מאובטח,

758
00:38:21,720 --> 00:38:24,590
אני אתן לכם לצפות, זה סוג של קצר הבין למה,

759
00:38:24,590 --> 00:38:27,590
ובתקווה לאחר עושה בעית שבוע זה נקבע

760
00:38:27,590 --> 00:38:29,270
שבו אתה בעצם לכתוב הצפנת קיסר, תוכל להבין קצת יותר

761
00:38:29,270 --> 00:38:32,600
על מה זה אומר להיות מאובטח ובטוח -

762
00:38:36,180 --> 00:38:38,960
או לא מאובטח, אני מניח - חוסר הביטחון הוא מעט שונה.

763
00:38:40,560 --> 00:38:43,140
הדבר השני היה שיש לנו השאלות אחרות האלה כאן

764
00:38:43,140 --> 00:38:45,470
על פונקציות

765
00:38:45,470 --> 00:38:47,330
ומה תפקידו הוא,

766
00:38:47,330 --> 00:38:52,820
ואנחנו סוג של דברנו על כך זמן קצר בעת שדברנו על ערכים לחזור;

767
00:38:52,820 --> 00:38:54,560
למישהו שהייתי בהרצאה,

768
00:38:54,560 --> 00:38:57,790
אתה יכול לסכם שהיה להרצות היום?

769
00:38:57,790 --> 00:38:59,670
בסדר.

770
00:39:01,210 --> 00:39:04,320
בואו נראים, בואו יש - מישהו יכול להגיד לנו מה היא פונקציה?

771
00:39:04,320 --> 00:39:06,060
קלי?

772
00:39:07,800 --> 00:39:11,260
>> >> בעיקרון משהו שאתה מצייר עליו משהו שכתוב בספרייה זה

773
00:39:11,260 --> 00:39:14,460
מסובך יותר לשם, ואז אתה פשוט כותב טופס קצר שלה,

774
00:39:14,460 --> 00:39:17,360
אז כמו שאת מתייחסת אל הספרייה, באמצעות

775
00:39:17,360 --> 00:39:19,650
כל מה שהקוד ארוך ו[ לא ברור].

776
00:39:19,650 --> 00:39:22,680
כן, בדיוק, ואז אתה רוצה להוסיף משהו לזה?

777
00:39:22,680 --> 00:39:27,050
>> כן, אני חושב על זה כדומה לרעיון של נוסחה במתמטיקה

778
00:39:27,050 --> 00:39:30,130
שבו אתה פשוט כותב נוסחה ואז אתה יכול לחבר במשתנים

779
00:39:30,130 --> 00:39:32,660
וזה מה שפונקציה היא [לא ברורה].

780
00:39:32,660 --> 00:39:35,390
>> כן, אז יש לנו כמה תשובות כאן

781
00:39:35,390 --> 00:39:38,080
כי שניהם ממש טובים וממש על.

782
00:39:38,080 --> 00:39:43,040
יש המתייחסים לקוד שכבר נכתב בספרייה במקום

783
00:39:43,040 --> 00:39:45,390
זה יותר מסובך

784
00:39:45,390 --> 00:39:47,130
ואז אתה יכול לשאוב כי קוד

785
00:39:47,130 --> 00:39:50,480
ובעצם להשתמש בו רק על ידי כתיבת צורה הקצרה שלו -

786
00:39:50,480 --> 00:39:54,060
או, לייתר דיוק, את שמו -

787
00:39:54,060 --> 00:39:57,590
ואז יש גם השוואה זה לנוסחה במתמטיקה

788
00:39:57,590 --> 00:40:00,400
או פיסיקה, כל דברים כאלה

789
00:40:00,400 --> 00:40:02,980
שם יש לך נוסחה

790
00:40:02,980 --> 00:40:05,690
ואז אתה יכול לחבר

791
00:40:05,690 --> 00:40:08,100
המשתנים שלנוסחא

792
00:40:08,100 --> 00:40:11,130
אז כדי לקבל את התוצאה של הנוסחא,

793
00:40:11,130 --> 00:40:14,580
אז אתה חושב על זה כמו כמו המשוואה ריבועית.

794
00:40:14,580 --> 00:40:17,690
תאר לעצמכם אם לא שיש ללמוד על

795
00:40:17,690 --> 00:40:21,310
מה הנוסחא ריבועית היא בשיעור מתמטיקה,

796
00:40:21,310 --> 00:40:24,610
אתה פשוט הייתה תכנית מחשבון קטנה שעשתה את זה בשבילך.

797
00:40:24,610 --> 00:40:28,930
האם מישהו משתמש בתוכניות של מחשבון בלימודי מתמטיקה בבית הספר תיכון?

798
00:40:28,930 --> 00:40:31,020
כן, שיעורי פיסיקה?

799
00:40:31,020 --> 00:40:34,670
איפה אתה יכול פשוט לומר, "היי, נוסחה ריבועית.

800
00:40:34,670 --> 00:40:37,740
אלה הם את המשתנים שאני רוצה קלט.

801
00:40:37,740 --> 00:40:40,250
עכשיו תן לי את התשובה. "

802
00:40:40,250 --> 00:40:42,170
זה סוג של מה היא פונקציה.

803
00:40:42,170 --> 00:40:44,850
זוהי דרך עבורנו

804
00:40:44,850 --> 00:40:47,720
סוג של כתיבה כגון תת תוכנה קטנה קטנה

805
00:40:47,720 --> 00:40:51,700
במסגרת התכנית הגדולה שלנו

806
00:40:51,700 --> 00:40:55,090
ולהשתמש בו שוב ושוב

807
00:40:55,090 --> 00:40:58,380
כך שאין לנו להעתיק ולהדביק קוד,

808
00:40:58,380 --> 00:41:04,220
אנחנו יכולים לתת לו כניסות שונות ולקבל תפוקות שונות,

809
00:41:04,220 --> 00:41:07,090
זה סופר שימושי

810
00:41:07,090 --> 00:41:11,420
כשאתה מנסה לכתוב תוכניות שונות בזמנים שונות.

811
00:41:11,420 --> 00:41:14,580
>> כך למשל, פונקציה שאנחנו כבר משתמשים שוב ושוב ושוב

812
00:41:14,580 --> 00:41:17,310
במהלך הקורס הוא printf.

813
00:41:17,310 --> 00:41:19,680
Printf היא עצם פונקציה

814
00:41:19,680 --> 00:41:23,360
ומתברר שזה בעצם די ארוך ומסובך,

815
00:41:23,360 --> 00:41:26,420
נבזה, לתפקד לכתוב.

816
00:41:26,420 --> 00:41:29,590
אז פשוט כמו שזה נראה לנו

817
00:41:29,590 --> 00:41:31,810
להדפיס סחורה למסך,

818
00:41:31,810 --> 00:41:34,820
משום שכולנו פשוט עשינו את זה בתחילה היום סעיף,

819
00:41:34,820 --> 00:41:36,870
מתברר שזה בעצם, אתה יודע,

820
00:41:36,870 --> 00:41:39,900
זוג טוב של 100 שורות קוד.

821
00:41:42,030 --> 00:41:45,620
זה לא משהו שאני אי פעם ארצה לכתוב, זה בטוח,

822
00:41:45,620 --> 00:41:47,480
אבל אנחנו מקבלים להשתמש בו בכל יום; זה די מגניב,

823
00:41:47,480 --> 00:41:49,020
ולכן אנחנו מקבלים לחלוק אותו עם זה,

824
00:41:49,020 --> 00:41:51,790
עם תוכניות שונות,

825
00:41:51,790 --> 00:41:54,520
לכן אנחנו יוצאים לצלול יותר לפונקציות;

826
00:41:54,520 --> 00:41:56,090
לעת עתה, אנחנו לא -

827
00:41:56,090 --> 00:41:59,150
הפונקציה היחידה שאנחנו הולכים להיות כתיבה היא עיקרית.

828
00:41:59,150 --> 00:42:01,570
ראשי עצמו הוא גם פונקציה,

829
00:42:01,570 --> 00:42:04,270
ואתה יכול לראות שיש לו הפלט,

830
00:42:04,270 --> 00:42:06,610
התשומות שלה כמו שדברנו עליו,

831
00:42:06,610 --> 00:42:08,930
ולאחר מכן את שמה, שהיא מרכזית.

832
00:42:08,930 --> 00:42:11,800
העיקרי הוא סוג של - היא פונקציה מיוחדת לשם.

833
00:42:11,800 --> 00:42:14,800
בתכנית C שלך, שם צריך להיות פונקציה עיקרית,

834
00:42:14,800 --> 00:42:17,900
ואז לעת עתה, יש לנו סוג של כתיבה הושמטה

835
00:42:17,900 --> 00:42:21,400
אב הטיפוס, או הכרזה, העיקרי.

836
00:42:21,400 --> 00:42:23,050
אנחנו נתנו לך את זה,

837
00:42:23,050 --> 00:42:25,650
ויש לנו רק שאתה ממלא בסוג של את החסר.

838
00:42:25,650 --> 00:42:29,120
>> >> אז לקבוצת הבעיה השנייה, אנחנו לא צריכים

839
00:42:29,120 --> 00:42:31,350
לכתוב את זה בפונקציה השנייה?

840
00:42:31,350 --> 00:42:34,200
אני לא מאמין בכך.

841
00:42:34,200 --> 00:42:37,600
אני מאמין שהכול כאן.

842
00:42:37,600 --> 00:42:41,710
כן, אז קיסר הצפנה,

843
00:42:41,710 --> 00:42:45,000
אתה לא צריך, זה לא נראה כמו,

844
00:42:48,740 --> 00:42:53,150
וVigenere, שגם אתה לא,

845
00:42:53,150 --> 00:42:56,400
כך - ומתברר שאף פעם לא ממש צריך לכתוב

846
00:42:56,400 --> 00:42:58,250
פונקציה, נכון?

847
00:42:58,250 --> 00:43:01,950
אתה קורא תמיד לשים את כל הקוד שלך בתוך ראשי,

848
00:43:01,950 --> 00:43:04,500
ומתכנתים רבים לעשות זאת.

849
00:43:04,500 --> 00:43:07,130
ככל שאנו מתקדמים ב,

850
00:43:07,130 --> 00:43:09,480
אנחנו מתחילים פונקציות מציגות כדרך

851
00:43:09,480 --> 00:43:11,530
כדי לנקות את הקוד שלך,

852
00:43:11,530 --> 00:43:13,380
כדי לעשות את זה יותר אלגנטי,

853
00:43:13,380 --> 00:43:16,890
במקרה יש לך משימות - כמו סוג של כשדברנו על לולאות,

854
00:43:16,890 --> 00:43:20,400
איך לפעמים יש דברים שאתה רוצה לעשות שוב ושוב ושוב,

855
00:43:20,400 --> 00:43:23,510
ויש לך סוג של הדרך התמימה -

856
00:43:23,510 --> 00:43:26,360
או מה שאנו מכנים לעתים קרובות פתרון "קש האדם",

857
00:43:26,360 --> 00:43:29,390
פשוט להעתיק ולהדביק שוב ושוב -

858
00:43:29,390 --> 00:43:31,000
אתה יכול לעשות את אותו דבר עם פונקציות שבו אתה פשוט להעתיק ולהדביק

859
00:43:31,000 --> 00:43:33,360
את אותו קוד שוב ושוב,

860
00:43:33,360 --> 00:43:35,750
אבל זה bloats הקוד שלך -

861
00:43:35,750 --> 00:43:38,550
זה בסופו הופך את הקוד שלך באמת ארוך -

862
00:43:38,550 --> 00:43:41,550
והוא גם מקבל קצת מבלבל,

863
00:43:41,550 --> 00:43:43,470
ואז זה אומר שאתה לא מסוגל לאהוב -

864
00:43:43,470 --> 00:43:45,250
אם אי פעם תרצו להשתמש בקוד הזה שוב בתכנית אחרת,

865
00:43:45,250 --> 00:43:48,610
גם אתה תקוע העתקה והדבקה שלו שוב,

866
00:43:48,610 --> 00:43:51,170
כך אחד הדברים שנדברנו עליו

867
00:43:51,170 --> 00:43:54,960
סוג של עיצוב וסגנון של התוכניות שלך,

868
00:43:54,960 --> 00:43:57,010
ולכן כאשר זה הגיוני סוג של

869
00:43:57,010 --> 00:43:59,800
חבילת משהו ולשים אותו כפונקציה נפרדת,

870
00:43:59,800 --> 00:44:02,080
אנו ממליצים לך לעשות את זה,

871
00:44:02,080 --> 00:44:04,700
וזה משהו ששוב,

872
00:44:04,700 --> 00:44:07,790
אין שלטון חזק ומהר.

873
00:44:07,790 --> 00:44:11,540
לעתים נדירות אנו אומרים שאתה חייב לכתוב פונקציה שנקראת כך,

874
00:44:12,870 --> 00:44:16,320
אבל זה יותר מאחד מהדברים האלה שאתה פשוט מתפתח עם זמן

875
00:44:16,320 --> 00:44:19,470
כפי שאתה כותב יותר ויותר תוכניות.

876
00:44:21,940 --> 00:44:24,790
>> עוד שאלות?

877
00:44:26,340 --> 00:44:30,610
אוקיי, אז בואו עכשיו

878
00:44:30,610 --> 00:44:34,750
עליי חזרה לבחור הזה ממש כאן,

879
00:44:34,750 --> 00:44:37,800
לכן אני עדיין בחלק זה של שאלות.

880
00:44:37,800 --> 00:44:39,900
דברנו על כל אלה שונים אלה,

881
00:44:39,900 --> 00:44:42,050
מה פונקציה, למה לכתוב פונקציות,

882
00:44:42,050 --> 00:44:44,700
כאשר אתה יכול פשוט להעתיק ולהדביק?

883
00:44:44,700 --> 00:44:47,700
אני מקווה ששכנענו אותך שכתיבת פונקציות היא דבר טוב.

884
00:44:47,700 --> 00:44:50,870
אז עכשיו בואו נעבור לתכנית מייספייס זה,

885
00:44:50,870 --> 00:44:53,080
ונבלנו קצת זמן לעשות את זה.

886
00:44:54,600 --> 00:44:56,480
>> אז, בואו תראו,

887
00:44:56,480 --> 00:45:00,230
יש לי מישהו יכול לקרוא את זה בשבילי?

888
00:45:02,640 --> 00:45:04,660
בואו Mikhaila - תהיה לך לקרוא את זה בשבילנו?

889
00:45:07,660 --> 00:45:08,890
>> אתה מתכוון לחזור כשמייספייס -

890
00:45:08,890 --> 00:45:10,920
בחזרה כאשר מייספייס היה מגניב.

891
00:45:10,920 --> 00:45:12,070
>> "חזור כאשר מייספייס היה מגניב,

892
00:45:12,070 --> 00:45:14,900
זה היה כל הזעם לסוג כזה.

893
00:45:14,900 --> 00:45:17,320
אולי זה עדיין? אני לא ממש בטוח.

894
00:45:17,320 --> 00:45:19,990
בכל מקרה, שימוש CS50 Appliance,

895
00:45:19,990 --> 00:45:22,600
CS50 הפעלה, או CS50 Spaces,

896
00:45:22,600 --> 00:45:25,370
לכתוב תכנית שמנחה את המשתמש להודעה

897
00:45:25,370 --> 00:45:29,350
ואז פלט את ההודעה עם מהוון המכתב הראשון שלה,

898
00:45:29,350 --> 00:45:31,800
עם כל מכתבים האחרים במקרה לסירוגין,

899
00:45:31,800 --> 00:45:34,010
לפי פלט הדוגמא להלן,

900
00:45:34,010 --> 00:45:37,060
טקסט boldfaced בי מייצג קלט מסוים של משתמש.

901
00:45:37,060 --> 00:45:39,800
לשם פשטות, ניתן להניח שהמשתמש

902
00:45:39,800 --> 00:45:42,810
רק אותיות וחללים קטנות קלט.

903
00:45:42,810 --> 00:45:45,900
שקול בעיה זו הזדמנות להתאמן;

904
00:45:45,900 --> 00:45:48,640
אתה לא תתבקש להגיש תכנית זו. "

905
00:45:48,640 --> 00:45:51,640
>> מדהים, תודה לך.

906
00:45:51,640 --> 00:45:54,750
אז כפי שאמר Mikhaila,

907
00:45:54,750 --> 00:45:58,850
אנחנו הולכים לכתוב תכנית שMySpaces הקוד שלך.

908
00:45:58,850 --> 00:46:02,230
אז האם מישהו מכם ישתמש ב-MySpace?

909
00:46:02,230 --> 00:46:04,100
מישהו מכם יש חשבונות MySpace?

910
00:46:04,100 --> 00:46:05,920
אה, כן, כן!

911
00:46:05,920 --> 00:46:08,300
זה היה די מגניב.

912
00:46:08,300 --> 00:46:09,950
[שחוק]

913
00:46:09,950 --> 00:46:12,060
אני יודע.

914
00:46:12,060 --> 00:46:14,500
כרויות בעצמי.

915
00:46:15,490 --> 00:46:18,300
אז מה שאנחנו מנסים לעשות הוא לכתוב תכנית

916
00:46:18,300 --> 00:46:21,110
שעובר דרך

917
00:46:21,110 --> 00:46:24,490
ואת האות הראשונה

918
00:46:24,490 --> 00:46:27,140
ואז כל מכתב ואילך -

919
00:46:27,140 --> 00:46:29,350
או כל אות אחרת לאחר מכן, אני מצטער.

920
00:46:29,350 --> 00:46:32,910
>> לכן - ואתה יכול לראות בדוגמה זו,

921
00:46:32,910 --> 00:46:35,260
זה איך אנחנו מפעילים את התכנית,

922
00:46:35,260 --> 00:46:38,780
ואז זה רק אומר, "אנחנו מפעילים תכנית בשם a.out.

923
00:46:41,490 --> 00:46:44,630
הקלט שאנחנו הולכים לתת לו

924
00:46:44,630 --> 00:46:47,090
הולך להיות יתבקש לעשות זאת.

925
00:46:47,090 --> 00:46:51,150
אנחנו לא הולכים לספק את הקלט בשורת הפקודה ".

926
00:46:51,150 --> 00:46:54,100
אם אתה עוקב אחרי כל ההרצאות

927
00:46:54,100 --> 00:46:56,710
ושמע על טענות של שורת פקודה,

928
00:46:57,810 --> 00:47:00,080
זה סוג של שם אלה - שתחביר פאנקי

929
00:47:00,080 --> 00:47:04,530
בעיקרי מגיע עם argc int, כל הדברים האלה,

930
00:47:04,530 --> 00:47:07,630
אז הנה אנחנו לא משתמשים בזה, אנחנו לא עוסקים בכל אלה.

931
00:47:09,400 --> 00:47:12,650
אנחנו פשוט הולכים לקבל את זה שהוקלד על ידי המשתמש ב,

932
00:47:12,650 --> 00:47:15,700
ואז שורה שנייה זה עם ייוון פאנקי

933
00:47:15,700 --> 00:47:18,550
מה שאנחנו רוצים את התכנית שלנו לפלט.

934
00:47:19,790 --> 00:47:22,860
>> אז במקום להשתמש במכשיר או הפעלה, יצטרך להשתמש ברווחים,

935
00:47:22,860 --> 00:47:25,360
בגלל שיש לנו רווחים,

936
00:47:25,360 --> 00:47:28,640
ולכן אם אתם הייתם

937
00:47:28,640 --> 00:47:32,380
ולקבל קוד לנראה משהו כזה,

938
00:47:32,380 --> 00:47:35,930
אז אני הולך להציל את גרסה זו

939
00:47:35,930 --> 00:47:38,390
רק אז יש לך את צלחת הדוד ממש כאן

940
00:47:38,390 --> 00:47:42,840
שנראה כמו זה, int הראשי (ריק), שום דבר בו.

941
00:47:44,480 --> 00:47:48,460
למעשה, מה שאנחנו עושים הם שאנחנו נצטרך למחוק הכל ביחד.

942
00:47:48,460 --> 00:47:50,330
אנחנו רוצים לוח חלק,

943
00:47:50,330 --> 00:47:52,470
בגלל שאנחנו לא הולכים להתחיל לכתוב קוד;

944
00:47:52,470 --> 00:47:55,380
ולא, אנחנו הולכים לנסות לכתוב כמה pseudocode

945
00:47:55,380 --> 00:47:58,580
שבאמת רק אומר שאנחנו הולכים לכתוב משהו שאיני קוד

946
00:47:58,580 --> 00:48:01,010
זה סוג של מתאר את מה שאנחנו רוצים לעשות,

947
00:48:01,010 --> 00:48:05,180
שזה בערך כמו שעשה דוד ביום הראשון של הרצאה,

948
00:48:05,180 --> 00:48:08,310
או שאני מניח שזה היה ביום השני של הרצאה כשהוא עשה את הדגמת גרביים השלמה.

949
00:48:08,310 --> 00:48:10,990
אולי אתם זוכרים ש-- רואים את הגרביים?

950
00:48:10,990 --> 00:48:13,300
יוסף היה שם למעלה סוג של הקלדה באנגלית?

951
00:48:13,300 --> 00:48:16,300
אז אנחנו הולכים לעשות את אותו הדבר.

952
00:48:16,300 --> 00:48:18,380
>> אז כשאני מתחיל לכתוב pseudocode,

953
00:48:18,380 --> 00:48:22,640
אני רוצה להתחיל על ידי הסתכלות על מה הקלט הולך להיות.

954
00:48:22,640 --> 00:48:24,950
ואני נותן את עצמי דוגמה אחת,

955
00:48:24,950 --> 00:48:28,780
כל כך כמו "תודה על התוספת!"

956
00:48:35,030 --> 00:48:38,010
ואז גם אני אכתוב מה שאני רוצה להיות הפלט,

957
00:48:38,010 --> 00:48:42,210
אשר במקרה זה הוא משהו כזה.

958
00:48:53,790 --> 00:48:56,050
וזה סוג של נותן לי מקום טוב, כמו, מתחיל לחשוב על,

959
00:48:56,050 --> 00:48:59,730
"אוקיי, אני רוצה לקחת את הקו 1

960
00:48:59,730 --> 00:49:03,560
ואני רוצה להפוך אותו לקו 2, "

961
00:49:03,560 --> 00:49:06,570
וזה סוג של מסייע להנחות את החשיבה שלי.

962
00:49:06,570 --> 00:49:09,990
זהו מקום טוב להתחיל בו.

963
00:49:09,990 --> 00:49:12,190
דרך נוספת לחשוב על זה, יותר מדי, כפי שאנו kinda להמשיך הלאה

964
00:49:12,190 --> 00:49:15,020
וכמו שאתה עושה את זה בתוכניות שלך, היא

965
00:49:15,020 --> 00:49:18,530
לחשוב על סוג של כמו מה הם המקרים זה העוקץ?

966
00:49:18,530 --> 00:49:20,740
מה הוא סוג של התרחישים המוזרים?

967
00:49:20,740 --> 00:49:23,660
מה הן התשומות המוזרות שאנחנו עלולים לקבל?

968
00:49:23,660 --> 00:49:26,550
ומה היציאות האלה צריכות להיראות?

969
00:49:26,550 --> 00:49:29,670
לדוגמה, קלט אחד מוזר

970
00:49:29,670 --> 00:49:33,200
יהיה זה אחד,

971
00:49:33,200 --> 00:49:35,630
יצירה שום דבר,

972
00:49:35,630 --> 00:49:37,840
כמו מה שיש לנו פלט במקרה זה?

973
00:49:37,840 --> 00:49:40,530
משהו שאנחנו רוצים לחשוב על זה, יותר מדי.

974
00:49:40,530 --> 00:49:44,450
>> אז בדיוק כמו שאלה,

975
00:49:44,450 --> 00:49:46,870
מה שאולי אנחנו רוצים פלט?

976
00:49:46,870 --> 00:49:50,740
אם אנחנו לא מקבלים שום קלט בכלל, מה צריך להיות פלט התכנית שלנו?

977
00:49:53,740 --> 00:49:54,860
שום דבר. >>

978
00:49:54,860 --> 00:49:57,340
שום דבר? נשמע נהדר.

979
00:49:57,340 --> 00:49:59,280
אז אנחנו רוצים לוודא שאנחנו לא כותבים שום דבר

980
00:49:59,280 --> 00:50:01,500
אם אנחנו לא מקבלים שום דבר פנימה

981
00:50:01,500 --> 00:50:04,320
מגניב. אוקיי.

982
00:50:04,320 --> 00:50:07,370
כך

983
00:50:07,370 --> 00:50:09,380
אני מתכוון לקרוא לכמה אנשים כמו שאנחנו הולכים דרך

984
00:50:09,380 --> 00:50:12,790
ופשוט להבין כמו סוג של מה האלגוריתם הכללי הוא

985
00:50:12,790 --> 00:50:15,250
ואנחנו סוג נתחיל לעבוד דרך זה יחד.

986
00:50:16,240 --> 00:50:19,710
>> אז, בואו נראים. מסים.

987
00:50:19,710 --> 00:50:21,220
איך אתה חושב שתתחילו?

988
00:50:21,220 --> 00:50:24,830
מה יהיה מקום טוב להתחיל בו כאן

989
00:50:24,830 --> 00:50:27,900
אם אנחנו רוצים לשנות, למשל, קו 1

990
00:50:27,900 --> 00:50:29,440
אל קו 2?

991
00:50:29,440 --> 00:50:32,650
האם אתה סוג של רק תסביר לי, באנגלית, מה אתה חושב?

992
00:50:32,650 --> 00:50:34,770
אל תדאגו לגבי קוד.

993
00:50:34,770 --> 00:50:38,250
>> הדבר הראשון שאני אעשה יהיה

994
00:50:38,250 --> 00:50:41,170
סוג של המשתמש הישיר כדי לספר להם מה שאתה רוצה.

995
00:50:41,170 --> 00:50:44,730
אוקיי, אז, אומר,

996
00:50:44,730 --> 00:50:47,450
"היי, משתמש. אני רוצה

997
00:50:47,450 --> 00:50:50,560
מחרוזת "- מדהים.

998
00:50:50,560 --> 00:50:52,990
אז בואו לכתוב את זה.

999
00:50:52,990 --> 00:50:56,140
מנחה את המשתמש למחרוזת.

1000
00:50:56,140 --> 00:50:59,270
זה נשמע כמו התחלה טובה.

1001
00:51:03,920 --> 00:51:06,460
בסדר.

1002
00:51:06,460 --> 00:51:09,750
בואו נשאל קלי רן שלב זה.

1003
00:51:09,750 --> 00:51:11,580
מה היינו אז רוצה לעשות עכשיו?

1004
00:51:11,580 --> 00:51:14,220
מה סוג שלנו בא -?

1005
00:51:14,220 --> 00:51:18,080
>> איסוף הקלט שלהם ולאחסן אותו כמשתנה.

1006
00:51:18,080 --> 00:51:20,470
גדול.

1007
00:51:20,470 --> 00:51:24,280
אז אוסף את החוט,

1008
00:51:25,450 --> 00:51:27,880
לאחסן אותו במשתנה.

1009
00:51:34,840 --> 00:51:36,460
אז האם יש משהו מיוחד שאנחנו רוצים לעשות כאן?

1010
00:51:36,460 --> 00:51:39,700
האם אנחנו רוצים לבדוק את הקלט שלהם

1011
00:51:39,700 --> 00:51:42,260
לפני -?

1012
00:51:42,260 --> 00:51:43,790
>> כן.

1013
00:51:43,790 --> 00:51:46,330
מה שאולי אנחנו רוצים לבדוק?

1014
00:51:46,330 --> 00:51:48,980
>> כן, אמר שאין לנו כדי לבדוק אם זה מספר, נכון?

1015
00:51:48,980 --> 00:51:52,400
כי זה יניח שזה קטן?

1016
00:51:52,400 --> 00:51:55,650
כן.

1017
00:51:56,380 --> 00:51:58,920
>> אז מתברר ש-- כן.

1018
00:51:58,920 --> 00:52:01,850
אז getString מובטח להחזיר אותנו מחרוזת.

1019
00:52:01,850 --> 00:52:05,050
זה לא הולך לחזור מספר לנו או משהו כזה.

1020
00:52:05,050 --> 00:52:09,140
אולי יש תווים ספרתיים בתוך מחרוזת, אם כי.

1021
00:52:09,140 --> 00:52:13,460
ואלה, אנו יכולים להתעלם כמו שעשינו ייוון.

1022
00:52:13,460 --> 00:52:16,620
אבל מחרוזת ריקה היא בסדר גמורה,

1023
00:52:16,620 --> 00:52:19,900
לכן המקרה ממש כאן, על קו 4 ו 5,

1024
00:52:19,900 --> 00:52:22,020
ימין, שבו אין כניסה,

1025
00:52:22,020 --> 00:52:25,190
ויש לנו את הדבר כפלט שלנו.

1026
00:52:25,190 --> 00:52:28,730
אנחנו לא צריכים לדאוג ולוודא שיש משהו במחרוזת

1027
00:52:28,730 --> 00:52:31,840
או שהמחרוזת באורך של לפחות 4 תווים;

1028
00:52:31,840 --> 00:52:34,190
כל דבר הוא בסדר.

1029
00:52:34,190 --> 00:52:38,270
אז זה עומד בניגוד, למשל, בתוכניות כמו מטבעים שכתבו

1030
00:52:38,270 --> 00:52:42,340
שבו אתה צריך לוודא שאתה מקבל מספרים שאינם שליליים;

1031
00:52:42,340 --> 00:52:46,430
אתה צריך לוודא שאתה מקבל את המספר הנכון של ימים בחודש.

1032
00:52:46,430 --> 00:52:49,630
ואיך אתם עושים את זה?

1033
00:52:49,630 --> 00:52:51,470
איך תעשה את הבדיקה הזאת?

1034
00:52:51,470 --> 00:52:54,090
מה שמחייב אותך להשתמש?

1035
00:52:54,090 --> 00:52:55,650
>> האם-אילו לולאות.

1036
00:52:55,650 --> 00:53:00,840
עשה תוך לולאות; סוגים אחרים של לולאות, יותר מדי, כן.

1037
00:53:02,190 --> 00:53:04,520
אז מתבררים שאנחנו לא צריכים להשתמש בלולאה במקרה זה,

1038
00:53:04,520 --> 00:53:07,360
כשאנחנו להציג עבור מחרוזת, שהוא די נחמד.

1039
00:53:08,280 --> 00:53:10,620
>> בסדר, ימשיך הלאה.

1040
00:53:12,410 --> 00:53:14,270
אז, סטלה.

1041
00:53:14,270 --> 00:53:17,530
האם אתה יכול לספר לנו קצת על מה שאנחנו צריכים לעשות עכשיו?

1042
00:53:17,530 --> 00:53:20,270
אז עכשיו יש לנו את המחרוזת, יש לנו אותו מאוחסן במשתנה;

1043
00:53:20,270 --> 00:53:23,360
מה אנחנו צריכים לעשות עם החוט?

1044
00:53:26,790 --> 00:53:33,530
>> אנחנו צריכים -

1045
00:53:33,530 --> 00:53:36,550
לזהות 2 -

1046
00:53:36,550 --> 00:53:39,290
כן, רק אומר את זה באנגלית, זה מדהים.

1047
00:53:39,290 --> 00:53:42,670
זהה את >> [לא ברורות] בירות - או, באותיות גדולות.

1048
00:53:44,420 --> 00:53:48,130
כן, כך היית לזהות אילו הם אותיות גדולות וקטנים.

1049
00:53:50,020 --> 00:53:54,180
אנחנו לא יכולים רישיות או הקטנים עד שנזהה איזה מהן.

1050
00:54:03,790 --> 00:54:06,350
אז אני נשים את זה לכאן.

1051
00:54:06,350 --> 00:54:10,210
>> לכן, רק מלחשוב על התהליך הזה,

1052
00:54:10,210 --> 00:54:13,200
איך אנחנו עושים את זיהוי הזה?

1053
00:54:13,200 --> 00:54:15,050
אתה יודע, דן?

1054
00:54:15,050 --> 00:54:18,120
סוג של מה שאנחנו - מה כלי שהיינו צריכות להשתמש מארגז הכלים שלנו?

1055
00:54:18,120 --> 00:54:22,500
>> שהייתי מנסח זאת בדרך כלשהי במערך או כמו כל קו

1056
00:54:22,500 --> 00:54:24,240
היא קופסה הקטנה משלו,

1057
00:54:24,240 --> 00:54:27,240
ואז אותיות גדולות זה משם או לא.

1058
00:54:27,240 --> 00:54:30,440
אוקיי, אז כלי אחד שאנחנו יכולים להשתמש הוא מערך.

1059
00:54:30,440 --> 00:54:33,760
מה יש לנו לחפש במחרוזת,

1060
00:54:33,760 --> 00:54:36,680
אם כי, כדי להבין - היה לנו להסתכל על הדמויות.

1061
00:54:36,680 --> 00:54:40,890
>> אז יש לך להסתכל על האורך של המחרוזת?

1062
00:54:40,890 --> 00:54:43,880
כן, כל כך חלק, כי הוא מקבל את אורך המחרוזת.

1063
00:54:50,450 --> 00:54:54,150
רק מתוך סקרנות, מה אנו משתמשים כדי לקבל את אורך מחרוזת?

1064
00:54:54,150 --> 00:54:58,080
>> Strlen?

1065
00:54:58,080 --> 00:55:02,870
כן, strlen, אנחנו קוראים לזה "strlen"

1066
00:55:04,180 --> 00:55:08,620
כל פונקציות מחרוזת אלה, ולכן הוא פונקציה strlen,

1067
00:55:08,620 --> 00:55:10,670
וזה סופר נוח, משום שאנו יכולים להשתמש בו רק כדי להגיד,

1068
00:55:10,670 --> 00:55:13,430
היי, strlen: הנה מחרוזת, יגיד לי כמה זמן זה.

1069
00:55:13,430 --> 00:55:17,350
בהרצאה היום, דיוויד דבר הרבה על איך strlen מיושם,

1070
00:55:17,350 --> 00:55:20,370
מה באמת קורה מאחורי הקלעים.

1071
00:55:20,370 --> 00:55:25,450
אבל זה אחד מאלה מאוד הסופר השימושיים.

1072
00:55:25,450 --> 00:55:29,170
ישנם אלה אחרים שגם בספריית המייתר,

1073
00:55:29,170 --> 00:55:34,690
כמו strcmp, שאיית "strcmp",

1074
00:55:34,690 --> 00:55:38,010
המשמש להשוואת מייתרים אחד לשנייה.

1075
00:55:41,220 --> 00:55:45,020
האחרים יוכלו להשתמש כמו strstr,

1076
00:55:45,020 --> 00:55:48,770
וזה טוב למציאה תת מחרוזות וכן הלאה.

1077
00:55:48,770 --> 00:55:53,380
ברוב המקרים, כולם מתחילים עם str ואז ללכת על להיות משהו אחר.

1078
00:55:53,380 --> 00:55:57,080
הסיבה שהם לא באמת לאיית אותם כמו מחרוזת וכן הלאה

1079
00:55:57,080 --> 00:56:00,260
הוא כי עוד כבימים הראשונים של C,

1080
00:56:00,260 --> 00:56:04,100
כאשר אנשים היו כתיבה ראשונה וכל זה,

1081
00:56:04,100 --> 00:56:07,580
הם היו מגבלות על מספר התווים שאתה יכול להשתמש

1082
00:56:07,580 --> 00:56:09,950
לשמות פונקציות ושמות משתנים,

1083
00:56:09,950 --> 00:56:12,620
כך שכל הדבר הוא כמו סופר מרוכז.

1084
00:56:12,620 --> 00:56:15,750
אבל כל פעם שאתה רואה משהו שמתחיל ברחוב,

1085
00:56:15,750 --> 00:56:18,600
בדרך כלל אומר שזה משהו שקשור בחוט.

1086
00:56:20,990 --> 00:56:23,350
>> אוקיי, אז יש לך כדי לקבל את האורך של המחרוזת,

1087
00:56:23,350 --> 00:56:27,110
ואז, מה אנחנו עושים עם הדמויות?

1088
00:56:27,110 --> 00:56:29,020
אתה יודע, סם?

1089
00:56:29,020 --> 00:56:32,410
>> אין לי מושג, אני מנסה להבין את זה.

1090
00:56:32,410 --> 00:56:35,410
אני באמת לא יודע - הלוואי שהייתי דרך כלשהי -

1091
00:56:35,410 --> 00:56:38,990
אני מתכוון, אני חושב שאולי אוכל לעשות משהו עם סיכויים ומשתווה,

1092
00:56:38,990 --> 00:56:40,860
אבל אני לא יודע על שום תפקיד כזה.

1093
00:56:40,860 --> 00:56:42,240
כן.

1094
00:56:43,160 --> 00:56:45,200
>> אבל - זה לא בהכרח היה עובד,

1095
00:56:45,200 --> 00:56:48,690
כי אז היית מקבל את החללים להיות -

1096
00:56:48,690 --> 00:56:51,130
היית צריך להיות מקום כדי לקבל טיפים על איך -

1097
00:56:51,130 --> 00:56:54,310
אוקיי.

1098
00:56:54,310 --> 00:56:56,490
>> אני לא יודע - אני סוג של אבד בשלב זה.

1099
00:56:56,490 --> 00:56:58,120
כן - לא, לא, לא, אלה הם נקודות טובות.

1100
00:56:58,120 --> 00:57:00,420
אז מה שאנחנו צריכים לעשות הוא, כמו שאמר סם,

1101
00:57:00,420 --> 00:57:02,970
אנחנו צריכים לעקוב אחר שהאותיות הן האותיות המשונות,

1102
00:57:02,970 --> 00:57:05,540
ואלו הם אותיות אפילו.

1103
00:57:06,650 --> 00:57:09,090
אבל אנחנו רוצים לוודא שאנחנו לא רק מחפשים

1104
00:57:09,090 --> 00:57:12,110
במוזר ואפילו

1105
00:57:12,110 --> 00:57:14,030
מדדים במחרוזת,

1106
00:57:14,030 --> 00:57:17,660
אלא מסתכל על האותיות המוזרות ואפילו במחרוזת,

1107
00:57:17,660 --> 00:57:20,190
כך שאנחנו צריכים להיות קצת הבחנה זו בין

1108
00:57:20,190 --> 00:57:25,190
אותיות - כמו מה זה בעצם, B, C, D, או כן הלאה,

1109
00:57:25,190 --> 00:57:29,090
ומה הם דברים שלא מכתבים, אבל עדיין במחרוזת שלנו.

1110
00:57:29,090 --> 00:57:32,390
לדוגמה כאן, כמו סימן קריאה זה לא מכתב,

1111
00:57:32,390 --> 00:57:36,060
אבל זה עדיין חלק מהמחרוזת שלנו, זה עדיין char.

1112
00:57:36,060 --> 00:57:38,820
כמו כן, כל הרווחים האלה -

1113
00:57:38,820 --> 00:57:41,710
זה לא הגיוני לנצל שטח, נכון?

1114
00:57:41,710 --> 00:57:46,160
אז אנחנו רוצים לוודא שאנחנו איכשהו לדלג אלה

1115
00:57:46,160 --> 00:57:49,410
תוך מעקב ומאזן סיכויים.

1116
00:57:50,900 --> 00:57:54,990
>> אז סוג של ארגז הכלים בתכנות שלנו

1117
00:57:54,990 --> 00:57:57,270
עד כה, אם ארצה,

1118
00:57:57,270 --> 00:58:01,310
יש לנו מספר הכלים שונים שדברנו עליו.

1119
00:58:01,310 --> 00:58:04,640
אז אחת, למשל, הם משתנים,

1120
00:58:04,640 --> 00:58:07,120
כמו שדברנו עליו כאן.

1121
00:58:07,120 --> 00:58:10,730
כלי נוסף שדברנו עליו הם פונקציות.

1122
00:58:10,730 --> 00:58:15,800
אז אנחנו מדברים על משתנים בpseudocode כאן

1123
00:58:15,800 --> 00:58:19,760
כמו מה שאנחנו הולכים להשתמש לאחסון המחרוזת שלנו.

1124
00:58:19,760 --> 00:58:24,630
דברנו על פונקציות כדי לקבל את האורך של מחרוזת, כמו strlen.

1125
00:58:28,510 --> 00:58:31,170
אנחנו כבר מדברים על משהו אחר, ואנחנו לא מדברים על זה

1126
00:58:31,170 --> 00:58:34,850
להרבה קודם לכן בסעיף היום: לולאות.

1127
00:58:39,390 --> 00:58:42,030
>> מה אתם חושבים על שימוש בלולאה בתכנית זו?

1128
00:58:42,030 --> 00:58:44,110
ג'ארד, מה אתה חושב?

1129
00:58:47,150 --> 00:58:50,030
האם אנו משתמשים בלולאה בתכנית זו?

1130
00:58:50,030 --> 00:58:52,500
>> כנראה שלא, לא, כי אתה לא צריך לעבור את זה יותר מפעם אחת.

1131
00:58:52,500 --> 00:58:55,260
אוקיי, אתה לא צריך לעבור את מה שיותר מפעם אחת?

1132
00:58:55,260 --> 00:58:57,190
>> כל המחרוזת.

1133
00:58:57,190 --> 00:59:00,660
בסדר, אז אתה לא צריך לעבור את המחרוזת כל פעם.

1134
00:59:00,660 --> 00:59:03,330
מצטער שלא היה שום היגיון!

1135
00:59:03,330 --> 00:59:06,360
אתה לא צריך לעבור את כל המחרוזת יותר מפעם אחת.

1136
00:59:06,360 --> 00:59:08,660
אוקיי.

1137
00:59:09,790 --> 00:59:11,920
מה אתה חושב?

1138
00:59:11,920 --> 00:59:14,110
>> אני חושב שעדיף להשתמש בם

1139
00:59:14,110 --> 00:59:16,640
כדי שנוכל לעשות כמו להוון תוך

1140
00:59:16,640 --> 00:59:19,750
המיקום שלו הוא מספר [לא ברור].

1141
00:59:19,750 --> 00:59:22,940
גדול, וכך לנצל את מה?

1142
00:59:22,940 --> 00:59:25,200
אוקיי, אז אנחנו אומרים ש

1143
00:59:25,200 --> 00:59:28,130
אנחנו צריכים להשתמש בלולאה כי אנחנו רוצים

1144
00:59:28,130 --> 00:59:32,550
להוון מכתב בעוד שזה לא מספר.

1145
00:59:35,130 --> 00:59:37,140
אז - מצטער, לא ברצונך להוסיף?

1146
00:59:37,140 --> 00:59:39,340
>> אני עומד לומר שהדרך בה אתה מתייחס למחרוזת

1147
00:59:39,340 --> 00:59:42,290
וזה [לא ברור] נפרד [לא ברור] על הדמויות?

1148
00:59:42,290 --> 00:59:43,710
כן.

1149
00:59:43,710 --> 00:59:45,850
>> ואז תוכל להקצות את המספרים ל--

1150
00:59:45,850 --> 00:59:47,780
או המבוסס על המיקום של האותיות במחרוזת?

1151
00:59:47,780 --> 00:59:49,720
כן.

1152
00:59:49,720 --> 00:59:53,640
>> ולזהות אם זה מוזר או אפילו, ולמצות את המכתב עצמו

1153
00:59:53,640 --> 00:59:57,750
ואילו מיקומו של המכתב הוא [לא ברור] - מצטער.

1154
00:59:57,750 --> 01:00:00,150
גדול.

1155
01:00:00,150 --> 01:00:03,430
>> אז רק לסכם.

1156
01:00:03,430 --> 01:00:05,840
האם תוכל להזכיר לי את השם שלך שוב - אני מצטער.

1157
01:00:05,840 --> 01:00:06,900
>> שרלוט.

1158
01:00:06,900 --> 01:00:08,490
שרלוט, בסדר.

1159
01:00:08,490 --> 01:00:11,130
אז מה שרלוט אומרת,

1160
01:00:11,130 --> 01:00:14,950
אשר נכון לחלוטין - אלוהים, כמו זו לכניסה אוטומטית עליי -

1161
01:00:14,950 --> 01:00:17,770
הוא שאם אנחנו מסתכלים על מחרוזת

1162
01:00:17,770 --> 01:00:19,160
כמו זו בראש -

1163
01:00:19,160 --> 01:00:21,590
"תודה על הוספה" -

1164
01:00:21,590 --> 01:00:24,790
כרצף של תווים

1165
01:00:24,790 --> 01:00:29,010
איפה הוא בעמדה 0,

1166
01:00:29,010 --> 01:00:32,260
h הוא בעמדת 1.

1167
01:00:32,260 --> 01:00:36,880
הוא בשעת 2, אז יש לנו 3, 4, 5;

1168
01:00:36,880 --> 01:00:40,830
החלל הוא במיקום 6.

1169
01:00:42,380 --> 01:00:45,300
ואילו - מה העמדה של f?

1170
01:00:45,300 --> 01:00:47,610
7!

1171
01:00:47,610 --> 01:00:49,300
O? 8.

1172
01:00:49,300 --> 01:00:52,070
ר? 9.

1173
01:00:52,070 --> 01:00:54,340
ולאחר מכן יש לנו 10, ואז אני באמת לא יכול לכתוב את זה בלי זה

1174
01:00:54,340 --> 01:00:57,430
די מבולגן מקבל על המסך.

1175
01:00:57,430 --> 01:01:02,340
אבל זה בעצם מה שאנחנו יכולים לדבר על מחרוזות בזיכרון.

1176
01:01:02,340 --> 01:01:04,660
האם זה מחרוזת

1177
01:01:04,660 --> 01:01:07,920
הוא רצף של תווים,

1178
01:01:07,920 --> 01:01:12,430
כאשר אנו מתייחסים לאופי אישי ובמחרוזת,

1179
01:01:12,430 --> 01:01:15,280
לעתים קרובות אנו עושים זאת על ידי הפנייה לעמדה שהאופי של

1180
01:01:15,280 --> 01:01:17,620
בתוך המחרוזת,

1181
01:01:17,620 --> 01:01:19,910
כנראה באותה הדרך שאנחנו מדברים על ספטמבר

1182
01:01:19,910 --> 01:01:22,870
להיות החודש התשיעי של השנה

1183
01:01:22,870 --> 01:01:27,730
או ביום שני הוא היום הראשון בשבוע.

1184
01:01:29,280 --> 01:01:33,070
אז זה מספק אותנו לדרך

1185
01:01:33,070 --> 01:01:37,030
להבין אילו הם מוזרים אפילו לעומת

1186
01:01:37,030 --> 01:01:39,540
כי אתה יכול לראות כאן,

1187
01:01:39,540 --> 01:01:43,640
אם אנחנו משווים את זה עם T זה,

1188
01:01:46,310 --> 01:01:49,360
אתה יכול לראות שכל אלה שהוונו

1189
01:01:49,360 --> 01:01:53,040
הם אפילו בעמדות,

1190
01:01:53,040 --> 01:01:55,880
לפחות למילה הראשונה,

1191
01:01:55,880 --> 01:01:59,080
ואז דברים שהיינו נזרק מרגע שפגענו בחלל,

1192
01:01:59,080 --> 01:02:02,460
בגלל שאנחנו לא סופרים את החלל הזה כמכתב,

1193
01:02:02,460 --> 01:02:05,150
כך שזה כאילו התחלנו

1194
01:02:05,150 --> 01:02:08,930
ויצאתי 0, 1, 2, 3, 4, 5,

1195
01:02:08,930 --> 01:02:12,600
חלל, 6, 7, 8, מרחב,

1196
01:02:12,600 --> 01:02:16,440
9, ולאחר מכן 10, 11, 12, וכן הלאה.

1197
01:02:19,300 --> 01:02:22,910
>> מגניב, ולכן אנחנו בהחלט רוצים להשתמש בסוג מסוים של לולאה

1198
01:02:22,910 --> 01:02:27,760
כדי לעבור על כל אחת מהדמויות בתורו.

1199
01:02:31,330 --> 01:02:34,580
לכן בשלב זה,

1200
01:02:36,490 --> 01:02:38,360
אנחנו נחזור לpseudocode הישן שלנו כאן.

1201
01:02:40,970 --> 01:02:42,650
כחלק מהזדהות זו של אלה אשר

1202
01:02:42,650 --> 01:02:45,350
הם באותיות רישיות ואילו הם קטנים,

1203
01:02:45,350 --> 01:02:48,340
אנחנו רוצים לעשות את זה באיזה לולאה.

1204
01:02:51,080 --> 01:02:53,390
לולאה, במעי גס.

1205
01:02:55,070 --> 01:03:01,220
איזה סוג של לולאה, מתוך הסוגים של לולאות שיש לנו,

1206
01:03:01,220 --> 01:03:03,670
נראה שיש אחד טוב לשימוש במקרה זה?

1207
01:03:03,670 --> 01:03:05,610
>> חשבתי ללולאה.

1208
01:03:05,610 --> 01:03:07,500
ולמה אתה חושב ללולאה?

1209
01:03:07,500 --> 01:03:10,000
>> כי זה מתחיל באפס, ולאחר מכן

1210
01:03:10,000 --> 01:03:13,000
כאשר אנו מגיעים לאורכו של החוט,

1211
01:03:13,000 --> 01:03:16,170
ולאחר מכן כל איטרציה אתה יכול [לא ברור], מדי?

1212
01:03:16,170 --> 01:03:18,260
כן, בדיוק.

1213
01:03:18,260 --> 01:03:21,490
לכן, מתוך את הבחירות השונות של לולאות,

1214
01:03:21,490 --> 01:03:25,350
יש לנו ללולאות, בעוד לולאות, ולעשות תוך לולאות.

1215
01:03:25,350 --> 01:03:28,550
איפה ללולאה שימושית במיוחד

1216
01:03:28,550 --> 01:03:32,120
כאשר אתה רוצה לדעת

1217
01:03:32,120 --> 01:03:34,940
סוג שבו אתה נמצא בבית בלולאה,

1218
01:03:34,940 --> 01:03:38,520
כמה פעמי הלולאה בוצעה עד כה.

1219
01:03:38,520 --> 01:03:42,490
וזה בדיוק מה שאנחנו רוצים לדעת במצב הזה,

1220
01:03:42,490 --> 01:03:44,640
כמו אמר קלי,

1221
01:03:44,640 --> 01:03:47,400
מבוסס על ההנחה של ההערה הקודמת של שרלוט שאנחנו רוצים לדעת את המיקום

1222
01:03:47,400 --> 01:03:49,900
של הדמות בתוך המחרוזת,

1223
01:03:49,900 --> 01:03:51,750
ועבור לולאה ייתן לנו בדיוק את זה,

1224
01:03:51,750 --> 01:03:54,680
כי אם אנחנו מתחילים סוג של מבט לאחור על המחרוזת שלנו,

1225
01:03:54,680 --> 01:03:57,140
אם תתחילו הלולאה עבורנו ב0,

1226
01:03:57,140 --> 01:04:00,350
ואנחנו עולים לאורכו של כל החוט,

1227
01:04:00,350 --> 01:04:04,740
אז אנחנו יכולים לשייך את אות T

1228
01:04:04,740 --> 01:04:08,110
עם 0 בלולאה,

1229
01:04:09,950 --> 01:04:13,080
המכתב H עם 1 בלולאה, וכן הלאה,

1230
01:04:13,080 --> 01:04:16,600
הולך את כל הדרך עד לסוף המחרוזת.

1231
01:04:18,810 --> 01:04:21,890
>> אז בואו נתחיל קידוד זה רק קצת

1232
01:04:21,890 --> 01:04:24,930
פשוט כל כך אתם לקבל תחושה איך זה נראה.

1233
01:04:24,930 --> 01:04:27,980
אני הולך להציל את זה,

1234
01:04:27,980 --> 01:04:31,230
כך שיש לנו הקוד פסאודו כאן,

1235
01:04:33,490 --> 01:04:38,120
ואני הולך למחוק הכל.

1236
01:04:38,120 --> 01:04:42,210
אז יש לי לוח חלק.

1237
01:04:42,210 --> 01:04:45,910
אני הולך להתחיל על ידי כתיבה (void) העיקרי int

1238
01:04:45,910 --> 01:04:48,440
{

1239
01:04:48,440 --> 01:04:51,380
אני הולך לשים 0 בתמורה

1240
01:04:51,380 --> 01:04:53,320
ולאחר מכן}.

1241
01:04:53,320 --> 01:04:56,130
אז בדרך כלל כשאני מתחיל תכנית, זה מה שאני מתחיל איתו.

1242
01:04:56,130 --> 01:04:59,370
אני אשמור אותו כך שיש לכם את זה.

1243
01:05:06,290 --> 01:05:08,440
אז אחד הדברים הראשונים שדברנו עליו היה

1244
01:05:08,440 --> 01:05:10,920
מקבל קלט מהמשתמש

1245
01:05:10,920 --> 01:05:13,740
ולאחסן אותו בחוט.

1246
01:05:13,740 --> 01:05:16,420
כיצד תקבל קלט ממשתמש?

1247
01:05:16,420 --> 01:05:19,640
GetString. >>

1248
01:05:19,640 --> 01:05:21,870
GetString, בסדר.

1249
01:05:23,150 --> 01:05:26,820
אז אם אני מקליד GetString ()

1250
01:05:26,820 --> 01:05:32,150
ופסיק.

1251
01:05:32,150 --> 01:05:36,630
בואו ננסה לרוץ בזה; יהיה זה לרוץ, קודם כל?

1252
01:05:36,630 --> 01:05:38,430
ולמה זה לא פועל?

1253
01:05:38,430 --> 01:05:40,090
>> יש לך להצהיר על המשתנה.

1254
01:05:40,090 --> 01:05:43,040
אני חייב להצהיר על משתנה. אוקיי.

1255
01:05:43,040 --> 01:05:45,700
>> אז איך אני עושה את זה?

1256
01:05:45,700 --> 01:05:48,400
אכפת לך לכתוב משהו, לחלוק אותו?

1257
01:05:48,400 --> 01:05:51,270
ואז אנחנו יכולים למשוך אותו.

1258
01:05:51,270 --> 01:05:54,630
בואו נראים, דן, נכון, בסדר.

1259
01:05:54,630 --> 01:05:59,100
או דניאל. העתק שב, קלט מחרוזת = GetString ().

1260
01:05:59,100 --> 01:06:01,340
מדהים.

1261
01:06:01,340 --> 01:06:02,890
האם זה פועל?

1262
01:06:02,890 --> 01:06:05,210
בואו ננסה את זה.

1263
01:06:05,210 --> 01:06:08,890
הכה ריצה, קוד מקור העלאה, בניין, אירע שגיאה.

1264
01:06:08,890 --> 01:06:11,040
אוקיי.

1265
01:06:11,040 --> 01:06:14,950
אז מה חדש קורה כאן?

1266
01:06:14,950 --> 01:06:18,700
שימוש בביטויים 'המחרוזת' מזהה לא מוצהר.

1267
01:06:18,700 --> 01:06:22,840
>> יש לנו לכלול את הספריות?

1268
01:06:22,840 --> 01:06:25,130
כן, כל כך של דן אומר שיש לנו כדי לכלול את הספריות.

1269
01:06:25,130 --> 01:06:28,270
האם זה מה שאתה מתכוון לומר, סטלה? מדהים.

1270
01:06:29,450 --> 01:06:31,430
זה מדהים, כל כך סטלה, אתה יכול

1271
01:06:31,430 --> 01:06:34,800
העתק את הקוד הזה מתוך השטח של דניאל?

1272
01:06:34,800 --> 01:06:37,580
אם תלחץ על דניאל רולאן קי, להעתיק אותו,

1273
01:06:37,580 --> 01:06:41,360
ואז אתה שם את הקו כולל ב, ולאחר מכן לשמור אותו?

1274
01:06:46,580 --> 01:06:49,360
תודיע לי כשאתה מוכן.

1275
01:06:57,160 --> 01:06:59,490
אז תחביר כולל זה גם סוג של פאנקי;

1276
01:06:59,490 --> 01:07:02,210
יש כזה תג חשיש,

1277
01:07:02,210 --> 01:07:05,760
ויש לכלול, ואז יש הסוגריים האלה.

1278
01:07:12,490 --> 01:07:15,360
אתה זוכר איך זה עובד, או שאני צריך לשים אותו בקוד זה כאן?

1279
01:07:15,360 --> 01:07:17,850
>> אני טוב.

1280
01:07:17,850 --> 01:07:19,810
אוקיי.

1281
01:07:19,810 --> 01:07:23,260
>> שהדפסתי אותו - אני לא היה בטוח שספרייה, אם כי.

1282
01:07:23,260 --> 01:07:25,570
אה, בסדר - כן, כך שזה ספריית CS50.

1283
01:07:25,570 --> 01:07:27,660
>> אה, שמתי את ספריית stdio.

1284
01:07:27,660 --> 01:07:30,950
>> אה, יש את זה - כן, לא, כלומר -

1285
01:07:30,950 --> 01:07:34,380
כך מתבררת שהמחרוזת היא למעשה משהו שהוא מיוחד לCS50.

1286
01:07:36,590 --> 01:07:41,240
למעשה אין סוג מחרוזת אמיתית

1287
01:07:41,240 --> 01:07:45,000
כי ממש כאן, מחרוזת נמצאת במצב הסוג, -

1288
01:07:45,000 --> 01:07:49,140
אנחנו מכריזים קלט נקרא משתנה מסוג המחרוזת -

1289
01:07:49,140 --> 01:07:53,320
ואנחנו מציבים בתוך הקלט

1290
01:07:53,320 --> 01:07:58,440
הערך שמקבל חזר אלינו: הפלט של קריאה לפונקצית GetString זה.

1291
01:07:58,440 --> 01:08:02,910
אתה יכול להגיד את זה הוא קריאה לפונקציה כי יש בזה את הסוגריים, בדיוק כמו עושה printf,

1292
01:08:02,910 --> 01:08:05,920
בדיוק כמו strlen עושה.

1293
01:08:05,920 --> 01:08:09,860
אבל מחרוזת היא למעשה לא סוג אמיתי

1294
01:08:09,860 --> 01:08:11,760
בשפת C.

1295
01:08:11,760 --> 01:08:15,710
אנחנו הפכנו אותו לסוג, ואנחנו ניקח על יותר מה שהיא באמת

1296
01:08:15,710 --> 01:08:19,000
ב-C, משום שיש דרך לעבוד עם מחרוזות;

1297
01:08:19,000 --> 01:08:22,479
רק עשינו משהו כדי שזה ייראה טוב יותר במקצת.

1298
01:08:22,479 --> 01:08:25,240
>> אז הנה זה בא.

1299
01:08:25,240 --> 01:08:28,439
הנה הקוד של סטלה.

1300
01:08:28,439 --> 01:08:32,470
זה חייב לכלול # <cs50.h>.

1301
01:08:32,470 --> 01:08:36,390
אנשים אחרים קוראים לזה כמו חשיש כולל לפעמים או חד כולל.

1302
01:08:36,390 --> 01:08:39,580
עכשיו אנחנו יכולים להתחיל אותו, להפעיל אותו,

1303
01:08:39,580 --> 01:08:43,649
ואנחנו עדיין מקבלים הודעת שגיאה.

1304
01:08:43,649 --> 01:08:46,290
בואו לראות מה קורה.

1305
01:08:48,069 --> 01:08:50,569
"'קלט' משתנה שאינם בשימוש".

1306
01:08:50,569 --> 01:08:53,350
אוקיי, אז זה מגניב, זה מגניב.

1307
01:08:53,350 --> 01:08:55,859
אני מתכוון, זה לא ממש מגניב,

1308
01:08:55,859 --> 01:08:57,930
בגלל שאנחנו מקבלים הודעת שגיאה וזה לא פועל,

1309
01:08:57,930 --> 01:09:00,410
אבל מה שזה אומר הוא ש

1310
01:09:00,410 --> 01:09:03,130
אנחנו לא השתמשנו במשתנה שלנו, וזה הגיוני.

1311
01:09:03,130 --> 01:09:06,090
אנחנו לא ניסינו לעשות שום דבר עם זה.

1312
01:09:07,819 --> 01:09:10,490
זוהי דרך ש

1313
01:09:10,490 --> 01:09:14,170
קלאנג מנסה לעזור לנו לוודא שאנחנו לא רק באמצעות משתנים

1314
01:09:14,170 --> 01:09:18,819
ואז בטעות קורא להם משהו אחר מאוחר יותר בקוד שלנו,

1315
01:09:18,819 --> 01:09:21,649
עוזר לנו להימנע משגיאות בדרך זו.

1316
01:09:23,130 --> 01:09:28,810
>> בסדר, אז יש לנו קלט ממשתמש,

1317
01:09:28,810 --> 01:09:31,910
אז אחסנו אותו במשתנה.

1318
01:09:31,910 --> 01:09:34,569
הצעד הבא היה אז

1319
01:09:34,569 --> 01:09:37,609
להתחיל לחפש בכל התווים במחרוזת

1320
01:09:37,609 --> 01:09:41,830
ואילו הם מזהים לאותיות רישיות

1321
01:09:41,830 --> 01:09:44,600
ואילו הם להיות באותיות קטנות.

1322
01:09:44,600 --> 01:09:49,439
וכמו קלי ושרלוט הביאו למעלה,

1323
01:09:49,439 --> 01:09:52,340
אנו עושים זאת באמצעות ללולאה.

1324
01:09:52,340 --> 01:09:55,520
אז מישהו בכלל זוכר את התחביר של לולאת for

1325
01:09:55,520 --> 01:09:58,670
והייתי רוצה לקחת דקירה בפשוט כותבים

1326
01:09:58,670 --> 01:10:03,170
השורה הראשונה של ללולאה, רק לקצת?

1327
01:10:05,740 --> 01:10:07,330
קלי, אתה רוצה לנסות את זה?

1328
01:10:07,330 --> 01:10:10,300
>> כן, אז אתה צריך לאתחל ראשון,

1329
01:10:10,300 --> 01:10:13,170
אז שם לי = 0,

1330
01:10:13,170 --> 01:10:15,390
ואז עשה לי <strlen ().

1331
01:10:15,390 --> 01:10:18,570
האם זה בשטח שלך - האם אני יכול למשוך את זה?

1332
01:10:18,570 --> 01:10:21,330
>> כן, אני דפוק קצת, אבל כן.

1333
01:10:21,330 --> 01:10:24,180
>> אוקיי, בואו להרים אותה.

1334
01:10:24,180 --> 01:10:26,490
מדהים.

1335
01:10:26,490 --> 01:10:29,510
>> אבל אז אני לא יודע אם הייתי לך את זה -

1336
01:10:29,510 --> 01:10:32,180
כן, בסדר.

1337
01:10:33,020 --> 01:10:36,030
אז הנה מה שיש לי קלי: בואו נסתכל עליו במהירות.

1338
01:10:36,030 --> 01:10:40,290
אז היא כללה cs50 הספרייה בחלק העליון.

1339
01:10:40,290 --> 01:10:44,790
היא כללה את ספריית IO הסטנדרטית בראש,

1340
01:10:45,550 --> 01:10:48,990
והתקן IO יש פונקציות כמו printf,

1341
01:10:48,990 --> 01:10:51,690
כך שאם אי פעם תרצה להשתמש printf, אתה צריך את הקו הזה.

1342
01:10:53,060 --> 01:10:56,140
ואז היא כללה מחרוזת ספרייה,

1343
01:10:56,140 --> 01:10:58,200
שאנו צריכים,

1344
01:10:58,200 --> 01:11:01,010
מפני שהספרייה יש מחרוזת strlen פונקציה,

1345
01:11:01,010 --> 01:11:04,320
אשר יגיע ל, רק קצת.

1346
01:11:04,320 --> 01:11:07,560
אז אם אנחנו מסתכלים על מה שקלי נעשה כאן,

1347
01:11:07,560 --> 01:11:10,260
אם אפשר ללכת דרכנו את מה שעשית?

1348
01:11:10,260 --> 01:11:13,600
>> כן, כן - אני מתכוון, יש לי טעויות, ולכן -

1349
01:11:13,600 --> 01:11:15,380
כן, לא, זהו -

1350
01:11:15,380 --> 01:11:18,580
>> אז אני רציתי לקרוא את המחרוזת שיש לי רק "מחרוזת".

1351
01:11:18,580 --> 01:11:22,230
אני רוצה להדפיס את המחרוזת

1352
01:11:22,230 --> 01:11:25,640
ואז -

1353
01:11:27,450 --> 01:11:30,930
רציתי רוצה להגדיר כמחרוזת כמו מערך של כל תו

1354
01:11:30,930 --> 01:11:33,170
להיות שונים [לא ברור], נכון?

1355
01:11:33,170 --> 01:11:38,080
ואז אני רוצה להתחיל בעמדה 0

1356
01:11:38,080 --> 01:11:40,630
ולאחר מכן כל 2 ברווחים,

1357
01:11:40,630 --> 01:11:42,580
אני הולך לנצל,

1358
01:11:42,580 --> 01:11:45,680
אז אני פשוט תארתי אותו כבן 23, כי אני מסתכל בטבלת ASCII.

1359
01:11:45,680 --> 01:11:48,730
אז זה מה שאני חושב - אני יודע שזה לא בסדר.

1360
01:11:48,730 --> 01:11:50,920
>> קבלתי את זה, אז זה התחלה מצוינת.

1361
01:11:50,920 --> 01:11:54,120
אני חושב שהרבה מהמסגרת הוא במקום כאן.

1362
01:11:54,120 --> 01:11:57,500
בואו נעבור סוג של שורה אחרת שורה ולראות מה קורה.

1363
01:11:57,500 --> 01:12:01,040
אז כמו שאני אוהב לעשות זה פשוט להתחיל על ידי ההידור של הקוד

1364
01:12:01,040 --> 01:12:04,300
ולתת למהדר יגיד לי כמו מה לא בסדר עם הקוד שלי,

1365
01:12:04,300 --> 01:12:07,450
כי המהדר הוא ממש טוב באומר לך מה לא בסדר עם הקוד שלך.

1366
01:12:09,790 --> 01:12:12,780
אז אם אנחנו משחקים אותה, בנייה, וזה לא לבנות.

1367
01:12:12,780 --> 01:12:14,860
זה אומר שהייתה טעות,

1368
01:12:14,860 --> 01:12:17,320
כך שאם אנו לגלול למטה ומסתכלים על השגיאה הראשונה,

1369
01:12:17,320 --> 01:12:20,960
זה אמר -

1370
01:12:20,960 --> 01:12:22,040
אנו לגלול חזרה לפסגה,

1371
01:12:22,040 --> 01:12:26,070
אנו יכולים לראות שיש 5 טעויות שנוצרו כאן למטה בתחתית.

1372
01:12:26,070 --> 01:12:30,180
אופס, זה באמת נותק.

1373
01:12:31,810 --> 01:12:35,790
אני מניח שפשוט לא הולך להיות יותר טוב.

1374
01:12:36,970 --> 01:12:38,500
>> הנה אנחנו מתחילים.

1375
01:12:39,790 --> 01:12:42,530
אז יש 5 שגיאות הכוללים שנוצרו.

1376
01:12:42,530 --> 01:12:45,140
כאן אני יכול לראות את 2 הראשונים בלבד,

1377
01:12:45,140 --> 01:12:49,100
אז אני יכול להעביר את זה קצת, ואז סוג של את הגלילה.

1378
01:12:49,100 --> 01:12:53,220
זו הפקודה שהופעלה כדי לקמפל את הקוד,

1379
01:12:53,220 --> 01:12:59,030
ולאחר מכן השגיאה הראשונה הייתה בfile.c כאן:

1380
01:12:59,030 --> 01:13:03,300
"צפוי לזהות או '('", וזה היה על הקו הזה

1381
01:13:03,300 --> 01:13:06,680
איפה אנחנו אמרנו מחרוזת = GetString ().

1382
01:13:07,660 --> 01:13:12,920
אתה יכול לראות כאן שזה היה על קו 8 של file.c,

1383
01:13:12,920 --> 01:13:17,230
ואז אני מאמין שזה אופי 12 - זה השגיאה.

1384
01:13:17,230 --> 01:13:20,390
אז מה השתבש בשורה 8 - קלי?

1385
01:13:20,390 --> 01:13:22,810
>> אתה פשוט צריך לקרוא לזה, כמו, מכתב או משהו,

1386
01:13:22,810 --> 01:13:24,400
כמו מחרוזת של או משהו?

1387
01:13:24,400 --> 01:13:28,250
כן, אז מתבררים ששמות סוגים מיוחדים אלה,

1388
01:13:28,250 --> 01:13:31,770
כך המחרוזת, int, char, קצר,

1389
01:13:31,770 --> 01:13:35,740
הם כל מילות המפתח מיוחדות,

1390
01:13:35,740 --> 01:13:38,940
ואתה לא ממש יכול להשתמש בם כשמות של המשתנים שלך,

1391
01:13:38,940 --> 01:13:41,430
כי המהדר מסתכל על זה ואומר,

1392
01:13:41,430 --> 01:13:43,680
"אה, אני יודע שזה סוג"

1393
01:13:43,680 --> 01:13:46,530
אז אתה לא יכול באמת יש משתנה מחרוזת נקראת מחרוזת,

1394
01:13:46,530 --> 01:13:50,800
כמו שאני מנסה לעשות כאן, זה לא יעבוד.

1395
01:13:52,610 --> 01:13:58,250
אבל במקום זה, אנחנו יכולים לקרוא לזה משהו כמו ים או ברחוב או ברחוב.

1396
01:13:58,250 --> 01:14:01,540
אנחנו גם לא יכולים לקרוא לזה int.

1397
01:14:01,540 --> 01:14:03,740
אנחנו לא יכולים לקבל מחרוזת בשם int.

1398
01:14:03,740 --> 01:14:06,740
אנחנו לא יכולים לקבל מחרוזת בשם char: אף אחד מאלה שיעבדו.

1399
01:14:06,740 --> 01:14:09,420
>> אז אנחנו פשוט קוראים לזה של לעת עתה.

1400
01:14:10,630 --> 01:14:13,170
מדהים.

1401
01:14:13,170 --> 01:14:17,500
אז מה עכשיו קורה בתחום הזה?

1402
01:14:21,390 --> 01:14:24,350
מחרוזת - קו זה נראה די טוב?

1403
01:14:24,350 --> 01:14:27,830
בואו לנסות עוד פעם, ובואו להפעיל אותו.

1404
01:14:27,830 --> 01:14:30,360
אוקיי, אז אנחנו עדיין מקבלים שגיאות.

1405
01:14:30,360 --> 01:14:32,080
הפעם, אנחנו למטה עד 4 טעויות.

1406
01:14:32,080 --> 01:14:34,350
אז יש לנו אחד מהם.

1407
01:14:34,350 --> 01:14:36,130
בואו לעלות.

1408
01:14:36,130 --> 01:14:38,890
"מחרוזת" סוג שם לא צפוי: ביטוי צפוי, "כן?

1409
01:14:38,890 --> 01:14:41,780
>> כן, זה משום שניסיתי שם את המחרוזת.

1410
01:14:41,780 --> 01:14:44,270
כן, כך זה נראה כאילו אנחנו עכשיו גם צריכים ללכת לתקן

1411
01:14:44,270 --> 01:14:46,560
כל ההפניות הללו למחרוזת.

1412
01:14:46,560 --> 01:14:50,070
אתה יכול לראות שיש התייחסות למחרוזת כאן, כאן, כאן,

1413
01:14:50,070 --> 01:14:53,440
כדי שנוכל להעביר את כל אלה לשל.

1414
01:14:56,040 --> 01:15:00,930
גדול. אוקיי, להפעיל אותו שוב.

1415
01:15:00,930 --> 01:15:03,260
בניין - שגיאה אחרת התרחש.

1416
01:15:03,260 --> 01:15:06,900
>> אוקיי, עכשיו אנחנו למטה לשגיאה אחת,

1417
01:15:06,900 --> 01:15:11,090
כך אני int = s ולאחר מכן את הסוגריים המרובעים.

1418
01:15:11,090 --> 01:15:14,880
אז אתה יכול לספר לנו קצת על מה שאתה עושה כאן, קלי?

1419
01:15:14,880 --> 01:15:17,120
>> כן.

1420
01:15:17,120 --> 01:15:19,410
זה היה בקו 10.

1421
01:15:19,410 --> 01:15:22,760
>> אני לא יודע אם אנחנו צריכים את כל זה,

1422
01:15:22,760 --> 01:15:25,560
אבל אני חושב שאני מנסה -

1423
01:15:25,560 --> 01:15:27,580
אני אשמור את זה, כך שתוכל לבצע יחד.

1424
01:15:27,580 --> 01:15:30,470
>> אני חושב שהייתי

1425
01:15:30,470 --> 01:15:33,150
ניסיתי להגיד לו כדי להתחיל בעמדה 0

1426
01:15:33,150 --> 01:15:35,030
בתחילתי ללולאה,

1427
01:15:35,030 --> 01:15:38,370
לכן אני חושב שאולי זה אומר שאין צורך.

1428
01:15:39,690 --> 01:15:41,350
אז רק כדי לסכם,

1429
01:15:41,350 --> 01:15:44,850
היית אומר שזה - היית מנסה להתחיל עם זה בעמדה 0

1430
01:15:44,850 --> 01:15:47,030
ולקבל את זה - כן,

1431
01:15:47,030 --> 01:15:50,460
לכן אני חושב שקודם לכן, גם כשאתה היה חוצה את הקוד,

1432
01:15:50,460 --> 01:15:54,070
אתה מדבר על זה שאתה רצית להתייחס למחרוזת כמערך

1433
01:15:54,070 --> 01:15:57,440
כדי שנוכל לגשת לכל תו בנפרד.

1434
01:15:57,440 --> 01:16:00,660
אני חושב שדן מערכים הוזכרו גם מנסה להמיר מחרוזות למערכים.

1435
01:16:01,400 --> 01:16:03,300
>> מתברר מסוג זה מתחת למכסת המנוע,

1436
01:16:03,300 --> 01:16:06,060
מחרוזת מאוחסנת בפועל כמערך כבר,

1437
01:16:06,060 --> 01:16:08,060
ואתה יכול לגשת אליו כמו מערך;

1438
01:16:08,060 --> 01:16:12,390
אין מרה שאתה צריך לעשות.

1439
01:16:12,390 --> 01:16:15,770
אין מחרוזת - כך -

1440
01:16:15,770 --> 01:16:18,200
מחרוזת היא לא באמת מערך,

1441
01:16:18,200 --> 01:16:21,940
אבל אתה יכול לגשת אליו כאמור, כי כל הדמויות מאוחסנים

1442
01:16:21,940 --> 01:16:25,160
זכות אחד ליד שני בזיכרון,

1443
01:16:25,160 --> 01:16:28,310
כך שאם אתה רוצה לקבל את התו הראשון של המחרוזת,

1444
01:16:28,310 --> 01:16:31,910
זה אותו הדבר כמו מקבל המספר השלם הראשון במערך של מספרים שלמים.

1445
01:16:31,910 --> 01:16:35,010
אז אנחנו לעתים קרובות - אנחנו נטפל

1446
01:16:35,010 --> 01:16:36,360
מתייחס ל 2 כמו

1447
01:16:36,360 --> 01:16:38,590
הו, כמחרוזת, כמו להיות מערך,

1448
01:16:38,590 --> 01:16:40,830
למרות שזה באמת - הם נוראים דברים שונים מאוד,

1449
01:16:40,830 --> 01:16:43,410
אבל אתה יכול להתייחס אליהם מאוד דומה.

1450
01:16:44,700 --> 01:16:47,400
אז מתברר שזה ממש קו -

1451
01:16:47,400 --> 01:16:51,270
אנחנו לא צריכים לעשות שום מרה,

1452
01:16:51,270 --> 01:16:53,500
ולמעשה,

1453
01:16:53,500 --> 01:16:56,790
זה למעשה אינו ביטוי תקף,

1454
01:16:56,790 --> 01:16:59,040
וזה מה שהמהדר שלנו אומר לנו.

1455
01:16:59,040 --> 01:17:01,290
זה אומר, "היי, זה צפוי ביטוי,

1456
01:17:01,290 --> 01:17:04,610
ומה יש לי כאן משהו שלא ביטוי ".

1457
01:17:04,610 --> 01:17:07,310
כדי להצהיר על מערך,

1458
01:17:07,310 --> 01:17:11,780
כל מה שאתה צריך לעשות הוא משהו כמו זה בנקודת פסיק,

1459
01:17:11,780 --> 01:17:15,080
ואז אומרים לי המערך כמה זמן אתה רוצה שזה יהיה,

1460
01:17:15,080 --> 01:17:18,370
כמו 5, אז זה קו 10

1461
01:17:18,370 --> 01:17:23,880
יכריז מערך התקשרתי עם 5 מספרים שלמים בזה.

1462
01:17:23,880 --> 01:17:26,540
>> זה בצד, זה לא הכרחי לקוד,

1463
01:17:26,540 --> 01:17:30,970
אבל זה - זה סוג של מה שנראית כמו ההצהרה.

1464
01:17:30,970 --> 01:17:35,310
>> איך היית לא להשתמש בעוזרת ש[ strlen (s)]?

1465
01:17:35,310 --> 01:17:38,500
עוזרת ש[ strlen (s)]?

1466
01:17:38,500 --> 01:17:41,500
>> Char i, ואז בתוך הסוגריים, strlen (הים).

1467
01:17:43,900 --> 01:17:47,710
כן, ולכן אנחנו יכולים -

1468
01:17:47,710 --> 01:17:49,460
אנחנו יכולים לעשות את זה,

1469
01:17:49,460 --> 01:17:52,160
וזה יכריז - מה זה עושה?

1470
01:17:52,160 --> 01:17:55,900
>> אני חושב שזה יהיה להצהיר על מערך

1471
01:17:55,900 --> 01:18:01,780
של, כמו - של -

1472
01:18:01,780 --> 01:18:04,540
הו, אתה לא צריך אותי - הו,

1473
01:18:04,540 --> 01:18:06,420
כן, אתה בהחלט לא צריך אותי.

1474
01:18:06,420 --> 01:18:10,250
אתה מצהיר מערך של תווים

1475
01:18:10,250 --> 01:18:13,150
אורכו של הים.

1476
01:18:14,680 --> 01:18:16,770
ואז מה סם של אומרים זה ש

1477
01:18:16,770 --> 01:18:20,660
קו זה 10 - הניח לי קצת מרחב בינו לבין השאר ולכן אנחנו יכולים לבודד אותו -

1478
01:18:20,660 --> 01:18:23,440
קו 10 זה הייתי להצהיר על מערך

1479
01:18:23,440 --> 01:18:28,520
של תווים, strlen שווה (ים) שלהם,

1480
01:18:28,520 --> 01:18:32,270
אבל אנחנו ממש צריכים אותי,

1481
01:18:32,270 --> 01:18:35,710
והסיבה שאנחנו צריכים אותי, משום שאנו צריכים לתת למערך שם;

1482
01:18:35,710 --> 01:18:38,900
אחרת, לא תהיה לנו דרך להתייחס למערך מאוחר יותר בקוד.

1483
01:18:38,900 --> 01:18:41,180
>> אז עכשיו זה משהו ששם המערך

1484
01:18:41,180 --> 01:18:43,420
ובתוכו האורך.

1485
01:18:43,420 --> 01:18:45,010
זה ייתן לנו מערך,

1486
01:18:45,010 --> 01:18:47,430
אבל זה - שוב, זה הוא הצהרה.

1487
01:18:47,430 --> 01:18:50,380
זה לא משימה, זה לא אתחול.

1488
01:18:50,380 --> 01:18:52,330
אם תכריזו על מערך זה ככה,

1489
01:18:52,330 --> 01:18:54,490
יש בעצם שום דבר בתוכן של המערך.

1490
01:18:54,490 --> 01:18:57,490
זה פשוט זבל - מה שנמצא שם.

1491
01:18:57,490 --> 01:18:59,780
וכמו שאמרנו,

1492
01:18:59,780 --> 01:19:01,340
אנחנו למעשה אפילו לא צריכים לעשות מרה זו,

1493
01:19:01,340 --> 01:19:04,810
כי אנחנו כבר יכולים להתייחס למחרוזת של כמערך.

1494
01:19:06,750 --> 01:19:09,170
אני יודעת שאנחנו פועלים קצת ארוכים על זמן,

1495
01:19:09,170 --> 01:19:12,330
אבל אני רוצה להגיע רק לזה מהר מאוד ללולאה

1496
01:19:12,330 --> 01:19:14,850
ואראה לך איך לגשת לתווים הבודדים במערך,

1497
01:19:14,850 --> 01:19:17,170
כי זה מפתח למשימה שלנו.

1498
01:19:17,170 --> 01:19:20,790
ואז ניתן לך ללכת משם.

1499
01:19:20,790 --> 01:19:24,610
>> אז הנה, יש לנו ללולאה

1500
01:19:24,610 --> 01:19:28,310
זה נראה כמעט טוב.

1501
01:19:28,310 --> 01:19:30,960
מה לא ממש כמעט שם?

1502
01:19:30,960 --> 01:19:33,240
ממה - מה אינה כשורה בעניין הזה ללולאה?

1503
01:19:33,240 --> 01:19:36,010
>> אין סוגריים מסולסלים?

1504
01:19:36,010 --> 01:19:38,420
אין סוגריים מסולסלים, לאחד.

1505
01:19:38,420 --> 01:19:42,580
רוצה לוודא שיש לנו את הגוף של הלולאה עם סוגריים מסולסלים.

1506
01:19:42,580 --> 01:19:45,240
אופס, לא הסד המרובע!

1507
01:19:45,240 --> 01:19:48,660
ומהו הדבר הבא שאנחנו צריכים לעשות עם זה לולאה?

1508
01:19:48,660 --> 01:19:52,640
אם אני מנסה ולהפעיל אותו,

1509
01:19:52,640 --> 01:19:56,740
מה חדש השגיאה הזאת שאני מקבל?

1510
01:19:56,740 --> 01:20:00,990
אני מקבל את כל השגיאות הללו - אני צריך לאתחלי.

1511
01:20:00,990 --> 01:20:03,610
גדול.

1512
01:20:03,610 --> 01:20:05,770
אז זה יהיה לולאה - זה לא ממש שם,

1513
01:20:05,770 --> 01:20:08,680
אבל זה מתחיל להיות ממש קרוב.

1514
01:20:08,680 --> 01:20:11,260
קוד זה אנו יכולים כעת לרוץ,

1515
01:20:11,260 --> 01:20:14,620
לבנות, שגיאה עדיין מתרחשת.

1516
01:20:17,960 --> 01:20:19,800
למה הוא עדיין מתלונן,

1517
01:20:19,800 --> 01:20:22,030
אומר הביטוי הוא בשימוש,

1518
01:20:22,030 --> 01:20:24,600
וזה בגלל הקו הזה לא עושה כלום.

1519
01:20:24,600 --> 01:20:27,620
לא לאחסן אותו בכל מקום, אנחנו לא לשמור את התוצאה.

1520
01:20:27,620 --> 01:20:30,210
איפה אנחנו צריכים להיות להציל את התוצאה הזאת?

1521
01:20:30,210 --> 01:20:32,920
>> של או i?

1522
01:20:32,920 --> 01:20:35,990
בדיוק, והתחביר יוצא הדופן הזה,

1523
01:20:35,990 --> 01:20:38,550
של זה עם סוגריים המרובעים

1524
01:20:38,550 --> 01:20:41,500
הפירוש לגשת אופי i-ה של הים.

1525
01:20:41,500 --> 01:20:45,650
זה הולך להיות משהו שבאמת חשוב לתפקיד.

1526
01:20:45,650 --> 01:20:48,070
למרבה הצער, אנחנו הולכים צריכים להפסיק כאן,

1527
01:20:48,070 --> 01:20:50,550
כך שסעיף סבסטיאן יכול לבוא ב,

1528
01:20:50,550 --> 01:20:53,980
אבל אני שמח להישאר אחרי בחוץ ואקח אותך שאלות.

1529
01:20:53,980 --> 01:20:56,680
אז תודה שבאתם.

1530
01:20:56,680 --> 01:20:59,730
זה צריך עכשיו להעלות, לבנות, להפעיל.

1531
01:21:01,570 --> 01:21:04,320
אנחנו יכולים להיכנס למחרוזת כמו "שלום"

1532
01:21:06,570 --> 01:21:08,730
והוא מדפיס "QOX".

1533
01:21:08,730 --> 01:21:11,030
[שחוק]

1534
01:21:11,030 --> 01:21:14,640
>> אז לא ממש שם, אבל מרגש, מקבל כיוון הלולאות האלה!

1535
01:21:14,640 --> 01:21:18,640
תודה שבאת, ואני אהיה בחוץ.