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