1
00:00:00,000 --> 00:00:00,980

2
00:00:00,980 --> 00:00:04,410
>> [השמעת מוסיקה]

3
00:00:04,410 --> 00:00:11,147

4
00:00:11,147 --> 00:00:12,230
דוד י מלאן: בסדר.

5
00:00:12,230 --> 00:00:16,440
זה CS50, וזה
הוא סוף השבוע 2.

6
00:00:16,440 --> 00:00:18,480
אז היום, אנחנו הולכים
להמשיך המבט שלנו

7
00:00:18,480 --> 00:00:21,150
באופן בו אנו מייצגים דברים
מתחת hood-- מתרחק

8
00:00:21,150 --> 00:00:23,520
ממספרים כמו מספרים שלמים
וערכי נקודה צפה

9
00:00:23,520 --> 00:00:26,810
והתמקדות במחרוזות ו
תוכניות סופו של דבר יותר מעניינות.

10
00:00:26,810 --> 00:00:30,140
אבל אנחנו גם נסתכל על
כמה problems-- תחום ספציפי

11
00:00:30,140 --> 00:00:33,620
הראשון שבם יהיה
להיות מעורב קריפטוגרפיה,

12
00:00:33,620 --> 00:00:36,570
האמנות של ערבול מידע,
שבו אתה רואה לעיל כאן

13
00:00:36,570 --> 00:00:41,480
תמונה של רדיו אנני היתומה של
טבעת מפענח סוד מפעם.

14
00:00:41,480 --> 00:00:46,490
>> זהו למעשה צורה מאוד פרימיטיבית
וצורה ידידותית לילדים של cryptopgraphy

15
00:00:46,490 --> 00:00:50,590
לפי יש טבעת זו שתי disks--
בתוך אחד ואחד בחוץ.

16
00:00:50,590 --> 00:00:54,740
ועל ידי החלפה אחד מאותם, אתה יכול
בעצם בשורה אותיות כמו

17
00:00:54,740 --> 00:00:59,520
עד Z עם אותיות אחרות
כמו ב 'עד א' במילים אחרות,

18
00:00:59,520 --> 00:01:03,730
אתה ממש יכול לסובב את האלפבית,
ובכך מגיע עם מיפוי מ

19
00:01:03,730 --> 00:01:07,820
מכתבים למכתבים כך ש, אם אתה
רציתי לשלוח מסר סודי

20
00:01:07,820 --> 00:01:11,820
למישהו כמו אנני, אתה יכול לכתוב
את ההודעה שלך ולאחר מכן לסובב

21
00:01:11,820 --> 00:01:15,370
המכתבים, לפיה, אם אתה מתכוון
לומר "," לך במקום לומר "B,"

22
00:01:15,370 --> 00:01:17,280
אתה מתכוון לומר "B,"
אתה במקום לומר "C" -

23
00:01:17,280 --> 00:01:20,240
או משהו קצת יותר חכם
מ that-- ולאחר מכן, בסופו,

24
00:01:20,240 --> 00:01:24,630
כל עוד אנני יש מפענח זה
טבעת, היא יכולה לפענח את ההודעה.

25
00:01:24,630 --> 00:01:28,540
עכשיו, שאתם אולי זוכרים, למעשה, כי זה
היה בשימוש בסרט מפורסם מאוד ש

26
00:01:28,540 --> 00:01:31,140
nauseum מודעה משחק במהלך
עונת חג המולד.

27
00:01:31,140 --> 00:01:32,650
בואו נסתכל כאן.

28
00:01:32,650 --> 00:01:35,294

29
00:01:35,294 --> 00:01:37,210
ראלפי PARKER: "זה היה
ידוע לכל בסיכום

30
00:01:37,210 --> 00:01:41,000
שראלף פארקר מתמנה בזאת
חבר הקטן אנני הסוד יתום

31
00:01:41,000 --> 00:01:44,860
מעגל, והיא זכאי לכל
כיבודים והטבות המתרחשים לו. "

32
00:01:44,860 --> 00:01:47,410
>> ראלפי פארקר (מספרת):
חתמה היתומה הקטנה אנני.

33
00:01:47,410 --> 00:01:50,070
בתשובה, פייר אנדרה!

34
00:01:50,070 --> 00:01:51,490
בדיו.

35
00:01:51,490 --> 00:01:55,494
כיבודים והטבות,
כבר בגיל תשע.

36
00:01:55,494 --> 00:01:57,402
>> [השמעת מוסיקה]

37
00:01:57,402 --> 00:02:00,470
>> [ברבורים ברדיו]

38
00:02:00,470 --> 00:02:01,470
יאללה: ראלפי פרקר.

39
00:02:01,470 --> 00:02:02,344
בואו נגמור עם זה.

40
00:02:02,344 --> 00:02:06,029
אני לא צריך את כל הג'אז הזה
על מבריחים ופירטים.

41
00:02:06,029 --> 00:02:08,820
שדרן רדיו: תקשיב מחר
לילה להרפתקה המסכמת

42
00:02:08,820 --> 00:02:11,060
של שחור ספינת פיראטים.

43
00:02:11,060 --> 00:02:14,740
עכשיו, הגיע זמן לאנני של
מסר סודי בשבילך חברים

44
00:02:14,740 --> 00:02:17,110
של המעגל הסודי.

45
00:02:17,110 --> 00:02:20,700
זכור את הילדים, רק חברים
של המעגל הסודי של אנני

46
00:02:20,700 --> 00:02:23,270
יכול לפענח המסר הסודי של אנני.

47
00:02:23,270 --> 00:02:27,270
>> זכרו, אנני תלויה בך.

48
00:02:27,270 --> 00:02:30,060
הגדר הסיכות שלך לB-2.

49
00:02:30,060 --> 00:02:34,004
הנה 12 message--, 11, 2--

50
00:02:34,004 --> 00:02:36,503
ראלפי פארקר (מספרת): אני
אני בפגישה החשאית הראשונה שלי.

51
00:02:36,503 --> 00:02:40,041
שדרן רדיו: --25, 14, 11, 18, 16--

52
00:02:40,041 --> 00:02:42,790
ראלפי פארקר (מספרת): הו,
פייר היה בערב קול גדול.

53
00:02:42,790 --> 00:02:46,110
אני יכול לספר לי הלילה של ש
ההודעה הייתה באמת חשובה.

54
00:02:46,110 --> 00:02:47,930
>> שדרן רדיו: --3, 25.

55
00:02:47,930 --> 00:02:49,940
זה מסר מאנני את עצמה.

56
00:02:49,940 --> 00:02:52,182
זכור, לא לספר לאף אחד.

57
00:02:52,182 --> 00:02:55,077
>> [מתנשף]

58
00:02:55,077 --> 00:02:57,285
ראלפי פארקר (מספרת):
תשעים שניות מאוחר יותר, אני

59
00:02:57,285 --> 00:03:00,090
בחדר היחיד ב
בית שבו ילד בן תשע

60
00:03:00,090 --> 00:03:04,380
יכל לשבת בפרטיות ולפענח.

61
00:03:04,380 --> 00:03:04,990
אה.

62
00:03:04,990 --> 00:03:05,680
"ב '"

63
00:03:05,680 --> 00:03:06,524
>> [מגחך]

64
00:03:06,524 --> 00:03:08,684
>> ראלפי פארקר (מספרת):
הלכתי למקום הבא.

65
00:03:08,684 --> 00:03:09,610
"א '"

66
00:03:09,610 --> 00:03:11,641
המילה הראשונה היא "להיות".

67
00:03:11,641 --> 00:03:12,140
כן!

68
00:03:12,140 --> 00:03:14,293
זה היה הקרוב יותר קל עכשיו.

69
00:03:14,293 --> 00:03:15,259
"ע '"

70
00:03:15,259 --> 00:03:16,225
>> [מגחך]

71
00:03:16,225 --> 00:03:18,157
>> רנדי PARKER: אוי, בחיים, ראלפי.

72
00:03:18,157 --> 00:03:19,606
אני חייב ללכת!

73
00:03:19,606 --> 00:03:21,538
>> ראלפי PARKER: אני אהיה מימין למטה, מא.

74
00:03:21,538 --> 00:03:22,504
גאון גי.

75
00:03:22,504 --> 00:03:25,402

76
00:03:25,402 --> 00:03:31,220
"ט" "א '" "תהיה בטוח
ל. "" הקפד "מה?

77
00:03:31,220 --> 00:03:33,981
מה הייתה היתומה הקטנה אנני
מנסה לומר? "הקפד" מה?

78
00:03:33,981 --> 00:03:35,522
אמא: ראלפי, רנדי חייב ללכת.

79
00:03:35,522 --> 00:03:36,735
אתה מוכן בבקשה לצאת?

80
00:03:36,735 --> 00:03:38,190
>> ראלפי PARKER: בסדר, אמא!

81
00:03:38,190 --> 00:03:39,787
אני אהיה מחוץ נכון!

82
00:03:39,787 --> 00:03:41,995
ראלפי פארקר (מספרת):
אני מתקרב עכשיו.

83
00:03:41,995 --> 00:03:43,370
המתח היה נורא.

84
00:03:43,370 --> 00:03:44,794
מה זה היה?

85
00:03:44,794 --> 00:03:47,656
גורלו של כדור הארץ
עלול להיתקע במאזן.

86
00:03:47,656 --> 00:03:50,518
>> אמא: ראלפי, רנדי חייב ללכת!

87
00:03:50,518 --> 00:03:53,635
>> ראלפי PARKER: אני אהיה תקין
את, בוכה בקול רם!

88
00:03:53,635 --> 00:03:55,343
ראלפי PARKER
(מספרת): כמעט שם!

89
00:03:55,343 --> 00:03:56,520
האצבעות שלי טסו!

90
00:03:56,520 --> 00:03:58,500
המוח שלי היה מלכודת פלדה.

91
00:03:58,500 --> 00:03:59,850
כל נקבובית רטט.

92
00:03:59,850 --> 00:04:01,806
זה היה כמעט ברור!

93
00:04:01,806 --> 00:04:02,773
כן!

94
00:04:02,773 --> 00:04:03,273
כן!

95
00:04:03,273 --> 00:04:03,773
כן!

96
00:04:03,773 --> 00:04:04,740
כן!

97
00:04:04,740 --> 00:04:10,250
>> ראלפי PARKER: "תהיה בטוח
לשתות השוקו שלך. "

98
00:04:10,250 --> 00:04:10,750
שוקו?

99
00:04:10,750 --> 00:04:14,864

100
00:04:14,864 --> 00:04:17,539
מסחרי עלוב?

101
00:04:17,539 --> 00:04:19,439
>> [השמעת מוסיקה]

102
00:04:19,439 --> 00:04:21,724
>> ראלפי PARKER: יא בן זונה.

103
00:04:21,724 --> 00:04:23,460
>> [צוחק]

104
00:04:23,460 --> 00:04:27,070
>> דוד י מלאן: אז שלאחר מכן הוא
הצצה אל מה קריפטוגרפיה

105
00:04:27,070 --> 00:04:29,880
יכול להיות לזה-
לשתות מפעם.

106
00:04:29,880 --> 00:04:30,900
אז הודעה מהירה.

107
00:04:30,900 --> 00:04:33,410
אם אתה חופשי זה
יום שישי בשעה 1:15 והיית

108
00:04:33,410 --> 00:04:36,610
רוצה להצטרף אלינו לCS50
ארוחת צהריים, בראש לכתובת אתר זו כאן.

109
00:04:36,610 --> 00:04:38,080
במקום ראשון, ישמש ראשון כרגיל.

110
00:04:38,080 --> 00:04:41,840
אבל לאורך זמן, נדאג ש
רוב מי שרוצה להשתתף

111
00:04:41,840 --> 00:04:43,640
עשוי לקבוע חכם.

112
00:04:43,640 --> 00:04:45,170
>> אז מיתרים.

113
00:04:45,170 --> 00:04:47,940
יש לנו Zamyla--
עכשיו אתה כבר פגשת סביר ביותר

114
00:04:47,940 --> 00:04:50,750
בבעיה סט 1-- ש
שם מאוית כך.

115
00:04:50,750 --> 00:04:53,570
ונניח שהקלדת את שמה
לתוך תוכנת מחשב זה

116
00:04:53,570 --> 00:04:55,710
באמצעות משהו כמו getString.

117
00:04:55,710 --> 00:04:57,890
כדי לאחזר
הקשות האלה, איך

118
00:04:57,890 --> 00:05:01,620
אנחנו הולכים על ייצוג
מחרוזת, מילה, פיסקה,

119
00:05:01,620 --> 00:05:03,960
או מכתבים מרובים כמו כאן אלה?

120
00:05:03,960 --> 00:05:06,790
>> דברנו בפעם האחרונה על
מספרים שלמים ובעיות

121
00:05:06,790 --> 00:05:09,960
שעולה עם מעבר שלם
וערכי נקודה צפה

122
00:05:09,960 --> 00:05:12,190
ובעיות ש
להתעורר בתוך דיוק.

123
00:05:12,190 --> 00:05:16,080
עם מחרוזות, אנחנו לפחות
יש קצת יותר גמישות

124
00:05:16,080 --> 00:05:17,970
בגלל המייתרים: רק
בworld-- האמיתי

125
00:05:17,970 --> 00:05:19,790
יכול להיות באורך די שרירותי.

126
00:05:19,790 --> 00:05:21,055
די קצר, ארוך למדי.

127
00:05:21,055 --> 00:05:23,680
אבל גם אז, אנחנו הולכים
יגלה שלפעמים מחשבים יכולים

128
00:05:23,680 --> 00:05:27,200
נגמרים של זיכרון ואפילו לא
לאחסן מספיק מחרוזת גדולה.

129
00:05:27,200 --> 00:05:30,840
>> אבל לעת עתה, בואו נתחיל לדמיין
מחרוזת כמו משהו בקופסות אלה

130
00:05:30,840 --> 00:05:31,340
כאן.

131
00:05:31,340 --> 00:05:36,410
אז שש קופסות כאלה, כל אחד מהם
מייצג דמות או "char".

132
00:05:36,410 --> 00:05:40,646
אז תזכור, כי "char" - c-h--r-- הוא
אחד מסוגי הנתונים מובנים בג

133
00:05:40,646 --> 00:05:43,520
ומה נחמד הוא שאתה יכול להשתמש
כי סוג של כאבן בניין,

134
00:05:43,520 --> 00:05:47,880
פיסת הפאזל, אם תרצה, כדי ליצור
סוג גדול יותר של נתונים שאנחנו נמשיך

135
00:05:47,880 --> 00:05:49,410
לקרוא "מחרוזת".

136
00:05:49,410 --> 00:05:53,650
>> עכשיו, מה שימושי על חשיבה
על דברים כמו מחרוזות בדרך זו?

137
00:05:53,650 --> 00:05:57,720
ובכן, מתברר שאנחנו יכולים
למעשה למנף את המבנה הזה

138
00:05:57,720 --> 00:06:01,420
כדי לגשת למעשה תווים בודדים
בדרך די פשוטה.

139
00:06:01,420 --> 00:06:04,099
אני הולך קדימה וליצור
קובץ בשם "stringzero.c,"

140
00:06:04,099 --> 00:06:05,765
אבל אתה יכול לקרוא לזה איך שאתה רוצה.

141
00:06:05,765 --> 00:06:08,500
ובאתר האינטרנט של הקורס הוא
כבר דוגמא זו מראש,

142
00:06:08,500 --> 00:06:10,430
אז אתה לא צריך
הקלד את הכל.

143
00:06:10,430 --> 00:06:13,820
>> ואני הולך קדימה
ולעשות void main int הראשון.

144
00:06:13,820 --> 00:06:15,980
ותוך כמה ימים,
נתחיל להקניט בנפרד

145
00:06:15,980 --> 00:06:19,070
מה חלל הוא כאן, מדוע זה
int ליד ראשי, וכן הלאה.

146
00:06:19,070 --> 00:06:21,180
אבל לעת עתה, בואו נמשיך
ללהעתיק ולהדביק את זה.

147
00:06:21,180 --> 00:06:23,455
>> אני הולך להכריז על מחרוזת בשם ש.

148
00:06:23,455 --> 00:06:26,920
ואני הולך לחזור מ
GetString מה שהמשתמש ב.

149
00:06:26,920 --> 00:06:29,170
זה הולך להיות פשוט
תכנית, אין הוראות,

150
00:06:29,170 --> 00:06:31,336
אני רק הולך לעיוור
מצפה שהמשתמש יודע

151
00:06:31,336 --> 00:06:32,600
מה לעשות כדי לשמור את זה פשוט.

152
00:06:32,600 --> 00:06:34,220
>> ועכשיו אני הולך להיות ללולאה.

153
00:06:34,220 --> 00:06:37,450
ובתוך לולאת for שלי אני
הולך להיות int i מקבלת אפס.

154
00:06:37,450 --> 00:06:40,660
ואני הוא, שוב, רק אמנה,
משתנה מדד לספירה,

155
00:06:40,660 --> 00:06:42,350
אבל אני יכול לקרוא לזה מה שאני רוצה.

156
00:06:42,350 --> 00:06:46,275
אני הולך לעשות הוא אני פחות than-- גם
שמו של Zamyla הוא באורך של שש אותיות.

157
00:06:46,275 --> 00:06:48,150
אז אני הולך לקשה
כי קוד שם לעת עתה.

158
00:06:48,150 --> 00:06:49,730
>> ולאחר מכן אני ++.

159
00:06:49,730 --> 00:06:53,190
ועכשיו בתוך מתולתל אלה
פלטה אני הולך לעשות printf,

160
00:06:53,190 --> 00:06:55,460
ואני רוצה להדפיס אחד
אופי בכל פעם.

161
00:06:55,460 --> 00:06:58,227
אז אני הולך להשתמש% ג ל
אולי בפעם הראשונה.

162
00:06:58,227 --> 00:07:00,560
ולאחר מכן אני רוצה להדפיס כל
דמות בשורה הנפרדת.

163
00:07:00,560 --> 00:07:02,550
אז אני הולך לשים
קו נטוי מעט n יש.

164
00:07:02,550 --> 00:07:03,640
ציטוט לסגור.

165
00:07:03,640 --> 00:07:06,250
>> ועכשיו אני רוצה לעשות משהו כאן.

166
00:07:06,250 --> 00:07:10,610
אני רוצה להדפיס
מכתב ספציפי במחרוזת,

167
00:07:10,610 --> 00:07:13,670
ים, כמו שאני iterating
מאפס על עד שש.

168
00:07:13,670 --> 00:07:17,150
במילים אחרות, אני רוצה
להדפיס את אופי i'th של ים.

169
00:07:17,150 --> 00:07:18,420
עכשיו איך אני יכול לעשות את זה?

170
00:07:18,420 --> 00:07:21,550
>> ובכן הרבה כמו התיבות ב
ייצוג זה כאן,

171
00:07:21,550 --> 00:07:25,560
סוג של, להעלות את הרעיון של אגרוף
אותיות ב, אתה יכול לעשות את זה באופן דומה

172
00:07:25,560 --> 00:07:32,630
מבחינה תחבירית בC פשוט על ידי ציון,
אני רוצה להדפיס של של i'th אופי.

173
00:07:32,630 --> 00:07:35,640
שימוש בסוגריים מרובעים
על המקלדת של המחשב שלך

174
00:07:35,640 --> 00:07:38,910
שעל מקלדת ארה"ב
בדרך כלל מעל מפתח ההחזר.

175
00:07:38,910 --> 00:07:42,630
>> אז זה לא לגמרי בסדר
עדיין, כפי שאתה אולי שמת לב.

176
00:07:42,630 --> 00:07:44,780
אבל אני הולך לסוג של
באופן עיוור להתקדם כאן.

177
00:07:44,780 --> 00:07:47,020
ואני הולך לעשות לעשות מחרוזת 0.

178
00:07:47,020 --> 00:07:50,860
אבל לפני שאני עושה את זה, בואו תראו אם אנחנו
לא יכול לצפות כמה טעויות נפוצות.

179
00:07:50,860 --> 00:07:52,844
האם זה הולך לקמפל?

180
00:07:52,844 --> 00:07:54,510
לא, אני חסר חבורה שלמה של דברים.

181
00:07:54,510 --> 00:07:55,280
ספריות שמעתי.

182
00:07:55,280 --> 00:07:58,480
>> אז איזה כותרת קבצים
אולי אני רוצה להוסיף כאן?

183
00:07:58,480 --> 00:07:59,205
כן.

184
00:07:59,205 --> 00:08:01,580
>> קהל: אתה צריך
אני סטנדרטי / פלט [לא ברור]

185
00:08:01,580 --> 00:08:02,663
>> דוד י מלאן: מצוין.

186
00:08:02,663 --> 00:08:06,060
אז אני צריך קלט / פלט סטנדרטי. למה
מטרה לעשות אני רוצה I / O סטנדרטי?

187
00:08:06,060 --> 00:08:06,670
לprintf.

188
00:08:06,670 --> 00:08:09,220
אז להכליל את stdio.h.

189
00:08:09,220 --> 00:08:13,490
ואתה גם מציע שאני כולל
ספריית CS50 למה סיבה?

190
00:08:13,490 --> 00:08:14,650
יש מחרוזות.

191
00:08:14,650 --> 00:08:17,780
כך תוכל לראות מה
הספרייה של CS50 עושה

192
00:08:17,780 --> 00:08:19,260
כדי ליצור את הרעיון הזה של מחרוזת.

193
00:08:19,260 --> 00:08:21,930
אבל לעת עתה, אתה יכול פשוט חושב
על זה כעל סוג הנתונים בפועל.

194
00:08:21,930 --> 00:08:23,596
>> כך שנראה שניקה קצת.

195
00:08:23,596 --> 00:08:27,060
ועכשיו אני הולך קדימה
ואכן לעשות להפוך את המחרוזת 0.

196
00:08:27,060 --> 00:08:27,700
הידור.

197
00:08:27,700 --> 00:08:28,370
אז זה טוב.

198
00:08:28,370 --> 00:08:32,799
אז ./string0 תן לי להתקרב כל כך שאנחנו יכולים
לראות יותר מקרוב מה קורה.

199
00:08:32,799 --> 00:08:33,850
הזן.

200
00:08:33,850 --> 00:08:37,789
Z--M-Y-L-להיכנס.

201
00:08:37,789 --> 00:08:39,440
ואנחנו כבר הדפסנו לשמו של Zamyla.

202
00:08:39,440 --> 00:08:40,409
>> אז זה די טוב.

203
00:08:40,409 --> 00:08:43,220
אז עכשיו בואו נלך קדימה ו
להפעיל את התכנית שוב,

204
00:08:43,220 --> 00:08:45,659
ולהקליד את השם המלא של דייבן.

205
00:08:45,659 --> 00:08:46,450
הפתעה, הפתעה.

206
00:08:46,450 --> 00:08:48,021
הזן.

207
00:08:48,021 --> 00:08:48,520
הממ.

208
00:08:48,520 --> 00:08:51,750
לא הדפסנו ךייבן של
ראשון שמו מלא בצורה נכונה.

209
00:08:51,750 --> 00:08:54,250
עכשיו זה צריך להיות ברור ב
בדיעבד, בגלל מה,

210
00:08:54,250 --> 00:08:57,010
סוג של, החלטת עיצוב טפשה?

211
00:08:57,010 --> 00:08:59,590
>> כן, אני קשה מקודד
שש בתוכי ללולאה.

212
00:08:59,590 --> 00:09:01,610
עכשיו אני עשיתי את זה רק בגלל ש
ידעתי את שמו של Zamyla

213
00:09:01,610 --> 00:09:02,776
הולך להיות שש אותיות.

214
00:09:02,776 --> 00:09:04,720
אבל אין ספק שזה לא
פתרון כללי.

215
00:09:04,720 --> 00:09:07,720
אז מתברר שאנחנו יכולים דינמי
להבין את האורך של מחרוזת

216
00:09:07,720 --> 00:09:10,440
על ידי קריאת פונקציה שנקראת strlen.

217
00:09:10,440 --> 00:09:12,840
>> שוב, בכוונה
בשם בתמציתיות רק

218
00:09:12,840 --> 00:09:14,450
כדי לעשות את זה יותר נוח להקלדה.

219
00:09:14,450 --> 00:09:17,170
אבל זה שם נרדף ל
מקבל את האורך של מחרוזת.

220
00:09:17,170 --> 00:09:23,190
אני הולך לחזור למסוף שלי
חלון מחדש להפעיל את המהדר.

221
00:09:23,190 --> 00:09:24,170
אבל זה לצעוק עליי.

222
00:09:24,170 --> 00:09:29,130
במרומז הכרזת פונקצית ספרייה
strlen עם סוג שאינו חתום int const--

223
00:09:29,130 --> 00:09:29,780
אני אבוד.

224
00:09:29,780 --> 00:09:30,590
לחלוטין.

225
00:09:30,590 --> 00:09:32,940
>> אז, במיוחד כמו שלך
עיניים מתחילות מזדגגות

226
00:09:32,940 --> 00:09:36,000
עם הודעות שגיאה כמו זו, מוקד
בכנות על כמה המילים הראשונות.

227
00:09:36,000 --> 00:09:38,590
אנחנו יודעים שהבעיה היא ב
קו 8, כפי שצוין כאן.

228
00:09:38,590 --> 00:09:40,500
וזה במחרוזת-0.c.

229
00:09:40,500 --> 00:09:43,580
במרומז הכרזה
פונקצית ספריית strlen.

230
00:09:43,580 --> 00:09:47,000
כך שבדרך כלל הולכים
להיות דפוס של הודעות שגיאה.

231
00:09:47,000 --> 00:09:49,190
במובלע שהכריז משהו.

232
00:09:49,190 --> 00:09:53,250
>> אז בקיצור, מה שיש לי נראה ש
עשה ביחס לקו 8, כאן.

233
00:09:53,250 --> 00:09:56,880
מה יכול להיות הפתרון להיות אפילו
אם מעולם לא השתמשו strlen את עצמך?

234
00:09:56,880 --> 00:09:58,907
>> קהל: חלק מספרייה אחרת?

235
00:09:58,907 --> 00:10:00,740
דוד י מלאן: חלק
של ספרייה שונה.

236
00:10:00,740 --> 00:10:02,400
אז הוא הצהיר, כביכול.

237
00:10:02,400 --> 00:10:07,510
היא מוזכרת בכמה קובץ
מלבד stdio.h וCS50.h.

238
00:10:07,510 --> 00:10:09,179
עכשיו שבו הוא מוגדר?

239
00:10:09,179 --> 00:10:12,220
אם להיות כנה, אתה גם צריך רק
יודע שזה את החלק העליון של הראש שלך,

240
00:10:12,220 --> 00:10:13,640
או שאתה בגוגל ולגלות.

241
00:10:13,640 --> 00:10:18,150
או יודע את זה, אני כבר פתחתי בCS50
מכשיר תכנית המסוף, ש

242
00:10:18,150 --> 00:10:22,200
רק הגרסה של גדולה, מסך מלא
מה שבתחתית החלון של gedit.

243
00:10:22,200 --> 00:10:24,970
>> ומתברר שיש
הפקודה דומה תמציתית, הנקראת

244
00:10:24,970 --> 00:10:29,280
אדם לידני, שבו אם אתה מקליד ב
השם של פונקציה וקש Enter,

245
00:10:29,280 --> 00:10:32,240
אתה תחזרי למדי
תיעוד מסתורי.

246
00:10:32,240 --> 00:10:35,299
זה פשוט טקסט שבדרך כלל
נראה קצת משהו כזה.

247
00:10:35,299 --> 00:10:37,090
זה קצת מוחץ
במבט ראשון.

248
00:10:37,090 --> 00:10:39,048
אבל בכנות, אני הולך
הניח לעיניי לזגג מעל

249
00:10:39,048 --> 00:10:41,930
ולהתמקד רק בחלק
אכפת לי לרגע.

250
00:10:41,930 --> 00:10:42,780
>> איזו היא זו.

251
00:10:42,780 --> 00:10:45,470
שנראה מבחינה מבנית כמו
משהו שאני מכיר.

252
00:10:45,470 --> 00:10:48,080
אכן דף האדם, כך
לדבר, יגיד לך

253
00:10:48,080 --> 00:10:51,590
במה שכותרת להגיש פונקציה
כמו strlen מוגדר.

254
00:10:51,590 --> 00:10:54,170
אז אני הולך לחזור עכשיו לgedit.

255
00:10:54,170 --> 00:10:59,070
ואני הולך קדימה,
להוסיף בכאן #include

256
00:10:59,070 --> 00:11:00,480
ולשמור את הקובץ.

257
00:11:00,480 --> 00:11:04,300
>> אני הולך לנקות את המסך עם
L שליטה אם אתה כבר תוהה.

258
00:11:04,300 --> 00:11:08,210
ואני הולך להפעיל מחדש איפור
string.0, הידור זה זמן.

259
00:11:08,210 --> 00:11:11,790
./string.0 Zamyla.

260
00:11:11,790 --> 00:11:15,020
זה נראה לעבוד תן לי ללכת
קדימה ולהפעיל מחדש את זה עם דבנפורט.

261
00:11:15,020 --> 00:11:15,860
הזן.

262
00:11:15,860 --> 00:11:17,730
וזה, יותר מדי, נראה לעבוד.

263
00:11:17,730 --> 00:11:21,220
>> אז אנחנו יכולים לעשות קצת יותר טוב מזה,
אם כי, אנחנו יכולים להתחיל לדברים מסודרים

264
00:11:21,220 --> 00:11:23,257
עד קצת.

265
00:11:23,257 --> 00:11:25,590
ואני הולך בעצם
להציג דבר אחד אחר עכשיו.

266
00:11:25,590 --> 00:11:28,930
אני הולך קדימה,
להציל את זה בקובץ אחר.

267
00:11:28,930 --> 00:11:31,770
ואני הולך לקרוא
string1.c קובץ זה פשוט

268
00:11:31,770 --> 00:11:34,620
להיות עקבי עם הקוד
תוכל למצוא באינטרנט.

269
00:11:34,620 --> 00:11:37,050
>> ובואו נתמקד ב
בדיוק באותו הקוד.

270
00:11:37,050 --> 00:11:39,000
מתברר שיש לי
היה סוג של לקיחה

271
00:11:39,000 --> 00:11:42,600
כמובן מאליו את העובדה שהמחשב הנייד שלי,
בתורו, את מכשיר CS50

272
00:11:42,600 --> 00:11:47,450
יש לו הרבה זיכרון, הרבה
זיכרון RAM, הרבה בתים של שטח

273
00:11:47,450 --> 00:11:48,920
שבו אני יכול לאחסן מחרוזות.

274
00:11:48,920 --> 00:11:53,560
>> אבל המציאות אם הקלדתי ארוכה
מספיק, ומספיק הקשות,

275
00:11:53,560 --> 00:11:56,170
אני יכול בסוג התאוריה
בתווים נוספים

276
00:11:56,170 --> 00:11:58,830
מהמחשב שלי
יש פיזי זיכרון ל.

277
00:11:58,830 --> 00:11:59,830
וזה בעייתי.

278
00:11:59,830 --> 00:12:03,050
בדומה int יכול רק
לספור כל כך גבוה, בתאוריה,

279
00:12:03,050 --> 00:12:06,600
אתה יכול רק לדחוס כל כך הרבה דמויות
לזכרון RAM של המחשב שלך או אקראי

280
00:12:06,600 --> 00:12:07,920
גישה לזיכרון.

281
00:12:07,920 --> 00:12:11,140
>> לכן כדאי שצופה
בעיה, זה אפילו

282
00:12:11,140 --> 00:12:13,660
למרות שזה יכול להיות נדיר
מקרה פינה, אם אפשר לומר כך.

283
00:12:13,660 --> 00:12:15,670
לא קורה, כי לעתים קרובות, יכול לקרות.

284
00:12:15,670 --> 00:12:18,815
ואם זה קורה ואני לא
צופה ותכנית לזה,

285
00:12:18,815 --> 00:12:20,300
התכנית שלי יכולה לעשות מי יודע מה.

286
00:12:20,300 --> 00:12:22,220
להקפיא, לתלות, אתחול מחדש, לא משנה מה.

287
00:12:22,220 --> 00:12:24,490
משהו צפוי שעלולים לקרות.

288
00:12:24,490 --> 00:12:27,120
>> אז מה שאני הולך לעשות
עכשיו, מכאן ואילך באמת,

289
00:12:27,120 --> 00:12:31,630
הוא לפני שאי פעם באופן עיוור
להשתמש משתנה כמו של ש

290
00:12:31,630 --> 00:12:36,790
הוקצה ערך ההחזרה של
תפקיד אחר כמו getstring,

291
00:12:36,790 --> 00:12:40,200
אני הולך לוודא
שהערך שלה הוא בתוקף.

292
00:12:40,200 --> 00:12:44,280
אז אני יודע רק שמקראתי
התיעוד של CS50 לgetstring,

293
00:12:44,280 --> 00:12:49,020
שסופו של דבר אנחנו נצביע עליך,
getstring שחוזר סמל מיוחד

294
00:12:49,020 --> 00:12:53,610
נקרא, N-U-L-L NULL בכל
כובעים, אם משהו משתבש.

295
00:12:53,610 --> 00:12:55,650
>> אז בדרך כלל, זה מחזיר מחרוזת.

296
00:12:55,650 --> 00:12:59,700
אבל חוץ מזה, אם הוא חוזר N-U-L-L--
אנו סופו של דבר תראו מה שבאמת

297
00:12:59,700 --> 00:13:01,790
means-- שרק אמצעי
קרה משהו רע.

298
00:13:01,790 --> 00:13:05,560
עכשיו זה אומר, ממש כמו בגרד,
אני יכול לבדוק את מצב כאן בC,

299
00:13:05,560 --> 00:13:08,830
אם ים לא NULL שווה.

300
00:13:08,830 --> 00:13:11,930
אז אם כבר אתה לא ראית את זה קודם,
זה רק אומר שאינו שווה.

301
00:13:11,930 --> 00:13:15,290
>> אז זה ההפך של
שווה שווה, אשר, כזכור,

302
00:13:15,290 --> 00:13:18,940
שונה מאחד
שווה, אשר היא משימה.

303
00:13:18,940 --> 00:13:23,030
אז אם של אינו שווה
NULL, רק אז

304
00:13:23,030 --> 00:13:25,980
אני רוצה לבצע שורות הקוד הללו.

305
00:13:25,980 --> 00:13:28,080
אז במילים אחרות,
לפני שאני צולל באופן עיוור

306
00:13:28,080 --> 00:13:30,919
ולהתחיל iterating
מעל ים, וטיפול בו

307
00:13:30,919 --> 00:13:33,710
כאילו זה הוא רצף של
דמויות, אני הולך קודם לבדוק,

308
00:13:33,710 --> 00:13:37,900
חכה רגע, הוא בהחלט לא
שווה לערך מיוחד זה, NULL?

309
00:13:37,900 --> 00:13:40,030
>> כי אם כן, דברים רעים יכולים לקרות.

310
00:13:40,030 --> 00:13:43,080
ועכשיו, תניח דברים שרעים
קורים פירושו קריסות התכנית שלך,

311
00:13:43,080 --> 00:13:45,070
ואתה לא יכול לשחזר בהכרח.

312
00:13:45,070 --> 00:13:46,800
אז בכנות, זה נראה מכוער.

313
00:13:46,800 --> 00:13:48,660
זה סוג של מבלבל עכשיו במבט חטוף ב.

314
00:13:48,660 --> 00:13:50,780
אבל זה יהיה יותר
מוכר לפני זמן רב.

315
00:13:50,780 --> 00:13:52,920
>> אבל אני הולך להציע
עכשיו שיפור אחד אחר.

316
00:13:52,920 --> 00:13:54,660
זה שיפור לתקינות.

317
00:13:54,660 --> 00:13:58,800
התכנית שלי היא עכשיו נכונה יותר, משום ש
במקרה הנדיר שאין מספיק זיכרון

318
00:13:58,800 --> 00:14:01,180
קיים, אני אטפל בזה,
ואני רק לא לעשות כלום.

319
00:14:01,180 --> 00:14:02,680
אני לפחות לא לקרוס.

320
00:14:02,680 --> 00:14:05,000
>> אבל בואו נעשה את הגרסה סופית כאן.

321
00:14:05,000 --> 00:14:07,690
וקובץ שנקרא string2.c.

322
00:14:07,690 --> 00:14:10,190
אני הולך להדביק ש
אותו קוד רק לרגע,

323
00:14:10,190 --> 00:14:14,210
ואני הולך כדי להדגיש את זה
קו, 11, כאן, רק לרגע.

324
00:14:14,210 --> 00:14:18,179
עכשיו המציאות היא שמהדרים חכמים
כמו קלאנג יכול לתקן את זה בשבילנו

325
00:14:18,179 --> 00:14:19,970
מאחורי הקלעים
מבלי שלנו בידיעה.

326
00:14:19,970 --> 00:14:24,670
אבל בואו נחשוב על זה
ביסודו כעיצוב בעייתי.

327
00:14:24,670 --> 00:14:29,010
>> קו זה של קוד הוא, כמובן,
אומר, לאתחל כמה משתנה i ל0.

328
00:14:29,010 --> 00:14:30,260
זה די פשוט.

329
00:14:30,260 --> 00:14:34,691
ומה הוא שוב זה
אמירה, כאן, אני ++, עושה?

330
00:14:34,691 --> 00:14:37,066
אנחנו ראינו את זה לפני, אבל אנחנו
לא ממש מדבר על זה.

331
00:14:37,066 --> 00:14:37,900
>> קהל: להגדיל כל i.

332
00:14:37,900 --> 00:14:39,191
>> דוד י מלאן: i להגדיל כל.

333
00:14:39,191 --> 00:14:41,890
אז בכל איטרציה דרך
לולאה זו, בכל מחזור,

334
00:14:41,890 --> 00:14:43,570
אתה להגדיל כל i על ידי אחד.

335
00:14:43,570 --> 00:14:45,740
אז זה נעשה גדול יותר, וגדול יותר, ו
גדול עד הלולאה מסתיימת.

336
00:14:45,740 --> 00:14:46,810
איך זה לסיים?

337
00:14:46,810 --> 00:14:49,430
ובכן יש אמצע זה
מצב שבו אנו כבר השתמשנו בעבר.

338
00:14:49,430 --> 00:14:52,500
ראית וב
ערוצים בסט P.

339
00:14:52,500 --> 00:14:53,880
>> אבל מה זה אומר?

340
00:14:53,880 --> 00:14:58,352
האם הלולאה הבאה כך
עוד הוא אני פחות ממה?

341
00:14:58,352 --> 00:14:59,810
קהל: האורך של המחרוזת.

342
00:14:59,810 --> 00:15:01,518
דוד י מלאן:
אורך של המחרוזת.

343
00:15:01,518 --> 00:15:04,300
אז זה מתרגם די נקי
לאנגלית במובן זה.

344
00:15:04,300 --> 00:15:08,810
עכשיו הבעיה היא שכל זמן אני
לחזר דרך לולאה זה בתאוריה,

345
00:15:08,810 --> 00:15:10,000
אני שואל את השאלה הזאת.

346
00:15:10,000 --> 00:15:12,250
האם אני פחות מאורך המחרוזת של ים?

347
00:15:12,250 --> 00:15:14,500
האם אני פחות מאורך המחרוזת של ים?

348
00:15:14,500 --> 00:15:18,380
>> עכשיו הוא שאני משתנה בכל איטרציה?

349
00:15:18,380 --> 00:15:18,880
זה.

350
00:15:18,880 --> 00:15:19,629
בגלל ++.

351
00:15:19,629 --> 00:15:21,700
אז כל איטרציה אני נעשה גדול יותר.

352
00:15:21,700 --> 00:15:25,411
אבל האם זה נעשה גדול יותר, או
קטן יותר, או שינוי בכלל?

353
00:15:25,411 --> 00:15:25,910
מס '

354
00:15:25,910 --> 00:15:30,240
אז במונחים של עיצוב, אחד מהצירים
שלאורכו אנו מנסים להעריך קוד

355
00:15:30,240 --> 00:15:32,610
בכיתה, זה מרגיש סוג של טיפשים.

356
00:15:32,610 --> 00:15:34,690
>> כמוך, פשוטו כמשמעו,
בכל איטרציה

357
00:15:34,690 --> 00:15:37,110
של לולאה זה שואל
אותה שאלה ארורה שוב,

358
00:15:37,110 --> 00:15:40,770
ושוב, ושוב, ופשוטו כמשמעו
זה לא הולך להשתנות.

359
00:15:40,770 --> 00:15:44,220
לפחות אם אני לא נוגע בים ו
מנסה לשנות את תוכנו של ים.

360
00:15:44,220 --> 00:15:46,610
אז אני יכול לעשות קצת יותר טוב מזה.

361
00:15:46,610 --> 00:15:49,530
>> ומה שאני הולך לעשות הוא לא
להכריז רק אחד אני משתנה,

362
00:15:49,530 --> 00:15:53,330
אבל משתנה שני אני באופן שרירותי ימצא,
אבל כמקובל, קורא לזה n.

363
00:15:53,330 --> 00:15:55,940
הקצאת n שווה ל
אורך מחרוזת של s.

364
00:15:55,940 --> 00:15:59,090
ולאחר מכן לכאן, אני הולך
לעשות אופטימיזציה קטנה וחכמה, כל כך

365
00:15:59,090 --> 00:16:03,460
לדבר, כי בסופו של היום
הוא לא יותר נכון או לא פחות נכון

366
00:16:03,460 --> 00:16:04,260
יותר מאשר בעבר.

367
00:16:04,260 --> 00:16:05,500
אבל זה עיצוב טוב יותר.

368
00:16:05,500 --> 00:16:09,480
בעובדה שאני משתמש
פחות זמן, מחזורי CPU פחות, כך

369
00:16:09,480 --> 00:16:14,040
לדבר, לענות אותו
שאלה, אבל רק פעם אחת.

370
00:16:14,040 --> 00:16:17,870
>> כל שאלות באופן כללי ש
עיקרון של שיפור,

371
00:16:17,870 --> 00:16:21,294
אומר, היעילות של תכנית?

372
00:16:21,294 --> 00:16:21,991
כן?

373
00:16:21,991 --> 00:16:23,699
קהל: למה אתה
להשתמש ב[ לא ברור]?

374
00:16:23,699 --> 00:16:25,760

375
00:16:25,760 --> 00:16:27,010
דוד י מלאן: שאלה טובה.

376
00:16:27,010 --> 00:16:30,690
אז למה אנחנו שמים את ++ על הקצה
אני במקום תחילת i?

377
00:16:30,690 --> 00:16:33,070
במקרה זה, יש לו
אין השפעה תפקודית.

378
00:16:33,070 --> 00:16:36,670
ובאופן כללי, אני נוטה
להשתמש במפעיל postfix

379
00:16:36,670 --> 00:16:41,750
כך שזה קצת יותר ברור
כאשר הפעולה שקורה.

380
00:16:41,750 --> 00:16:46,670
>> עבור לא מוכר אלו, יש עוד
הצהרות שבו אתה יכול לעשות ++ i.

381
00:16:46,670 --> 00:16:48,747
אלה הם פונקציונלי
שווה ערך במקרה זה

382
00:16:48,747 --> 00:16:51,080
כי אין שום דבר אחר
סביב incrementation ש.

383
00:16:51,080 --> 00:16:54,435
אבל אתה יכול לבוא עם
מקרים ושורות קוד

384
00:16:54,435 --> 00:16:55,810
שבו שעושה את הבדל.

385
00:16:55,810 --> 00:16:57,810
אז בדרך כלל, אנחנו עושים לא
אפילו לדבר על זה.

386
00:16:57,810 --> 00:17:00,690
כי למען האמת, זה גורם לך
סקסי קוד, וסוג של מעיל גשם,

387
00:17:00,690 --> 00:17:01,776
ומספר קטן של תווים.

388
00:17:01,776 --> 00:17:04,859
אבל המציאות היא שזה הרבה יותר קשה,
אני חושב, אפילו בשבילי לעטוף את דעתי

389
00:17:04,859 --> 00:17:07,319
סביבו לפעמים,
את סדר פעולות.

390
00:17:07,319 --> 00:17:09,750
אז כמו בצד, אם אתה
ממש לא אוהב את זה,

391
00:17:09,750 --> 00:17:14,650
למרות שזה סוג של סקסי
מחפש, אתה יכול גם לעשות i + = 1,

392
00:17:14,650 --> 00:17:18,880
המהווה את הגרסה מכוערת יותר של
אותו רעיון לincrementation postfix.

393
00:17:18,880 --> 00:17:22,250
>> אני אומר את זה ואתה
צריך לצחוק על זה,

394
00:17:22,250 --> 00:17:25,140
אבל אתה תבוא לראות את הקוד כ
משהו יפה לפני זמן רב.

395
00:17:25,140 --> 00:17:27,160
>> [שחוק]

396
00:17:27,160 --> 00:17:28,410
>> דוד י מלאן: מימין?

397
00:17:28,410 --> 00:17:29,360
כן.

398
00:17:29,360 --> 00:17:30,480
שאלה באמצע.

399
00:17:30,480 --> 00:17:32,146
>> קהל: האם אתה צריך להגיד n int?

400
00:17:32,146 --> 00:17:34,020
דוד י מלאן: אתה עושה
לא צריך להגיד n int.

401
00:17:34,020 --> 00:17:37,670
אז בגלל שכבר אמרו int,
אתה לא צריך להגיד את זה שוב.

402
00:17:37,670 --> 00:17:41,820
המלכוד הוא שn יש
להיות אותו סוג נתונים כפי שאני.

403
00:17:41,820 --> 00:17:43,310
אז זה רק נוחות כאן.

404
00:17:43,310 --> 00:17:44,058
כן.

405
00:17:44,058 --> 00:17:47,806
>> קהל: אתה יכול לעבור על
אופי של הדפסת סוגר אני שוב?

406
00:17:47,806 --> 00:17:48,930
דוד י מלאן: בהחלט.

407
00:17:48,930 --> 00:17:52,110
אז% ג, זוכר מאחרון
הזמן, הוא רק מציין.

408
00:17:52,110 --> 00:17:53,930
זה אומר לשים char כאן.

409
00:17:53,930 --> 00:17:56,780
n הקו הנטוי, כמובן, רק
אמצעים לשים מעבר שורה כאן.

410
00:17:56,780 --> 00:17:59,540
אז זה משאיר רק, עכשיו,
זה חתיכת התחביר חדש.

411
00:17:59,540 --> 00:18:03,730
וזה, פשוטו כמשמעו, ואמר, לתפוס
נקראת את המחרוזת של וללכת לקבלו

412
00:18:03,730 --> 00:18:06,050
אופי i'th, אם אפשר לומר כך.

413
00:18:06,050 --> 00:18:10,590
>> ואני חוזר ואומר אופי i'th
כי בכל איטרציה של לולאה זה

414
00:18:10,590 --> 00:18:14,540
זה כאילו שאנחנו מדפיסים
את, סוגר של ראשון 0,

415
00:18:14,540 --> 00:18:15,780
כמתכנת יכולה להגיד.

416
00:18:15,780 --> 00:18:18,680
אז זה סוגר 1, ולאחר מכן s
סוגר 2, ואז 3, ולאחר מכן 4.

417
00:18:18,680 --> 00:18:21,610
אבל כמובן שזה משתנה,
אז אני פשוט לבטא את זה עם i.

418
00:18:21,610 --> 00:18:23,900
>> מפתח, אם כי, הוא להבין,
במיוחד אם יש לך לא

419
00:18:23,900 --> 00:18:26,358
כבר הסתגלות לעולם הזה
של תכנות, שבו כולנו

420
00:18:26,358 --> 00:18:28,950
נראה לספור מאפס, צריך
מתחיל לספור מאפס עכשיו.

421
00:18:28,950 --> 00:18:35,130
בגלל מיתרים, תו ראשון,
z בZamyla הוא לטוב או לרע

422
00:18:35,130 --> 00:18:40,490
הולך לחיות במספר מיקום אפס.

423
00:18:40,490 --> 00:18:48,210
>> בסדר, אז תנו לי להביא
אותנו בחזרה לכאן כדי Zamyla

424
00:18:48,210 --> 00:18:50,746
ולראות מה באמת קורה
על מתחת למכסת המנוע.

425
00:18:50,746 --> 00:18:52,370
אז יש את הרעיון הזה של יציקת סוג.

426
00:18:52,370 --> 00:18:53,800
ייתכן שבאמת יש להם
שיחקתי עם זה כבר,

427
00:18:53,800 --> 00:18:55,970
אולי להאקר
מהדורה של P להגדיר אחד.

428
00:18:55,970 --> 00:19:00,320
אבל ליהוק סוג פשוט מתייחס ל
היכולת בC וכמה שפות אחרות

429
00:19:00,320 --> 00:19:03,170
להמיר סוג נתונים אחד למשנהו.

430
00:19:03,170 --> 00:19:05,450
>> עכשיו איך אנחנו יכולים לראות את זה
די בצורה ישירה?

431
00:19:05,450 --> 00:19:08,530
אז זה, כזכור, היא תחילתו
של האלפבית האנגלי.

432
00:19:08,530 --> 00:19:11,265
וההקשר, כזכור, מ
כמו לפני שבוע הוא ASCII.

433
00:19:11,265 --> 00:19:13,790
התקן האמריקאי הקוד
למידע מחלף.

434
00:19:13,790 --> 00:19:17,080
וזה רק באמת דרך ארוכה
לומר מיפוי מאותיות

435
00:19:17,080 --> 00:19:19,370
למספרים, וממספרים לאותיות.

436
00:19:19,370 --> 00:19:22,940
>> אז דרך M כאן, נקודת נקודה
נקודה, שורות עם, כזכור,

437
00:19:22,940 --> 00:19:25,582
המספר העשרוני 65 בעד.

438
00:19:25,582 --> 00:19:27,290
ואנחנו לא מדברים
על זה באופן מפורש,

439
00:19:27,290 --> 00:19:29,850
אבל אין ספק שיש דומה
מספרים לאותיות קטנות.

440
00:19:29,850 --> 00:19:30,820
ואכן, יש.

441
00:19:30,820 --> 00:19:33,730
העולם החליט כמה שנים
לפני שקטן, אותיות קטנות,

442
00:19:33,730 --> 00:19:35,020
הולך להיות 97.

443
00:19:35,020 --> 00:19:38,010
וb הקטנה הולכת
להיות 98, וכן הלאה.

444
00:19:38,010 --> 00:19:40,200
>> ועבור כל מקש אחר על
המקלדת שלך, יש

445
00:19:40,200 --> 00:19:42,190
הולך להיות דפוס דומה של ביטים.

446
00:19:42,190 --> 00:19:44,540
או באופן שקול, מספר עשרוני.

447
00:19:44,540 --> 00:19:47,110
אז השאלה שעל פרק,
לאחר מכן, יכולים הוא איך אנחנו

448
00:19:47,110 --> 00:19:49,400
למעשה רואה את זה מתחת למכסת המנוע?

449
00:19:49,400 --> 00:19:51,539
אז אני הולך לעבור לgedit שוב.

450
00:19:51,539 --> 00:19:53,330
ולא סוג
זה אחד מהתחלה,

451
00:19:53,330 --> 00:19:55,330
אני הולך קדימה,
רק לפתוח משהו

452
00:19:55,330 --> 00:19:58,350
מהקוד של היום נקרא ASCII אפס.

453
00:19:58,350 --> 00:20:01,210
>> וASCII אפס נראה כך.

454
00:20:01,210 --> 00:20:02,710
אז בואו לעטוף את דעתנו לעקוף את זה.

455
00:20:02,710 --> 00:20:04,969
אז קודם כל, אני כבר הגיב
הקוד, וזה נחמד.

456
00:20:04,969 --> 00:20:07,010
כי זה ממש
אומר לי למה לצפות,

457
00:20:07,010 --> 00:20:08,950
להציג מיפוי לאותיות רישיות.

458
00:20:08,950 --> 00:20:13,690
עכשיו אני לא ממש יודע למה אני
מתכוון, אז בואו להסיק.

459
00:20:13,690 --> 00:20:16,870
>> באנגלית, אולי
אנגלית טכנאי במידה מסוימת,

460
00:20:16,870 --> 00:20:20,660
מה עושה שורת 18 מופיעים
להיות עושה לנו?

461
00:20:20,660 --> 00:20:21,500
רק שורת 18.

462
00:20:21,500 --> 00:20:22,430
מה זה ישכנע?

463
00:20:22,430 --> 00:20:25,192
מה זה הולך לבעוט את כאן?

464
00:20:25,192 --> 00:20:26,100
>> קהל: לולאה.

465
00:20:26,100 --> 00:20:26,630
>> דוד י מלאן: לולאה.

466
00:20:26,630 --> 00:20:28,463
וכמה פעמים היא
שהולך לחזר?

467
00:20:28,463 --> 00:20:31,562

468
00:20:31,562 --> 00:20:33,270
קהל: [חציצת קולות]
שש פעמים.

469
00:20:33,270 --> 00:20:34,830
דוד י מלאן: לא שש פעמים.

470
00:20:34,830 --> 00:20:35,840
קהל: 26 פעמים.

471
00:20:35,840 --> 00:20:36,560
דוד י מלאן: 26 פעמים.

472
00:20:36,560 --> 00:20:37,060
כן, מצטער.

473
00:20:37,060 --> 00:20:37,960
26 פעמים.

474
00:20:37,960 --> 00:20:38,460
למה?

475
00:20:38,460 --> 00:20:41,590
ובכן, זה קצת מוזר, אבל
אני כבר התחלתי לספור מ65.

476
00:20:41,590 --> 00:20:43,300
וזה מוזר, אבל לא רע.

477
00:20:43,300 --> 00:20:44,610
זה לא רע לכל אומר.

478
00:20:44,610 --> 00:20:46,980
ואני עושה את זה רק
כי, לדוגמא זו,

479
00:20:46,980 --> 00:20:50,455
אני די מצפה
הון שהיה 65.

480
00:20:50,455 --> 00:20:53,330
עכשיו זה לא אלגנטי ביותר
דרך לעשות זאת, לסוג של קוד קשה

481
00:20:53,330 --> 00:20:56,130
ערכים אזוטריים שאף אחד לא
אי פעם צפוי זוכר.

482
00:20:56,130 --> 00:21:00,155
>> אבל לעת עתה, שם לב שאני
עושה את זה דרך 65 תוספת 26.

483
00:21:00,155 --> 00:21:03,030
כי כנראה אני אפילו לא רוצה
לעשות חשבון בראש שלי.

484
00:21:03,030 --> 00:21:04,440
אז אני אתן לי מהדר לעשות את זה.

485
00:21:04,440 --> 00:21:08,600
אבל אז בכל לולאה, כל איטרציה
של הלולאה, אני להגדיל כל i.

486
00:21:08,600 --> 00:21:10,196
>> אז עכשיו זה נראה קצת לא ברור מאליהם.

487
00:21:10,196 --> 00:21:13,320
אבל אנחנו צריכים את הבניין הבסיסי
לוקים בה להבין את זה.

488
00:21:13,320 --> 00:21:15,510
% C הוא רק מציין לchar.

489
00:21:15,510 --> 00:21:19,010
אני% הוא מציין מיקום עבור int.

490
00:21:19,010 --> 00:21:23,310
ומתברר כי באמצעות זה
תחביר חדש, בסוגריים זה, כל כך

491
00:21:23,310 --> 00:21:26,100
לדבר, כך סוג הנתונים
בתוך סוגריים,

492
00:21:26,100 --> 00:21:32,270
אני יכול להכריח את המהדר לטיפול
אני לא הוא מספר שלם, אלא כתווים.

493
00:21:32,270 --> 00:21:35,520
>> ובכך מראה לי את האופי
מקבילה של המספר הזה.

494
00:21:35,520 --> 00:21:37,986
עכשיו כאן למטה, את הקוד הזה
הוא זהה למדי.

495
00:21:37,986 --> 00:21:39,860
אני רק רציתי לעשות
סופר מפורש העובדה

496
00:21:39,860 --> 00:21:42,095
כי אני מתחיל ב97,
שאותיות קטנות.

497
00:21:42,095 --> 00:21:44,080
על דרך 26 מכתבים יותר.

498
00:21:44,080 --> 00:21:46,970
ואני doing-- שוב,
ליהוק i, אם אפשר לומר כך.

499
00:21:46,970 --> 00:21:49,160
או ליהוק סוג i, אם אפשר לומר כך.

500
00:21:49,160 --> 00:21:51,420
>> מint לchar.

501
00:21:51,420 --> 00:21:55,760
אז התוצאה הסופית תהיה,
בכנות, מידע שאנו כבר יודעים.

502
00:21:55,760 --> 00:21:59,411
אני הולך לעשות
ascii-0 dot-- לא מנקדים ג.

503
00:21:59,411 --> 00:22:02,160
שים לב, אתה כנראה עשית את זה
טעות כמו שאני פשוט עשיתי טעות.

504
00:22:02,160 --> 00:22:03,820
הפוך ascii-0.

505
00:22:03,820 --> 00:22:06,090
עכשיו אני הולך לעשות ./ascii-0.

506
00:22:06,090 --> 00:22:09,050
אני להתקרב, ולמרבה הצער,
זה הולך כדי לגלול את המסך.

507
00:22:09,050 --> 00:22:15,060
אבל אנחנו רואים תרשים כולו שבו
מפות ל97, מפות ב 98,

508
00:22:15,060 --> 00:22:18,931
ואם אנחנו לגלול מעלה נוספים
, כמובן, מפות ל65.

509
00:22:18,931 --> 00:22:21,180
אז זה רק אומר ש
מה שאנחנו כבר הטפה,

510
00:22:21,180 --> 00:22:25,310
יש שקילות זו, היא
למעשה המקרה במציאות.

511
00:22:25,310 --> 00:22:28,000
אז שינוי מהיר של זה.

512
00:22:28,000 --> 00:22:31,220
תן לי לפתוח את ascii-1.c.

513
00:22:31,220 --> 00:22:38,070
ושים לב זה חכם, סוג
של, בירור זה.

514
00:22:38,070 --> 00:22:41,770
זה ascii-1.c, ו
שם לב הדבר המטורף הזה.

515
00:22:41,770 --> 00:22:45,120
>> וזה באמת מגיע ללב
ממה שמחשבים עושים.

516
00:22:45,120 --> 00:22:48,150
למרות שאנחנו בני אדם היית
לא לספור במונחים של letters--

517
00:22:48,150 --> 00:22:50,380
אני לא מתחיל לחשוב,
בסדר אז ב,

518
00:22:50,380 --> 00:22:52,590
ולהשתמש בם כדי לספור עצמים פיזיים.

519
00:22:52,590 --> 00:22:58,680
אתה בהחלט יכול לומר שאני רוצה
לאתחל כמה משתנים בשם c--

520
00:22:58,680 --> 00:23:03,220
אבל אני יכול היה נקרא anything-- זה
כך ג מאותחל לא הון

521
00:23:03,220 --> 00:23:07,560
>> כי בסופו של היום, המחשב
לא אכפת לי מה אתה אחסון,

522
00:23:07,560 --> 00:23:10,170
זה רק אכפת איך אתה רוצה
להציג את המידע הזה.

523
00:23:10,170 --> 00:23:13,560
איך אתה רוצה שמחשב
לפרש דפוס זה של ביטים?

524
00:23:13,560 --> 00:23:16,320
אז זה לא שאני משהו
בדרך כלל ממליץ לעשות.

525
00:23:16,320 --> 00:23:19,500
זה באמת רק דוגמה ל
להעביר את המסר שאתה בהחלט יכול

526
00:23:19,500 --> 00:23:22,049
לאתחל שלם לתווים.

527
00:23:22,049 --> 00:23:24,090
מפני שמתחת
מכסה המנוע של char, כמובן,

528
00:23:24,090 --> 00:23:26,170
רק מספר בין 0 ל 255.

529
00:23:26,170 --> 00:23:28,540
>> אז אתה בהחלט יכול
לשים אותו בתוך int.

530
00:23:28,540 --> 00:23:30,890
ומה זה גם
מדגים הוא שאנחנו

531
00:23:30,890 --> 00:23:34,040
יכול להמיר מאחד
הקלד למשנהו, כאן,

532
00:23:34,040 --> 00:23:36,780
סופו של דבר הדפסה את אותו הדבר.

533
00:23:36,780 --> 00:23:44,760
ואכן, זו אני אסדר online--
היה אמור להגיד את זה, שוב, כאן.

534
00:23:44,760 --> 00:23:48,610
תן לי לנקות את זה באינטרנט, ואנו
לראות בהדרכה מקוונת לפי צורך,

535
00:23:48,610 --> 00:23:50,280
מה נועד לשם.

536
00:23:50,280 --> 00:23:50,960
>> אישור.

537
00:23:50,960 --> 00:23:53,892
דוגמא כל כך שעברה עכשיו מעורבת
של וb של ואז

538
00:23:53,892 --> 00:23:54,850
לקחת את הדברים צעד אחד קדימה.

539
00:23:54,850 --> 00:23:58,330
אז עם של וb של ו
ג של בהיוון

540
00:23:58,330 --> 00:24:01,560
ושקילותיהם, בואו
תסתכל בדוגמה זו, כאן.

541
00:24:01,560 --> 00:24:02,752
דוגמא נוספת קוד.

542
00:24:02,752 --> 00:24:04,460
אנחנו תפתחו אחד זה
כבר עשה, ולכן אנחנו

543
00:24:04,460 --> 00:24:06,440
לא יצטרך להקליד אותה
כל את מאפס.

544
00:24:06,440 --> 00:24:09,420
>> ושים לב בציפייה
אנחנו משתמשים בכותרת מספר

545
00:24:09,420 --> 00:24:13,240
קבצים, בין שהוא
החבר החדש שלנו, string.h.

546
00:24:13,240 --> 00:24:15,597
עכשיו זה נראה, בהתחלה
מבט חטוף, קצת לא ברור מאליהם.

547
00:24:15,597 --> 00:24:18,180
אבל בואו נראה אם ​​אנחנו לא יכולים לדבר בהיגיון
דרך מה שקורה כאן.

548
00:24:18,180 --> 00:24:21,150
ראשית אני מקבל מחרוזת מהמשתמש,
ואני שם את המחרוזת שבמשתנה

549
00:24:21,150 --> 00:24:22,286
שנקרא.

550
00:24:22,286 --> 00:24:24,090
העתק דבק מלפני.

551
00:24:24,090 --> 00:24:27,250
בשורה 22, אני כנראה
עושה בדיוק את מה

552
00:24:27,250 --> 00:24:30,760
אני עשיתי לפני רגע, אני iterating
על הדמויות בים.

553
00:24:30,760 --> 00:24:34,780
>> והטריקים החדשים כאן משתמשים
אורך מחרוזת, אופטימיזציה הקטין

554
00:24:34,780 --> 00:24:37,930
אחסון אורך המחרוזת בn,
במקום לקרוא strlen שוב,

555
00:24:37,930 --> 00:24:38,850
ושוב, ושוב.

556
00:24:38,850 --> 00:24:41,120
ורק בודק שהוא אני פחות מ n.

557
00:24:41,120 --> 00:24:43,330
עכשיו כאן, דברים מקבלים
קצת מעניין.

558
00:24:43,330 --> 00:24:45,980
אבל זה רק יישום
של אותו הרעיון החדש הזה.

559
00:24:45,980 --> 00:24:48,470
מה באנגלית עושה
סוגר של אני מייצג?

560
00:24:48,470 --> 00:24:51,772

561
00:24:51,772 --> 00:24:54,260
>> קהל: ספירה כל
אופי [לא ברור].

562
00:24:54,260 --> 00:24:55,926
>> דוד י מלאן: ספירת כל דמות.

563
00:24:55,926 --> 00:24:58,680
ואפילו באופן תמציתי יותר,
הסוגר של i מייצגת את מה?

564
00:24:58,680 --> 00:25:00,950
היית אומר.

565
00:25:00,950 --> 00:25:04,084
לא לשים אותך במקום כאן.

566
00:25:04,084 --> 00:25:06,375
>> קהל: Well--

567
00:25:06,375 --> 00:25:09,500
דוד י מלאן: אז אם המילה is-- אם
המחרוזת היא Zamyla, שstarts--

568
00:25:09,500 --> 00:25:12,380
קהל: --you להתמודד עם
דמויות separately--

569
00:25:12,380 --> 00:25:13,690
דוד י מלאן: טוב.

570
00:25:13,690 --> 00:25:14,190
בדיוק.

571
00:25:14,190 --> 00:25:17,940
סימון הסוגר המרובע מאפשר
כדי לגשת לכל תו בנפרד,

572
00:25:17,940 --> 00:25:21,120
כך הסוגר של 0 הולך להיות
התו ראשון במחרוזת.

573
00:25:21,120 --> 00:25:24,110
של הסוגר 1 הולך להיות
השני, וכן הלאה.

574
00:25:24,110 --> 00:25:28,050
אז השאלה שאני שואל,
כאן, במצב הזה הוא מה?

575
00:25:28,050 --> 00:25:33,984
האם אופי i'th של יותר של
או שווה לאותיות קטנות?

576
00:25:33,984 --> 00:25:36,400
ומה זה אומר, כאן,
עם סימן החיבור הכפול?

577
00:25:36,400 --> 00:25:36,800
קהל (ביחד): ו.

578
00:25:36,800 --> 00:25:37,210
דוד י מלאן: ו.

579
00:25:37,210 --> 00:25:38,418
זה פשוט שווה ערך לזה.

580
00:25:38,418 --> 00:25:42,310
ולא מילת מפתח בC, יש לך ל
שימוש, מעצבן, אמפרסנד אמפרסנד.

581
00:25:42,310 --> 00:25:47,520
וזה, לעומת זאת, מבקש הוא
ים של i'th אופי פחות או שווה

582
00:25:47,520 --> 00:25:49,030
לאותיות קטנות z?

583
00:25:49,030 --> 00:25:52,440
ושוב, הנה שבו
הבנה הבסיסית

584
00:25:52,440 --> 00:25:54,550
יישום
מחשב הגיוני.

585
00:25:54,550 --> 00:25:57,330
שים לב ש, אף על פי שיש לי
נקודת נקודת נקודה שם,

586
00:25:57,330 --> 00:26:04,410
נראה כמו דרך z באותיות קטנות ה
כל הערכים רציפים מ97 בעד.

587
00:26:04,410 --> 00:26:07,820
>> ואותו הדבר עבורו באותיות גדולות מתחיל ב65.

588
00:26:07,820 --> 00:26:10,410
אז האוכל המוכן, אז,
היא שבאנגלית,

589
00:26:10,410 --> 00:26:12,760
איך היית מתאר את
מה קו 24 עושים?

590
00:26:12,760 --> 00:26:15,736

591
00:26:15,736 --> 00:26:16,728
כן?

592
00:26:16,728 --> 00:26:21,575
>> קהל: ביום 24 בזה בודק
אם כל תו הוא באותיות קטנות.

593
00:26:21,575 --> 00:26:24,700
דוד י מלאן: זה לבדוק אם
כל דמות היא אות קטנה.

594
00:26:24,700 --> 00:26:28,590
אז גם באופן תמציתי יותר, הוא
אופי i'th של אותיות קטנות של?

595
00:26:28,590 --> 00:26:30,690
זה כל מה שאתה
להביע כאן באופן הגיוני,

596
00:26:30,690 --> 00:26:33,750
קצת מסתוריות, אבל
סופו של דבר די בצורה ישירה.

597
00:26:33,750 --> 00:26:36,480
האם ים של i'th אותיות קטנות אופי?

598
00:26:36,480 --> 00:26:40,130
>> אם כך, והנה שבו דברים
לקבל קצת מוח כיפוף

599
00:26:40,130 --> 00:26:44,760
רק לרגע, אם כן, ללכת
קדימה ולהדפיס את דמות.

600
00:26:44,760 --> 00:26:47,360
אז זה רק מציין,
אבל מה אופי?

601
00:26:47,360 --> 00:26:53,710
למה אני עושה את של הסוגר אני
מינוס בביטוי זה כאן?

602
00:26:53,710 --> 00:26:55,110
>> ובכן שים לב לדפוס כאן.

603
00:26:55,110 --> 00:26:57,380
המספרים בפועל לא משנה כל כך הרבה.

604
00:26:57,380 --> 00:27:02,700
אבל שים לב ש97 הוא
כמה רחוק מ65?

605
00:27:02,700 --> 00:27:03,560
>> קהל: 32.

606
00:27:03,560 --> 00:27:04,480
>> דוד י מלאן: 32.

607
00:27:04,480 --> 00:27:06,890
כמה רחוק הוא 98 מ66?

608
00:27:06,890 --> 00:27:07,740
>> קהל: 32.

609
00:27:07,740 --> 00:27:09,890
>> דוד י מלאן: c הקטן מC הגדול?

610
00:27:09,890 --> 00:27:10,420
32.

611
00:27:10,420 --> 00:27:14,550
אז יש 32 כשות מ
אות אחת למשנהו.

612
00:27:14,550 --> 00:27:17,790
אז בכנות אני, יכול
לפשט את זה של.

613
00:27:17,790 --> 00:27:20,400
אבל אז אני סוג של קידוד קשה
הבנה ברמה נמוכה זה

614
00:27:20,400 --> 00:27:21,740
שאף קורא הוא אי פעם
הולך להבין.

615
00:27:21,740 --> 00:27:25,080
אז אני הולך להכליל אותו כ, אני
יודעים האותיות קטנות הן גדולות יותר.

616
00:27:25,080 --> 00:27:28,400
אני יודע האותיות הגדולות הן
ערכים קטנים יותר, באופן אירוני.

617
00:27:28,400 --> 00:27:33,216
>> אבל זה הוא, למעשה, שווה ערך ל
אומר להחסיר 32 משל סוגר אני.

618
00:27:33,216 --> 00:27:35,430
אז בהקשר של אלה
מכתבים, אם המכתב

619
00:27:35,430 --> 00:27:38,950
קורה להיות, באותיות קטנות
, ואני לחסר 32,

620
00:27:38,950 --> 00:27:43,442
מה השפעה שיש ל,
מבחינה מתמטית, באותיות קטנות?

621
00:27:43,442 --> 00:27:44,400
קהל: Capitalizes--

622
00:27:44,400 --> 00:27:45,691
דוד י מלאן: מנצל את זה.

623
00:27:45,691 --> 00:27:48,440
ואכן, זו הסיבה שלנו
תכנית נקראת לנצל אפס.

624
00:27:48,440 --> 00:27:51,590
תכנית זו או
מהוון מכתב,

625
00:27:51,590 --> 00:27:54,580
לאחר הבדיקה אם הוא
אכן אות קטנה.

626
00:27:54,580 --> 00:27:59,810
אחרת, בשורה 30, מה עליי לעשות אם
זה לא אות קטנה שאני

627
00:27:59,810 --> 00:28:02,852
מסתכל על במסוים
איטרציה בלולאה.

628
00:28:02,852 --> 00:28:03,890
רק להדפיס אותו.

629
00:28:03,890 --> 00:28:07,010
>> אז לא לשנות דברים
זה אפילו לא באותיות קטנות.

630
00:28:07,010 --> 00:28:10,790
הגבל את עצמך ל
קצת דרך z הקטן.

631
00:28:10,790 --> 00:28:12,730
עכשיו זה די מסתורי.

632
00:28:12,730 --> 00:28:15,230
אבל בסופו של היום, זה
הוא כיצד אנו, פעם,

633
00:28:15,230 --> 00:28:16,460
הייתי צריך ליישם את הדברים.

634
00:28:16,460 --> 00:28:19,780
אם אני במקום פתוחים לנצל
אחד, הו תודה לאל.

635
00:28:19,780 --> 00:28:22,320
יש פונקציה
שיכול נקרא לעליון

636
00:28:22,320 --> 00:28:25,410
לעשות הכל רק שעשינו
ברמה נמוכה למדי.

637
00:28:25,410 --> 00:28:28,752
>> עכשיו לעליון הוא מעניין
משום שהוא הצהיר בקובץ,

638
00:28:28,752 --> 00:28:31,210
ואתה רק היה יודע את זה
על ידי בדיקת התיעוד,

639
00:28:31,210 --> 00:28:35,730
או שאומר לי, למשל, בכיתה, שבו
הוא קיים, בctype.h קובץ שנקרא.

640
00:28:35,730 --> 00:28:37,630
אז זה עוד חבר חדש שלנו.

641
00:28:37,630 --> 00:28:40,750
ועליון לעושה בדיוק
מה ששם מרמז.

642
00:28:40,750 --> 00:28:44,860
>> אתה יכול לעבור ב, כטיעון, בין
סוגריים אלה, איזו דמות.

643
00:28:44,860 --> 00:28:48,390
אני הולך לעבור באופי i'th
של s באמצעות הסימון החדש והמפואר שלנו

644
00:28:48,390 --> 00:28:49,870
מעורב בסוגריים מרובעים.

645
00:28:49,870 --> 00:28:53,391
ולקחת את ניחוש, מה היא התשואה
ערך של לעליון הולך כנראה

646
00:28:53,391 --> 00:28:53,890
להיות?

647
00:28:53,890 --> 00:28:56,460

648
00:28:56,460 --> 00:28:57,770
מכתב הון.

649
00:28:57,770 --> 00:28:58,620
מכתב הון.

650
00:28:58,620 --> 00:29:02,330
>> אז אם אני עובר באותיות קטנות,
אני מקווה, על ידי הגדרה של לעליון,

651
00:29:02,330 --> 00:29:05,600
זה הולך לחזור
באותיות גדולות א 'אחרת,

652
00:29:05,600 --> 00:29:08,590
אם זה לא אות קטנה ב
מלכתחילה, אני פשוט להדפיס אותו.

653
00:29:08,590 --> 00:29:10,800
ואכן, שים לב
החבר שני כאן.

654
00:29:10,800 --> 00:29:13,840
לא רק לעליון קיימת,
אבל נמוך, ש

655
00:29:13,840 --> 00:29:16,200
למעשה עונה על השאלה שבשבילי.

656
00:29:16,200 --> 00:29:19,730
>> עכשיו כל מי שכתב את הדברים האלה,
10s של שנים לפני, אתה יודע מה?

657
00:29:19,730 --> 00:29:23,840
מיושם לעליון והוא
להוריד באמצעות קוד כזה.

658
00:29:23,840 --> 00:29:27,270
אבל שוב, עולה בקנה אחד עם
הרעיון הזה של הפשטה משם,

659
00:29:27,270 --> 00:29:29,190
רמת סוג של, נמוכה יותר
פרטי יישום.

660
00:29:29,190 --> 00:29:32,600
ועומד על כתפיהם של אנשים
שבא לפנינו, תוך שימוש בפונקציות

661
00:29:32,600 --> 00:29:36,300
כמו לעליון ונמוך, ש
נפלא מספיק הם יפה

662
00:29:36,300 --> 00:29:40,190
שם להגיד מה שהם עושים, הוא
הפרדיגמה נפלאה לאמץ.

663
00:29:40,190 --> 00:29:44,040
>> עכשיו, מתברר שאם אני קורא
דף האדם ל, אומר, לעליון,

664
00:29:44,040 --> 00:29:45,010
אני לומד משהו אחר.

665
00:29:45,010 --> 00:29:46,890
אז איש toUpper.

666
00:29:46,890 --> 00:29:48,050
זה קצת מוחץ.

667
00:29:48,050 --> 00:29:51,110
אבל שימו לב, כאן זה שאזכור
קובץ הכותרת שאני צריך להשתמש.

668
00:29:51,110 --> 00:29:54,460
במאמר מוסגר, כי זה
הוא מטעה, הפונקציה

669
00:29:54,460 --> 00:29:59,070
משתמש ints במקום תווים
מסיבות של בדיקת שגיאות.

670
00:29:59,070 --> 00:30:01,260
אבל אנחנו אולי נבוא
אחזור לזה בעתיד.

671
00:30:01,260 --> 00:30:05,910
>> אבל שים לב, כאן, לגרים העליונים
אות c לאותיות רישיות במידת האפשר.

672
00:30:05,910 --> 00:30:07,674
אז זה די פשוט.

673
00:30:07,674 --> 00:30:09,340
ועכשיו בואו נהיה קצת יותר ספציפי.

674
00:30:09,340 --> 00:30:12,750
בואו נסתכל על החלק מ
דף איש תחת ערך החזרה.

675
00:30:12,750 --> 00:30:15,420
הערך המוחזר הוא ש
מהמכתב שהומר.

676
00:30:15,420 --> 00:30:18,690
או ג, אם ההמרה
לא היה אפשרי,

677
00:30:18,690 --> 00:30:20,250
כאשר c הוא הקלט המקורי.

678
00:30:20,250 --> 00:30:24,140
שאני יודע מכאן, מ
הטיעון לעליון.

679
00:30:24,140 --> 00:30:25,780
>> אז מה הוא האוכל המוכן לכך?

680
00:30:25,780 --> 00:30:28,060
הערך המוחזר הוא ש
של המכתב המומר,

681
00:30:28,060 --> 00:30:32,110
או ג, המכתב המקורי, אם
ההמרה לא הייתה אפשרית.

682
00:30:32,110 --> 00:30:36,460
מה שיפור שאני יכול להיות ולכן
להפוך לעיצוב של הקוד שלי?

683
00:30:36,460 --> 00:30:37,146
כן?

684
00:30:37,146 --> 00:30:38,810
>> קהל: אתה יכול להסיר אותם.

685
00:30:38,810 --> 00:30:40,810
דוד י מלאן: אני יכול
להסיר את ההצהרה אחרת,

686
00:30:40,810 --> 00:30:42,510
ולא רק ההצהרה אחרת.

687
00:30:42,510 --> 00:30:44,150
>> קהל: אתה יכול להסיר [לא ברור].

688
00:30:44,150 --> 00:30:46,310
>> דוד י מלאן: אני יכול
להסיר את כל המזלג

689
00:30:46,310 --> 00:30:48,209
בכביש, אם אחר לגמרי.

690
00:30:48,209 --> 00:30:50,250
אז אכן, תן לי לפתוח
הגרסה הסופית של זה,

691
00:30:50,250 --> 00:30:55,540
לנצל-2 ושימו לב עד כמה, אם
אתה, סקסי, הקוד הוא מקבל עכשיו,

692
00:30:55,540 --> 00:31:00,040
בכי אני כבר מופחת מכמה
שבע או כך קווים לארבעה,

693
00:31:00,040 --> 00:31:03,850
הפונקציונליות שנועדתי
פשוט על ידי קורא לעליון,

694
00:31:03,850 --> 00:31:09,410
עובר בים סוגר i, והדפסה
את, עם% c מציין המיקום,

695
00:31:09,410 --> 00:31:11,090
אופי מסוים.

696
00:31:11,090 --> 00:31:14,560
>> עכשיו ניתן לטעון, יש באג,
או לפחות את הסיכון לבאג,

697
00:31:14,560 --> 00:31:15,350
בתכנית זו.

698
00:31:15,350 --> 00:31:18,200
אז רק כדי לחזור
לאוכל מוכן קודם לכן,

699
00:31:18,200 --> 00:31:21,820
מה אני צריך כנראה גם לעשות ב
בתכנית זו כדי להפוך אותו חזקה יותר,

700
00:31:21,820 --> 00:31:24,974
כך שאין שום דרך שהוא יכול
לקרוס, גם במקרים נדירים?

701
00:31:24,974 --> 00:31:26,390
קהל: ודא שזה לא NULL.

702
00:31:26,390 --> 00:31:28,056
דוד י מלאן: ודא שזה לא NULL.

703
00:31:28,056 --> 00:31:31,030
אז באמת, כדי להפוך סופר זה
ראוי, אני צריך לעשות משהו כמו,

704
00:31:31,030 --> 00:31:35,300
אם ים הוא לא NULL, אז
קדימה ולבצע

705
00:31:35,300 --> 00:31:38,470
שורות אלה של קוד, ש
אז אני יכול לשנן כמו ש,

706
00:31:38,470 --> 00:31:39,870
ולאחר מכן לשים בסד הקרוב שלי.

707
00:31:39,870 --> 00:31:41,550
כל כך טוב קשירה יחד של שני הרעיונות.

708
00:31:41,550 --> 00:31:42,429
כן?

709
00:31:42,429 --> 00:31:44,470
קהל: האם אתה יכול להשתמש
לעשות בזמן הלולאה, במקום?

710
00:31:44,470 --> 00:31:47,270
דוד י מלאן: יכול
אני עושה לעשות בזמן לולאה?

711
00:31:47,270 --> 00:31:50,020
קהל: --you רוצה לוודא
כי אתה בעצם [לא ברור].

712
00:31:50,020 --> 00:31:51,728
דוד י מלאן: יכול
אתה משתמש לעשות בזמן?

713
00:31:51,728 --> 00:31:52,450
תשובה קצרה, לא.

714
00:31:52,450 --> 00:31:54,700
מכיוון שאתה עומד
להציג את מקרה פינה אחרת.

715
00:31:54,700 --> 00:31:56,660
אם המחרוזת של אורך אפס.

716
00:31:56,660 --> 00:31:59,600
אם למשל, אני פשוט פגע
הזן, מבלי להקליד Zamyla.

717
00:31:59,600 --> 00:32:02,490
אני הולך למסור לך בחזרה בפועל
מחרוזת, כפי שאנו יהיו סופו של דבר לראות,

718
00:32:02,490 --> 00:32:03,780
כי יש אפס תווים.

719
00:32:03,780 --> 00:32:05,630
זה עדיין מחרוזת,
זה סופר קצר פשוט.

720
00:32:05,630 --> 00:32:07,960
אבל אם אתה משתמש לעשות בזמן,
אתה הולך באופן עיוור

721
00:32:07,960 --> 00:32:10,050
תנסה לעשות משהו עם
לכבד למחרוזת ש,

722
00:32:10,050 --> 00:32:12,537
ושום דבר לא הולך להיות שם.

723
00:32:12,537 --> 00:32:18,607
>> קהל: ובכן, אם אתה עשית
לעשות [לא ברור] ואילו s--

724
00:32:18,607 --> 00:32:21,190
דוד י מלאן: אה אני רואה, לשמור
מקבל מחרוזת מהמשתמש.

725
00:32:21,190 --> 00:32:23,525
תשובה כל כך קצרה, אתה
יכול, ולשמור על להציק

726
00:32:23,525 --> 00:32:26,150
שלהם לתת לך מחרוזת זה
קצר מספיק כדי להתאים בזיכרון.

727
00:32:26,150 --> 00:32:26,700
בהחלט.

728
00:32:26,700 --> 00:32:27,630
אני פשוט בחרתי שלא.

729
00:32:27,630 --> 00:32:30,505
אם הם לא נותנים לי אני המחרוזת
רוצים, אני מפסיק, אני מוותר.

730
00:32:30,505 --> 00:32:33,260
אבל בהחלט, למטרה זו,
אתה בהחלט יכול לעשות את זה.

731
00:32:33,260 --> 00:32:37,500
>> אז קבצי הכותרת של הספרייה ש
אנחנו מכירים אותם אלה, כאן ועכשיו.

732
00:32:37,500 --> 00:32:41,550
קלט / פלט סטנדרטי, CS50.h, string.h,
ctype.h, ויש, אכן, אחרים.

733
00:32:41,550 --> 00:32:44,460
כמה מכם גילו
ספריית המתמטיקה בmath.h.

734
00:32:44,460 --> 00:32:48,200
אבל הרשית לי להציג בפניכם, עכשיו, ל
משאב זה שצוות CS50 דווין,

735
00:32:48,200 --> 00:32:50,630
ורוב, וגייב מסוים
יש להרכיב.

736
00:32:50,630 --> 00:32:52,630
כי בקרוב יהיה קישור על
אתר האינטרנט של הקורס.

737
00:32:52,630 --> 00:32:54,870
זה נקרא התייחסות CS50.

738
00:32:54,870 --> 00:32:58,230
>> שרק כדי לתת לך מהיר
טעם שלה, פועל באופן הבא.

739
00:32:58,230 --> 00:33:00,740
תן לי ללכת לreference.cs50.net.

740
00:33:00,740 --> 00:33:02,990
אתה תראה על יד שמאל
צד רשימה מכרעת

741
00:33:02,990 --> 00:33:04,595
של פונקציות שמגיעות עם ג.

742
00:33:04,595 --> 00:33:07,790
אבל אם אכפת לי, לרגע,
על משהו כמו strlen,

743
00:33:07,790 --> 00:33:08,746
אני יכול להקליד אותו שם.

744
00:33:08,746 --> 00:33:10,870
היא מסננת את הרשימה
רק מה אכפת לי.

745
00:33:10,870 --> 00:33:11,940
אני הולך ללחוץ עליו.

746
00:33:11,940 --> 00:33:14,740
ועכשיו בצד שמאל,
תראה את מה שאנחנו מקווים

747
00:33:14,740 --> 00:33:18,290
הוא יותר פשוט, אנושי
הסבר ידידותי של איך

748
00:33:18,290 --> 00:33:19,170
פונקציה זו עובדת.

749
00:33:19,170 --> 00:33:20,600
>> מחזיר את האורך של מחרוזת.

750
00:33:20,600 --> 00:33:24,060
הנה תקציר, הנה איך אתה
להשתמש בו במונחים של קובץ הכותרת,

751
00:33:24,060 --> 00:33:27,430
ובמונחים של מה הפונקציה
נראה כמו במונחים של טיעוניה.

752
00:33:27,430 --> 00:33:30,250
ואז כאן, חוזר
אורכו של חוט.

753
00:33:30,250 --> 00:33:34,280
אבל לאלו מכם יותר נוחים,
למעשה אתה יכול ללחוץ נוח יותר,

754
00:33:34,280 --> 00:33:37,070
ואת התוכן של זה
דף, עכשיו, ישתנה

755
00:33:37,070 --> 00:33:41,660
להיות ערכי ברירת המחדל של מה ש
אתה מקבל על ידי שימוש בדף האיש.

756
00:33:41,660 --> 00:33:44,100
>> במילים אחרות, CS50
התייחסות היא פישוט

757
00:33:44,100 --> 00:33:46,220
דפי גבר על ידי צוות, לסטודנטים.

758
00:33:46,220 --> 00:33:49,320
במיוחד, אלה פחות נוחים
ובין לבין, כך שאתה

759
00:33:49,320 --> 00:33:51,660
לא צריך לנסות לעטוף
המוח שלך מסביב, בכנות,

760
00:33:51,660 --> 00:33:55,030
כמה תחביר למדי נסתר
ותיעוד מתישהו.

761
00:33:55,030 --> 00:33:57,650
>> אז לשמור את זה בחשבון
בימים הבאים.

762
00:33:57,650 --> 00:33:59,560
אז הנה, שוב, הוא Zamyla.

763
00:33:59,560 --> 00:34:03,255
עכשיו בואו תשאלו את שאלה זה
קצת יותר אנושי נגיש.

764
00:34:03,255 --> 00:34:05,380
תודה לצ'אנג, מי שהייתה
הדפסה יותר פילים

765
00:34:05,380 --> 00:34:07,090
ללא הפסקה בימים האחרונים.

766
00:34:07,090 --> 00:34:09,730
יש לנו הזדמנות לתת
לפחות אחד מהם משם.

767
00:34:09,730 --> 00:34:13,239
אם היינו יכול לקבל רק מתנדב אחד
לבוא על עד לצייר על המסך.

768
00:34:13,239 --> 00:34:14,530
מה דעתך על כאן?

769
00:34:14,530 --> 00:34:15,340
>> בואו למעלה.

770
00:34:15,340 --> 00:34:16,720
מה שמך?

771
00:34:16,720 --> 00:34:17,219
אלכס: אלכס.

772
00:34:17,219 --> 00:34:17,760
דוד י מלאן: אלכס.

773
00:34:17,760 --> 00:34:18,259
בסדר.

774
00:34:18,259 --> 00:34:19,388
אלכס, בחייך עד.

775
00:34:19,388 --> 00:34:21,679
אנחנו עומדים לראותך
כתב יד על המסך כאן.

776
00:34:21,679 --> 00:34:24,325

777
00:34:24,325 --> 00:34:25,570
בסדר, נחמד לפגוש אותך.

778
00:34:25,570 --> 00:34:26,429
>> אלכס: נחמד שאתה פוגש אותך.

779
00:34:26,429 --> 00:34:27,512
>> דוד י מלאן: בסדר.

780
00:34:27,512 --> 00:34:28,969
אז, תרגיל סופר פשוט.

781
00:34:28,969 --> 00:34:31,440
בר הוא לא גבוה ל
לקבל פיל היום.

782
00:34:31,440 --> 00:34:33,439
אתה משחק את התפקיד של getstring.

783
00:34:33,439 --> 00:34:35,980
ואני הולך רק כדי להגיד לך
המחרוזת כי אתה כבר קיבלת.

784
00:34:35,980 --> 00:34:38,080
ונניח שאתה,
getstring, כבר קרא.

785
00:34:38,080 --> 00:34:42,480
והאדם, כמוני, יש לי
הקליד בZamyla, Z--M-Y-L-.

786
00:34:42,480 --> 00:34:45,650
פשוט להמשיך ולכתוב Zamyla על
מסך כאילו אתה מקבל את זה

787
00:34:45,650 --> 00:34:47,250
ואחסנתי אותו במקום כלשהו בזיכרון.

788
00:34:47,250 --> 00:34:52,370

789
00:34:52,370 --> 00:34:55,570
>> חדר יציאה למה יהיה מספר
words-- אחר זה בסדר, ימשיך.

790
00:34:55,570 --> 00:34:59,620
>> [שחוק]

791
00:34:59,620 --> 00:35:00,800
>> אז Zamyla, מצוין.

792
00:35:00,800 --> 00:35:04,880
אז עכשיו נניח שאתה,
getstring, נקרא שוב.

793
00:35:04,880 --> 00:35:09,350
ולכן, אני מספק לך, ב
מקלדת, עם שם אחרת, בלינדה.

794
00:35:09,350 --> 00:35:17,560

795
00:35:17,560 --> 00:35:18,060
בסדר.

796
00:35:18,060 --> 00:35:22,380
ועכשיו getstring הפעם הבאה הוא
בשם, אני מקליד במשהו כמו גייב,

797
00:35:22,380 --> 00:35:27,560
G-A-B-E. אתה באמת לוקח
לזיכרון גישה אקראית לב.

798
00:35:27,560 --> 00:35:29,631
שציור הכל
באופן אקראי לחלוטין.

799
00:35:29,631 --> 00:35:30,130
אישור.

800
00:35:30,130 --> 00:35:31,104
>> [שחוק]

801
00:35:31,104 --> 00:35:32,520
אלכס: מצטער כתב היד שלי היא רעה.

802
00:35:32,520 --> 00:35:33,770
דוד י מלאן: לא, זה בסדר.

803
00:35:33,770 --> 00:35:40,480
ומה דעתך על רוב, R-O-B. אישור.

804
00:35:40,480 --> 00:35:41,020
טוב.

805
00:35:41,020 --> 00:35:43,853
אז לא לצפות שהיית
סוג של להניח דברים בדרך זו.

806
00:35:43,853 --> 00:35:45,020
אבל אנחנו יכולים לעשות את העבודה הזאת.

807
00:35:45,020 --> 00:35:48,810
אז איך אתה לא הולך על הנחת
את התווים האלה בזיכרון?

808
00:35:48,810 --> 00:35:51,310
במילים אחרות, אם אנו חושבים על
מסך שחור מלבני זה

809
00:35:51,310 --> 00:35:53,550
כמייצג
זיכרון RAM, או הזיכרון של מחשב.

810
00:35:53,550 --> 00:35:55,850
>> וזוכר RAM כי הוא פשוט
חבורה של בתים שלם,

811
00:35:55,850 --> 00:35:57,480
ובתים הם חבורה של ביטים כל.

812
00:35:57,480 --> 00:35:59,350
וחתיכות הן איכשהו
מיושם, בדרך כלל

813
00:35:59,350 --> 00:36:01,119
עם צורה כלשהי של
חשמל בחומרה.

814
00:36:01,119 --> 00:36:03,160
אז זה סוג של
שכבות שדיברנו על

815
00:36:03,160 --> 00:36:04,510
ויכול עכשיו לקחת כמובן מאליו.

816
00:36:04,510 --> 00:36:07,020
איך אתה הולך על
להחליט איפה לכתוב

817
00:36:07,020 --> 00:36:11,634
רוב לעומת גייב לעומת
בלינדה לעומת Zamyla?

818
00:36:11,634 --> 00:36:14,020
>> אלכס: אני רק עשיתי את זה ב
להורות כי אתה אמר לי.

819
00:36:14,020 --> 00:36:15,650
>> דוד י מלאן: וזה נכון.

820
00:36:15,650 --> 00:36:20,100
אבל מה נשלטים איפה אתה שם את
שמו של לינדה ואת שמו של גייב?

821
00:36:20,100 --> 00:36:20,764
>> אלכס: שום דבר?

822
00:36:20,764 --> 00:36:22,930
דוד י מלאן: [צוחק]
אז זה עובד, זה בסדר.

823
00:36:22,930 --> 00:36:25,290
אז מחשבים קטנים
יותר מסודר מזה.

824
00:36:25,290 --> 00:36:29,000
ולכן כאשר אנו implement-- להישאר שם
רק moment-- כאשר אנחנו באמת

825
00:36:29,000 --> 00:36:31,470
ליישם משהו כמו
getstring במחשב,

826
00:36:31,470 --> 00:36:34,480
Zamyla עשוי להיות ערוך פחות או יותר
כמו שעשית על המסך, יש.

827
00:36:34,480 --> 00:36:36,660
>> ומה הוא מפתח ליבחין
כאן, מה שאלכס עשה,

828
00:36:36,660 --> 00:36:40,260
הוא שיש סוג של תיחום
בין כל אחת ממילות אלה, נכון?

829
00:36:40,260 --> 00:36:46,580
אתה לא כתבת
Z--M-Y-L-A-B-E-L-I-N-D-A-G-A-B--

830
00:36:46,580 --> 00:36:49,740
במילים אחרות, יש כאן איזה ש
תיחום אשר נראה כי,

831
00:36:49,740 --> 00:36:52,370
סוג של, מרווח אקראי
בין אלה מילות שונות.

832
00:36:52,370 --> 00:36:54,120
אבל זה טוב, כי
עכשיו אנחנו בני אדם יכולים

833
00:36:54,120 --> 00:36:56,470
לדמיין כי אלה הם
ארבעה מיתרים שונים.

834
00:36:56,470 --> 00:36:59,540
זה לא רק רצף אחד
של הרבה דמויות.

835
00:36:59,540 --> 00:37:04,190
אז מחשב, ולאחר מכן, בינתיים,
עלול לקחת מחרוזת כמו Zamyla,

836
00:37:04,190 --> 00:37:07,220
לשים את כל המכתבים האלה
בתוך בתים של זיכרון.

837
00:37:07,220 --> 00:37:10,400
אבל המספר הזה הוא הרבה יותר גדול,
כמובן, משישה תווים.

838
00:37:10,400 --> 00:37:11,690
>> יש חבורה של זיכרון RAM כל.

839
00:37:11,690 --> 00:37:15,330
וכך מעתה ואילך, זה
רשת של תיבות הולכת

840
00:37:15,330 --> 00:37:17,560
כדי לייצג את מה שאלכס רק
עשה כאן על המסך.

841
00:37:17,560 --> 00:37:20,937
ועכשיו, אלכס, אנחנו יכולים להציע לך
כחול או פיל כתום מצ'אנג.

842
00:37:20,937 --> 00:37:22,270
אלכס: אני אקח את פיל כחול.

843
00:37:22,270 --> 00:37:23,120
דוד י מלאן: פיל כחול.

844
00:37:23,120 --> 00:37:25,580
אז מחיאות כפות גדולות,
אם היינו יכולים, לאלכס כאן.

845
00:37:25,580 --> 00:37:26,100
>> [מחיאות כפות]

846
00:37:26,100 --> 00:37:26,766
>> אלכס: תודה לך.

847
00:37:26,766 --> 00:37:28,820
דוד י מלאן: תודה לך.

848
00:37:28,820 --> 00:37:36,230
אז ממסעדה היא ש, למרות ש
דפוס שינה את סוג של לאורך זמן, כאן

849
00:37:36,230 --> 00:37:40,430
על הלוח, היה זה
תיחום בין המחרוזות השונות

850
00:37:40,430 --> 00:37:42,610
שאלכס הגיע לנו.

851
00:37:42,610 --> 00:37:45,230
עכשיו מחשבים, בכנות,
יכול לעשות את אותו הדבר.

852
00:37:45,230 --> 00:37:48,210
הם סוג של יכולים היו לגלוש
מחרוזות בכל מקום בזכרון RAM.

853
00:37:48,210 --> 00:37:50,710
עד כאן, כאן,
כאן למטה, כאן למטה.

854
00:37:50,710 --> 00:37:52,020
>> הם יכולים לעשות בדיוק את זה.

855
00:37:52,020 --> 00:37:54,280
אבל, כמובן, זה
כנראה לא התכנון הטוב ביותר.

856
00:37:54,280 --> 00:37:54,780
נכון?

857
00:37:54,780 --> 00:37:57,340
אם אני כל הזמן שאל את אלכס
לקבל שמות, כנראה שהוא הייתי

858
00:37:57,340 --> 00:38:01,370
לשים קצת יותר כאן למטה, אולי עד
כאן, כאן, כאן, סופו של דבר

859
00:38:01,370 --> 00:38:02,211
כאן.

860
00:38:02,211 --> 00:38:05,460
אבל עם תכנון קצת יותר, בהחלט,
אנחנו יכולים להניח את הדברים החוצה יותר נקיים.

861
00:38:05,460 --> 00:38:07,350
ואכן, זה מה שמחשב עושה.

862
00:38:07,350 --> 00:38:10,720
>> אבל המלכוד הוא ש
אם המחרוזת הבאה אני מקבל

863
00:38:10,720 --> 00:38:14,050
לאחר Zamyla הוא משהו
כמו בלינדה,

864
00:38:14,050 --> 00:38:17,929
להציע שבו אנחנו יכולים לכתוב
מכתב ב ביחס לרשת זו?

865
00:38:17,929 --> 00:38:18,720
לאן תלך?

866
00:38:18,720 --> 00:38:21,480
בצד הימין של,
להלן z, מתחת ל?

867
00:38:21,480 --> 00:38:23,204
מה היית האינסטינקטים הראשונים שלך יהיו?

868
00:38:23,204 --> 00:38:24,120
קהל: להלן z.

869
00:38:24,120 --> 00:38:25,100
דוד י מלאן: אז להלן z.

870
00:38:25,100 --> 00:38:26,530
וזה פחות או
פשוט, נכון?

871
00:38:26,530 --> 00:38:29,321
זה סוג של מסודר, זה מה שאנחנו עושים
על מקלדת כאשר פגעו הזן,

872
00:38:29,321 --> 00:38:31,770
או בעת ביצוע דואר אלקטרוני
רשימה עם תבליטים של דברים.

873
00:38:31,770 --> 00:38:34,310
אבל המציאות היא שמחשבים
מנסה להיות יעיל יותר,

874
00:38:34,310 --> 00:38:37,170
ולדחוס בהחלט ככל
נתונים לזכרון RAM ככל האפשר,

875
00:38:37,170 --> 00:38:38,890
כך שאתה לא לבזבז את כל בתים.

876
00:38:38,890 --> 00:38:41,545
כך שאתה לא לבזבז
כל מסך הנדל"ן.

877
00:38:41,545 --> 00:38:44,170
והבעיה, אם כי, היא ש
אם אנחנו ממש שמנו את המכתב

878
00:38:44,170 --> 00:38:49,940
ב לאחר, איך אנחנו הולכים
יודע איפה שמו של Zamyla מסתיים

879
00:38:49,940 --> 00:38:51,840
ושמו של בלינדה מתחיל?

880
00:38:51,840 --> 00:38:55,270
אז אתם בני אדם בדיוק מוצעים, גם,
לחץ על המקש Enter, במהות.

881
00:38:55,270 --> 00:38:56,410
שים את זה למטה.

882
00:38:56,410 --> 00:38:59,750
או אפילו כאלכס עשה, פשוט להתחיל לכתוב
את השם הבא מתחת לקודמתה,

883
00:38:59,750 --> 00:39:01,583
ומתחת לזה אחד, ו
לאחר מכן מתחת לזה אחד.

884
00:39:01,583 --> 00:39:02,510
זה סימן חזותי.

885
00:39:02,510 --> 00:39:05,960
>> יש לי מחשבים אחר סימן חזותי,
אבל זה קצת תמציתי יותר.

886
00:39:05,960 --> 00:39:07,840
זה אופי פאנקי זה.

887
00:39:07,840 --> 00:39:11,890
0 מהלך סרק, שהוא אולי
מזכיר n הקו הנטוי,

888
00:39:11,890 --> 00:39:12,640
וכן הלאה, עכשיו.

889
00:39:12,640 --> 00:39:14,120
רצפי בריחה המיוחדים.

890
00:39:14,120 --> 00:39:19,120
מהלך סרק 0 הוא הדרך של
המייצג את שמונה אפס ביטים ברציפות.

891
00:39:19,120 --> 00:39:22,000
0000 0000.

892
00:39:22,000 --> 00:39:26,130
>> הדרך בה אתה מבטא את זה לא כדי
פגע במספר אפס במקלדת,

893
00:39:26,130 --> 00:39:28,140
כי בעובדה שהיא char ASCII.

894
00:39:28,140 --> 00:39:30,990
זה נראה כמו מספר, אבל
הוא למעשה מספר עשרוני

895
00:39:30,990 --> 00:39:35,910
המייצג את החוזר
גליף, הגופן העגול.

896
00:39:35,910 --> 00:39:38,410
בינתיים, קו נטוי
אפס פירושו, פשוטו כמשמעו

897
00:39:38,410 --> 00:39:40,700
לשים שמונה אפס בתים כאן בשבילי.

898
00:39:40,700 --> 00:39:42,136
>> אז זה הוא שרירותי במידה מסוימת.

899
00:39:42,136 --> 00:39:44,260
אנחנו יכולים כבר השתמשנו בכל תבנית
ביטים, אבל העולם

900
00:39:44,260 --> 00:39:46,610
החליט כמה שנים
לפני, שכדי לייצג

901
00:39:46,610 --> 00:39:49,710
קצה חוט בזיכרון,
פשוט לשים את החבורה של אפסים כל.

902
00:39:49,710 --> 00:39:51,000
מכיוון שאנו יכולים לזהות את זה.

903
00:39:51,000 --> 00:39:54,790
עכשיו זה אומר שאין אות של
האלפבית יכול להיות מיוצג עם אפסים.

904
00:39:54,790 --> 00:39:58,480
>> אבל זה בסדר, אנחנו כבר ראינו
שבו אנו משתמשים 65 ב97 בעד.

905
00:39:58,480 --> 00:40:00,290
אנחנו לא נגיע לשום מקום
קרוב לכל האפסים.

906
00:40:00,290 --> 00:40:03,040

907
00:40:03,040 --> 00:40:06,540
אז בלינדה בזיכרון של מחשב
הוא למעשה הולך כאן.

908
00:40:06,540 --> 00:40:09,764
אני כבר ציירתי אותו בצהוב רק
כדי למשוך תשומת הלב שלנו אליו.

909
00:40:09,764 --> 00:40:11,680
והודעה, גם זה
הוא שרירותי לחלוטין.

910
00:40:11,680 --> 00:40:12,680
אני כבר ציירתי אותו כגריד.

911
00:40:12,680 --> 00:40:14,460
כמו, זיכרון RAM הוא רק חלק אובייקט פיזי.

912
00:40:14,460 --> 00:40:17,300
אין זה בהכרח
שורות ועמודות, כשלעצמו.

913
00:40:17,300 --> 00:40:20,490
זה פשוט יש לי חבורה של בתים שלמות
מיושם בחומרה איכשהו.

914
00:40:20,490 --> 00:40:22,817
אבל אם אחרי בלינדה אני
הקליד את השם שלו של גייב,

915
00:40:22,817 --> 00:40:25,650
הוא הולך בסופו של כאן בזיכרון,
ואם אני הקלדתי את שמו של דייבן,

916
00:40:25,650 --> 00:40:27,316
למשל, שהוא הולך בסופו של כאן.

917
00:40:27,316 --> 00:40:29,310
ואני יכול להמשיך
לכתוב עוד יותר שמות.

918
00:40:29,310 --> 00:40:32,100
>> לרוע המזל, אם אני מנסה
לכתוב את שם סופר ארוך,

919
00:40:32,100 --> 00:40:33,730
אני יכול לרוץ סופו של דבר יצא מהזיכרון.

920
00:40:33,730 --> 00:40:37,810
במקרה כזה, getstring הוא
הולך להחזיר NULL, כפי שאמרנו.

921
00:40:37,810 --> 00:40:41,720
אך לשמחתם, לפחות בזה חזותי
כאן, אנחנו לא מקבלים די כל כך רחוקים.

922
00:40:41,720 --> 00:40:45,860
>> עכשיו מה נחמד הוא שזה
רעיון כללי של טיפול בדברים

923
00:40:45,860 --> 00:40:49,720
כמו להיות בקופסות הוא
נציג של תכונה של C

924
00:40:49,720 --> 00:40:52,690
והרבה שפות,
הידועה בשם מערך.

925
00:40:52,690 --> 00:40:55,490
מערך הוא סוג אחר של נתונים.

926
00:40:55,490 --> 00:40:57,380
זה מבנה נתונים, אם תרצה.

927
00:40:57,380 --> 00:41:01,160
מבנה במובן של זה באמת,
סוג של, נראה כמו קופסא, לפחות

928
00:41:01,160 --> 00:41:02,320
בעיניי רוחכם.

929
00:41:02,320 --> 00:41:09,680
מערך הוא רציף
רצף של סוגים זהים נתונים,

930
00:41:09,680 --> 00:41:11,330
גב אל גב אל גב אל גב.

931
00:41:11,330 --> 00:41:14,720
>> אז מחרוזת, באחר
מילות, היא מערך של תווים.

932
00:41:14,720 --> 00:41:16,120
מערך של תווים.

933
00:41:16,120 --> 00:41:19,070
אבל מתברר שאתה יכול להיות
מערכים של אשכולות של דברים.

934
00:41:19,070 --> 00:41:21,870
למעשה, אנחנו יכולים לשים אפילו
מספרים במערך.

935
00:41:21,870 --> 00:41:23,920
אז הטופס שבו
אנחנו הולכים להתחיל

936
00:41:23,920 --> 00:41:26,590
הכרזת נתונים זה
מבנה הידוע כמערך

937
00:41:26,590 --> 00:41:28,250
גם הוא הולך להשתמש בסוגריים מרובעים.

938
00:41:28,250 --> 00:41:31,500
אבל סוגריים מרובעים האלה הולכים
יש משמעות שונה בהקשר זה.

939
00:41:31,500 --> 00:41:33,450
>> ובואו לראות את זה באופן הבא.

940
00:41:33,450 --> 00:41:36,780
נניח שפתחתי
עד קובץ חדש כאן.

941
00:41:36,780 --> 00:41:38,535
ואני שומר את זה כages.c.

942
00:41:38,535 --> 00:41:41,280

943
00:41:41,280 --> 00:41:43,470
ואני אשמור את זה בתיקייה שלי כאן.

944
00:41:43,470 --> 00:41:46,130
ועכשיו אני הולך קדימה
והתחל להקליד משהו

945
00:41:46,130 --> 00:41:53,940
כמו כולל CS50.h, כולל
stdio.h, int חלל מרכזי.

946
00:41:53,940 --> 00:41:57,370
ואז בתוך כאן, אני רוצה
יש הראשון int נקרא גיל.

947
00:41:57,370 --> 00:42:01,371
>> ואני הולך להשתמש בזה כדי לקבל
int מהמשתמש לגילו או שלה.

948
00:42:01,371 --> 00:42:04,620
אבל בתכנית זו נועדה לשימוש על ידי
אנשים רבים, מכל הקשר.

949
00:42:04,620 --> 00:42:05,490
יש לי תור של אנשים.

950
00:42:05,490 --> 00:42:08,281
לכולם יש להקליד בהם
גיל לאולי קצת, אני לא יודע,

951
00:42:08,281 --> 00:42:10,530
תחרות, או אירוע
כי הם כבר הגיעו ל.

952
00:42:10,530 --> 00:42:13,030
אז האדם הבא, אני
צריך עוד משתנה.

953
00:42:13,030 --> 00:42:15,790
>> כי אם אני רק עושה
גיל מקבל getInt, זה

954
00:42:15,790 --> 00:42:18,500
עומד להכות, או להחליף
הגיל של האדם הקודם.

955
00:42:18,500 --> 00:42:19,760
אז זה לא טוב.

956
00:42:19,760 --> 00:42:21,790
אז האינסטינקט הראשון שלי
יכול להיות, הו, בסדר,

957
00:42:21,790 --> 00:42:26,260
אם אני רוצה לגרום לאנשים של מספר רב של
ages-- בואו נקרא age1 זה,

958
00:42:26,260 --> 00:42:31,280
age2 int מקבל int, age3 int מקבל getInt.

959
00:42:31,280 --> 00:42:35,340
ועכשיו אני הולך להשתמש
כמה קוד pseudocode כאן.

960
00:42:35,340 --> 00:42:37,679
>> לעשות משהו עם המספרים האלה.

961
00:42:37,679 --> 00:42:40,470
נשאיר ליום אחר מה
אנחנו עושים שם, כי אנחנו היחידים

962
00:42:40,470 --> 00:42:44,200
לדאוג לרגע
על age1, age2, age3.

963
00:42:44,200 --> 00:42:46,450
לרוע המזל, ברגע שאני
לקמפל תכנית זו

964
00:42:46,450 --> 00:42:51,140
ולשים אותו בחזית של משתמשים בפועל,
מה העניים ביסוד העיצוב

965
00:42:51,140 --> 00:42:53,890
החלטה נדמה לי שעשתה?

966
00:42:53,890 --> 00:42:54,624
כן?

967
00:42:54,624 --> 00:42:55,499
קהל: [לא ברור]

968
00:42:55,499 --> 00:42:58,071

969
00:42:58,071 --> 00:42:59,820
דוד י מלאן: כן,
אני אפילו לא ניסיתי

970
00:42:59,820 --> 00:43:02,028
כדי להבין גילים כמה
אני באמת אכפת?

971
00:43:02,028 --> 00:43:05,380
אם יש לי פחות משלושה אנשים כאן,
ולכן פחות משלושה גילים,

972
00:43:05,380 --> 00:43:07,260
אני עדיין בעיוורון אני מצפה שלוש.

973
00:43:07,260 --> 00:43:08,720
החס וחליל ארבעה אנשים להופיע.

974
00:43:08,720 --> 00:43:10,990
התכנית שלי פשוט לא אפילו לתמוך בהם.

975
00:43:10,990 --> 00:43:13,280
>> וכך הסיפור הזה, ארוך
קצר, לא הרגל טוב.

976
00:43:13,280 --> 00:43:13,780
נכון?

977
00:43:13,780 --> 00:43:16,530
אני היה בעצם העתקה ו
הדבקת קוד ורק tweaking

978
00:43:16,530 --> 00:43:17,430
השמות משתנים.

979
00:43:17,430 --> 00:43:22,410
ו, אלוהים שלי, אם היה לך, לא שלוש
גילים, אך 10, או 100, או אפילו 6,500

980
00:43:22,410 --> 00:43:23,820
סטודנטים לתואר ראשון, למשל.

981
00:43:23,820 --> 00:43:26,950
זה לא הולך להיות במיוחד
קוד אלגנטי, או בר קיימא.

982
00:43:26,950 --> 00:43:29,200
אתה הולך צריך
לשכתב את התכנית בכל פעם

983
00:43:29,200 --> 00:43:30,760
המספר שלך של שינויי אנשים.

984
00:43:30,760 --> 00:43:35,090
>> אז לשמחתי, בבפועל שלנו
קובץ ages.c להיום,

985
00:43:35,090 --> 00:43:36,970
יש לנו פתרון חכם יותר.

986
00:43:36,970 --> 00:43:39,800
ראשית, אני הולך לשאול
לבנות שהשתמשנו כמה פעמים,

987
00:43:39,800 --> 00:43:43,744
זה לעשות בזמן הלולאה, על מנת לקבל
מספר האנשים בחדר.

988
00:43:43,744 --> 00:43:46,910
אני רק הולך להציק למשתמש, שוב
ושוב, עד שהוא או היא נותנת לי

989
00:43:46,910 --> 00:43:49,260
ערך של n זה מספר חיובי.

990
00:43:49,260 --> 00:43:51,590
>> אני היה יכול להשתמש, אחרון
זמן לקבל int החיובי.

991
00:43:51,590 --> 00:43:53,720
אבל אין לנו ש
אמיתי, אז הלכתי קדימה

992
00:43:53,720 --> 00:43:55,660
ומחדש יישם את הרעיון הזה.

993
00:43:55,660 --> 00:43:58,410
עכשיו כאן למטה, זה הטריק החדש.

994
00:43:58,410 --> 00:44:02,260
בשורה 27, כהערות
בשורה 26 מרמזת,

995
00:44:02,260 --> 00:44:05,180
להצהיר על מערך שבו
כדי לאחסן הגיל של כולם.

996
00:44:05,180 --> 00:44:09,320
>> אז אם אתה רוצה לקבל, לא int אחד, לא
שני ints, אבל חבורה של ints כל.

997
00:44:09,320 --> 00:44:13,800
באופן ספציפי n מספרים שלמים, היו אולי n
יהיה שלוש, עשוי להיות 100, יכול להיות 1,000.

998
00:44:13,800 --> 00:44:17,570
התחביר, בפשטות, הוא
למשל, אילו נתונים סוג אתה רוצה?

999
00:44:17,570 --> 00:44:19,620
מה אתה רוצה לקרוא
נתח זה של זיכרון?

1000
00:44:19,620 --> 00:44:23,530
מה אתה רוצה לקרוא לרשת
שנראה כמו זה באופן ציורי?

1001
00:44:23,530 --> 00:44:27,700
>> ובסוגריים כאן, אתה אומר
כמה גדול אתה רוצה המערך להיות.

1002
00:44:27,700 --> 00:44:30,450
וכך קודם לכן, כשאמרתי
תחביר הוא קצת שונה כאן,

1003
00:44:30,450 --> 00:44:33,614
אנחנו עדיין משתמשים בסוגריים מרובעים,
אבל כשאני הגדרה של מערך,

1004
00:44:33,614 --> 00:44:35,530
המספר הפנימי של
אמצעי סוגריים מרובעים

1005
00:44:35,530 --> 00:44:37,610
עד כמה גדול אתה רוצה המערך להיות.

1006
00:44:37,610 --> 00:44:42,490
>> בניגוד לכך, כאשר אנחנו משתמשים בים
סוגר i לפני רגע, זה, מחרוזת,

1007
00:44:42,490 --> 00:44:46,820
אכן מערך של תווים, אבל
כשאתה לא מכריז משתנה,

1008
00:44:46,820 --> 00:44:49,760
כמו עם מילת מפתח זו כאן,
אתה פשוט מקבל

1009
00:44:49,760 --> 00:44:54,280
מדד ספציפי, ספציפי
אלמנט ממערך ש.

1010
00:44:54,280 --> 00:44:57,090
ברגע שאנו יודעים את זה, כל השאר
לכך הוא פשוט.

1011
00:44:57,090 --> 00:45:00,765
אם חדש אני הולך ראשון להדפיס
מה הגיל של מספר האדם שאני.

1012
00:45:00,765 --> 00:45:03,890
איפה אני פשוט אומר מספר אדם אחד,
מספר האדם שני, מספר האדם שלוש.

1013
00:45:03,890 --> 00:45:06,306
>> ואני פשוט עושה חשבון,
כך שאנשים רגילים כמו,

1014
00:45:06,306 --> 00:45:09,030
אנו סופרים מאחת לכך
תכנית, ולא מנקודת האפס.

1015
00:45:09,030 --> 00:45:13,620
אז אני קורא getint, אבל אני לאחסן
התשובה בגילים ממסגרת i.

1016
00:45:13,620 --> 00:45:16,610
שהוא גיל i'th במערך.

1017
00:45:16,610 --> 00:45:21,640
אז בעוד שהפעם האחרונה שהיינו בטיפול
תיבות אלה כתווים לשמו של Zamyla,

1018
00:45:21,640 --> 00:45:22,490
ואחרים.

1019
00:45:22,490 --> 00:45:26,530
עכשיו, תיבות אלה מייצגים
32 סיביות, או ארבעה בתים

1020
00:45:26,530 --> 00:45:29,510
שבו אנחנו יכולים לאחסן
int, int, int.

1021
00:45:29,510 --> 00:45:31,890
כולם, שוב,
הם אותו סוג נתונים.

1022
00:45:31,890 --> 00:45:33,890
>> עכשיו אני עושה משהו מטופש,
כמו שהזמן עובר, רק

1023
00:45:33,890 --> 00:45:35,510
כדי להצדיק את כתיבת תכנית זו.

1024
00:45:35,510 --> 00:45:40,050
ולאחר מכן כאן למטה, אני שוב לחזר
על המערך אומר שנה מעכשיו,

1025
00:45:40,050 --> 00:45:43,090
מספר אדם רצון אחד
להיות בן שנות משהו.

1026
00:45:43,090 --> 00:45:45,010
וכדי להבין את זה
math-- אני מתכוון, זה

1027
00:45:45,010 --> 00:45:49,260
לא מסובך מאוד arithmetic--
אני רק אוסיף אחד לגיל שלהם.

1028
00:45:49,260 --> 00:45:51,240
רק כדי להדגים, שוב, זה.

1029
00:45:51,240 --> 00:45:57,910
>> בדיוק כמו שאני יכול מדד למחרוזת, של,
גם אני יכול מדד למערך של גילים,

1030
00:45:57,910 --> 00:45:59,950
כמו שיש.

1031
00:45:59,950 --> 00:46:03,340
אז איפה זה הולך להיות לוקח אותנו?

1032
00:46:03,340 --> 00:46:07,070
אז נוכל לראות, סופו של דבר,
כמה דברים בימים הבאים.

1033
00:46:07,070 --> 00:46:09,510
אחד, כל הזמן הזה, כאשר
כתיבת תוכניות משלך,

1034
00:46:09,510 --> 00:46:11,239
כמו מריו, חמדנים, אשראי.

1035
00:46:11,239 --> 00:46:13,780
אתה כבר להקליד את השם
התכנית ולהכות על Enter.

1036
00:46:13,780 --> 00:46:15,610
ולאחר מכן מקבל קלט של המשתמש.

1037
00:46:15,610 --> 00:46:18,137
>> עם getString, getInt,
getLongLong, או משהו דומה.

1038
00:46:18,137 --> 00:46:20,720
אבל מתברר שתומך C
משהו שנקרא שורת הפקודה

1039
00:46:20,720 --> 00:46:25,740
טענות, שהוא הולך לתת לנו
למעשה לקבל במילים שאתם מקלידים,

1040
00:46:25,740 --> 00:46:28,570
בשורת הפקודה המהבהבת,
אחרי השם של התכנית שלך.

1041
00:46:28,570 --> 00:46:31,430
>> אז בימים הבאים, אתה
אולי להקליד משהו כמו קיסר,

1042
00:46:31,430 --> 00:46:34,950
או ./caesar מספר 13, לאחר מכן.

1043
00:46:34,950 --> 00:46:36,070
נצטרך לראות איך זה עובד.

1044
00:46:36,070 --> 00:46:37,550
כי אכן, ב
בעיה להגדיר שתי, אנחנו

1045
00:46:37,550 --> 00:46:39,383
הולך להציג בפניכם
למשהו קטן

1046
00:46:39,383 --> 00:46:42,360
מזכיר ראלפי של
לאתגר קודם של מיפוי.

1047
00:46:42,360 --> 00:46:43,970
האמנות של ערבול מידע.

1048
00:46:43,970 --> 00:46:46,660
זה, למעשה, הוא מאוד
מזכיר את מה שראלפי עשה.

1049
00:46:46,660 --> 00:46:51,380
>> זוהי דוגמא של הצפנה
אלגוריתם שנקרא rot13, R-O-T 13.

1050
00:46:51,380 --> 00:46:54,910
אשר פשוט אומר לסובב את
אותיות באלפבית 13 מקומות.

1051
00:46:54,910 --> 00:46:58,309
ואם אתה עושה את זה, אתה תראה עכשיו
מה הוא, אולי, ביטוי מוכר.

1052
00:46:58,309 --> 00:47:01,100
אבל הדרך בה אנו הולכים להשתמש
זה, בסופו, הוא באופן כללי יותר.

1053
00:47:01,100 --> 00:47:04,390
>> בP להגדיר שני, במהדורה סטנדרטית,
אתה ליישם כמה צופן,

1054
00:47:04,390 --> 00:47:06,720
אחד בשם קיסר, אחד בשם Vigenere.

1055
00:47:06,720 --> 00:47:10,090
שניהם סיבוב
צופן, שבאיכשהו אתה

1056
00:47:10,090 --> 00:47:11,826
להפוך אות אחת לאות אחרת.

1057
00:47:11,826 --> 00:47:12,950
והקיסר הוא סופר פשוט.

1058
00:47:12,950 --> 00:47:16,220
אתה מוסיף אחד, אתה מוסיף 13,
או למספר עד 26.

1059
00:47:16,220 --> 00:47:19,570
Vigenere עושה את זה על
למכתב בסיס.

1060
00:47:19,570 --> 00:47:22,140
אז Vigenere, כפי שתראה
במפרט, הוא בטוח יותר.

1061
00:47:22,140 --> 00:47:24,973
>> אבל בסופו של היום מה ש
אתה תהיה היישום וP להגדיר שני,

1062
00:47:24,973 --> 00:47:29,050
הוא שהמפתח שאתה משתמש בשניהם
להצפנה ופענוח.

1063
00:47:29,050 --> 00:47:32,160
בהתייחסו לתהליך של הפיכה
טקסט רגיל, כמה הודעה מקורית,

1064
00:47:32,160 --> 00:47:34,490
לטקסט סייפר, אשר
הוא משהו מוצפן.

1065
00:47:34,490 --> 00:47:36,220
ולאחר מכן פענוח את זה שוב.

1066
00:47:36,220 --> 00:47:38,119
>> במהדורת ההאקר,
בינתיים, אתה תהיה

1067
00:47:38,119 --> 00:47:40,660
המוטל עם משהו דומה
ברוח, שבו אנחנו אתן לך

1068
00:47:40,660 --> 00:47:44,610
קובץ, מLinux טיפוסי, או
Etsy מחשב בשם Mac, או יוניקס

1069
00:47:44,610 --> 00:47:47,800
סיסמא, אשר מכילה את כל
חבורה של שמות משתמש וסיסמאות.

1070
00:47:47,800 --> 00:47:50,932
וסיסמאות אלה לכל
הוצפן, או מרוסק,

1071
00:47:50,932 --> 00:47:53,140
אם אפשר לומר כך, יותר כראוי
כפי שתראה במפרט.

1072
00:47:53,140 --> 00:47:57,090
>> ומהדורת ההאקר תאתגר
לך עם לקיחת קלט כמו זה,

1073
00:47:57,090 --> 00:47:58,800
ופיצוח הסיסמה.

1074
00:47:58,800 --> 00:48:02,590
כלומר, להבין מה
הסיסמה של האדם בעצם הייתה.

1075
00:48:02,590 --> 00:48:05,570
משום, אכן, סיסמות
בדרך כלל לא מאוחסן בברור,

1076
00:48:05,570 --> 00:48:08,260
ובאופן כללי סיסמאות
צריך להיות קשה לנחש.

1077
00:48:08,260 --> 00:48:09,610
זה לא קורה לעתים קרובות.

1078
00:48:09,610 --> 00:48:12,110
>> ומה חשבתי שכדאי לעשות הוא
תסיים בכמה דקות

1079
00:48:12,110 --> 00:48:15,160
מבט חטוף בבמיוחד
בחירה גרועה של סיסמאות

1080
00:48:15,160 --> 00:48:17,260
מסרט שאתה עלול להיזכר בחיבה.

1081
00:48:17,260 --> 00:48:18,915
ואם לא, אתה צריך לשכור.

1082
00:48:18,915 --> 00:48:20,070
>> [וידאו השמעה]

1083
00:48:20,070 --> 00:48:22,320
>> -Helmet, אתה השטן, מה קורה?

1084
00:48:22,320 --> 00:48:24,240
מה אתה עושה לבת שלי?

1085
00:48:24,240 --> 00:48:28,010
>> -Permit לי להציג את
מנתח פלסטי צעיר מבריק,

1086
00:48:28,010 --> 00:48:30,010
הדוקטור פיליפ Schlotkin.

1087
00:48:30,010 --> 00:48:35,020
עבודת אדם האף הכי גדול ב
יקום כולו ובוורלי הילס.

1088
00:48:35,020 --> 00:48:36,140
>> -Your הוד מעלה.

1089
00:48:36,140 --> 00:48:36,820
>> עבודת -Nose?

1090
00:48:36,820 --> 00:48:37,700
אני לא מבין.

1091
00:48:37,700 --> 00:48:39,070
כבר היה לה ניתוח פלסטי באף.

1092
00:48:39,070 --> 00:48:40,800
זה היה מתוק שלה 16 נוכחי.

1093
00:48:40,800 --> 00:48:42,590
>> 'לא, זה לא מה שאתה חושב.

1094
00:48:42,590 --> 00:48:44,490
זה הרבה, הרבה יותר גרוע.

1095
00:48:44,490 --> 00:48:48,160
אם אתה לא נותן לי
שילוב למגן האוויר,

1096
00:48:48,160 --> 00:48:52,748
רופא Schlotkin ייתן לך
בת לגבות את אפה הישן.

1097
00:48:52,748 --> 00:48:53,748
- [התנשפויות] Nooooooooooooo.

1098
00:48:53,748 --> 00:48:57,684

1099
00:48:57,684 --> 00:48:59,652
מאיפה הבאת את זה?

1100
00:48:59,652 --> 00:49:00,640
>> כל להיטים תקין.

1101
00:49:00,640 --> 00:49:02,506
אני אגיד לי, אני אגיד לי.

1102
00:49:02,506 --> 00:49:03,498
>> 'לא, אבא, לא.

1103
00:49:03,498 --> 00:49:04,490
אתה לא חייב.

1104
00:49:04,490 --> 00:49:06,090
>> "אתה שזכותי יקרה.

1105
00:49:06,090 --> 00:49:07,390
אני אתגעגע אל האף החדש שלך.

1106
00:49:07,390 --> 00:49:10,990
אבל אני לא אגיד להם
שילוב לא משנה מה.

1107
00:49:10,990 --> 00:49:12,450
>> גם -Very.

1108
00:49:12,450 --> 00:49:14,830
רופא Schlotkin, לעשות הגרוע ביותר שלך.

1109
00:49:14,830 --> 00:49:15,744
>> ההנאה -לוח.

1110
00:49:15,744 --> 00:49:19,860

1111
00:49:19,860 --> 00:49:20,800
>> 'לא!

1112
00:49:20,800 --> 00:49:22,780
חכה, חכה.

1113
00:49:22,780 --> 00:49:24,000
אני אגיד לי.

1114
00:49:24,000 --> 00:49:25,830
אני אגיד לי.

1115
00:49:25,830 --> 00:49:28,270
>> 'אני יודע שזה יעבוד.

1116
00:49:28,270 --> 00:49:31,390
בסדר, תן לי את.

1117
00:49:31,390 --> 00:49:36,220
>> -The שילוב הוא אחד.

1118
00:49:36,220 --> 00:49:36,740
>> -One.

1119
00:49:36,740 --> 00:49:37,473
>> -One.

1120
00:49:37,473 --> 00:49:37,972
שתיים.

1121
00:49:37,972 --> 00:49:38,471
שתיים.

1122
00:49:38,471 --> 00:49:39,800
שתיים.

1123
00:49:39,800 --> 00:49:40,300
שלוש.

1124
00:49:40,300 --> 00:49:40,800
שלוש.

1125
00:49:40,800 --> 00:49:41,800
שלוש.

1126
00:49:41,800 --> 00:49:42,300
-Four.

1127
00:49:42,300 --> 00:49:42,800
-Four.

1128
00:49:42,800 --> 00:49:44,707
-Four.

1129
00:49:44,707 --> 00:49:45,521
-Five.

1130
00:49:45,521 --> 00:49:46,430
-Five.

1131
00:49:46,430 --> 00:49:47,930
-Five.

1132
00:49:47,930 --> 00:49:53,480
-אז השילוב הוא אחד,
שתיים, שלוש, ארבעה, חמש.

1133
00:49:53,480 --> 00:49:56,140
זה השילוב הכי המטומטם
אי פעם אני שומע בחיים שלי.

1134
00:49:56,140 --> 00:49:58,640
זה הסוג של דבר
אידיוט היה על המטען שלו.

1135
00:49:58,640 --> 00:50:00,000
>> תודה לך, הוד מעלתך.

1136
00:50:00,000 --> 00:50:01,340
>> [CLICKS REMOTE]

1137
00:50:01,340 --> 00:50:02,450
>> 'מה עשית?

1138
00:50:02,450 --> 00:50:03,800
>> 'אני כיביתי את הקיר.

1139
00:50:03,800 --> 00:50:05,010
>> 'לא, אתה לא, אתה
כיביתי את הסרט כולו.

1140
00:50:05,010 --> 00:50:06,220
>> זו בטח -אני לחצה על הכפתור הלא נכון.

1141
00:50:06,220 --> 00:50:07,064
>> "טוב, החזרת אותו על!

1142
00:50:07,064 --> 00:50:07,910
שים את הסרט בחזרה על!

1143
00:50:07,910 --> 00:50:08,300
>> -כן, אדוני!

1144
00:50:08,300 --> 00:50:08,799
כן, אדוני.

1145
00:50:08,799 --> 00:50:09,660
'תן נלך, ארנולד.

1146
00:50:09,660 --> 00:50:10,450
בואו, גרטשן.

1147
00:50:10,450 --> 00:50:12,533
כמובן שאתה יודע שאני
צריך לחייב אותך על זה.

1148
00:50:12,533 --> 00:50:16,720

1149
00:50:16,720 --> 00:50:17,220
"טוב?

1150
00:50:17,220 --> 00:50:17,802
האם זה עובד?

1151
00:50:17,802 --> 00:50:18,510
איפה המלך?

1152
00:50:18,510 --> 00:50:20,218
>> 'זה עבד, אדוני, אנחנו
יש לי שילוב.

1153
00:50:20,218 --> 00:50:20,740
-Great.

1154
00:50:20,740 --> 00:50:24,810
עכשיו אנחנו יכולים לקחת כל נשימה האחרונה
אוויר צח מהכוכב Druidia.

1155
00:50:24,810 --> 00:50:25,890
מה השילוב?

1156
00:50:25,890 --> 00:50:28,155
>> -One, שתיים, שלוש, ארבעה, חמש.

1157
00:50:28,155 --> 00:50:29,890
>> -One, שתיים, שלוש, ארבעה, חמש?

1158
00:50:29,890 --> 00:50:30,390
-כן.

1159
00:50:30,390 --> 00:50:31,110
-That מדהים.

1160
00:50:31,110 --> 00:50:34,550
יש לי את אותו
שילוב על המטען שלי.

1161
00:50:34,550 --> 00:50:37,160
הכן 1 spaceball ל
יציאה מיידית.

1162
00:50:37,160 --> 00:50:38,160
>> -כן, אדוני.

1163
00:50:38,160 --> 00:50:40,745
>> -ואז לשנות את
שילוב על המטען שלי.

1164
00:50:40,745 --> 00:50:41,578
[SOUND סגירת דלת]

1165
00:50:41,578 --> 00:50:42,064
[נקישת הדלתות להכות קסדה]

1166
00:50:42,064 --> 00:50:42,550
-Ahh.

1167
00:50:42,550 --> 00:50:43,383
[END הפעלת וידאו]

1168
00:50:43,383 --> 00:50:46,700
דוד י מלאן: זהו זה ל
CS50, נתראה בשבוע הבא.

1169
00:50:46,700 --> 00:50:49,883
קריין: ועכשיו, עמוק
מחשבות, על ידי ךייבן Farnham.

1170
00:50:49,883 --> 00:50:53,160

1171
00:50:53,160 --> 00:50:55,860
>> להתפלל Farnham: הקידוד בC הוא
כל כך הרבה יותר קשה מסריטות.

1172
00:50:55,860 --> 00:50:57,320
printf, גירוד היה שקר.

1173
00:50:57,320 --> 00:50:59,930

1174
00:50:59,930 --> 00:51:01,430
>> [Soundbite שחוק]

1175
00:51:01,430 --> 00:51:02,486