1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [סעיף 4] [פחות נוח]

2
00:00:02,000 --> 00:00:04,000
[נייט Hardison] [אוניברסיטת הרווארד]

3
00:00:04,000 --> 00:00:07,000
[זה CS50.] [CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> בסדר, ברוך שובי לסעיף.

5
00:00:10,000 --> 00:00:13,000
בסעיף של השבוע הזה אנחנו הולכים לעשות כמה דברים.

6
00:00:13,000 --> 00:00:17,000
אנחנו הולכים על ערכת בעיה לסכם 1 2,

7
00:00:17,000 --> 00:00:20,000
המהווה את סדרת בעית קיסר וVigenère.

8
00:00:20,000 --> 00:00:23,000
ואז אנחנו הולכים לצלול לביקורת 0 חידון

9
00:00:23,000 --> 00:00:26,000
ולבלות קצת הזמן recapping מה שדברנו עליו

10
00:00:26,000 --> 00:00:30,000
בכל אחת מההרצאות עד כה, ואנחנו גם עושים כמה בעיות

11
00:00:30,000 --> 00:00:32,000
מהבחנים של השנה הקודמת.

12
00:00:32,000 --> 00:00:36,000
בדרך זו יש לכם דרך טובה להתכונן לזה.

13
00:00:36,000 --> 00:00:40,000
>> כדי להתחיל, אני כבר מאותחל כמה פתרונות טובים

14
00:00:40,000 --> 00:00:45,000
לקבוצת הבעיה הקודמת, בעית ההגדרה 2, בשטח זה.

15
00:00:45,000 --> 00:00:48,000
אם אתם כל פגעתם על קישור זה,

16
00:00:48,000 --> 00:00:53,000
ואם תלחץ על השם שלי ולחץ על הגרסה הראשונה שלי

17
00:00:53,000 --> 00:00:56,000
תראה caesar.c, וזה בדיוק מה שאני מחפש ב.

18
00:00:56,000 --> 00:01:00,000
בואו נדבר על זה ממש במהירות.

19
00:01:00,000 --> 00:01:02,000
זה רק פתרון מדגם.

20
00:01:02,000 --> 00:01:05,000
זה לא בהכרח הפתרון המושלם.

21
00:01:05,000 --> 00:01:08,000
ישנן דרכים רבות ושונות כדי לכתוב את זה,

22
00:01:08,000 --> 00:01:10,000
אבל יש כמה דברים שאני רוצה להדגיש

23
00:01:10,000 --> 00:01:13,000
כי ראיתי שאני היה דירוג, טעויות נפוצות שאני חושב

24
00:01:13,000 --> 00:01:18,000
הפתרון הזה עושה עבודה טובה מאוד של טיפול.

25
00:01:18,000 --> 00:01:22,000
>> הראשון הוא שיש סוג מסוים של הערת הכותרת בחלקו העליון.

26
00:01:22,000 --> 00:01:25,000
ביום 1 בקווים עד 7 אתה רואה את הפרטים,

27
00:01:25,000 --> 00:01:28,000
מה בדיוק הוא עושה בתכנית זו.

28
00:01:28,000 --> 00:01:32,000
מקובל טוב כשאתה כותב קוד C

29
00:01:32,000 --> 00:01:35,000
ללא קשר אם התכנית שלך כלולה בתוך קובץ או בודד

30
00:01:35,000 --> 00:01:38,000
בין אם היא מפוצלת על פני מספר קבצים הוא שיש סוג מסוים של

31
00:01:38,000 --> 00:01:40,000
orienting הערה בחלק העליון.

32
00:01:40,000 --> 00:01:43,000
זה גם לאנשים שיוצאים ולכתוב קוד בעולם האמיתי.

33
00:01:43,000 --> 00:01:47,000
זה המקום בו נשים את המידע על זכויות יוצרים.

34
00:01:47,000 --> 00:01:50,000
להלן # כולל.

35
00:01:50,000 --> 00:01:55,000
בקו 16 יש את זה # להגדיר, שאנחנו נחזור ל, רק קצת.

36
00:01:55,000 --> 00:01:59,000
ואז ברגע שהפונקציה מתחילה, מתחילה ברגע עיקרי,

37
00:01:59,000 --> 00:02:03,000
כי תכנית זו כבר כלולה בכל פונקציה אחת

38
00:02:03,000 --> 00:02:09,000
הדבר הראשון שקרה, וזה מאוד האידיומטיים וטיפוסי של תכנית C

39
00:02:09,000 --> 00:02:14,000
שלוקח בשורת פקודת טיעונים-הוא שהוא בודק באופן מיידי

40
00:02:14,000 --> 00:02:18,000
>> לספירת הוויכוח, argc.

41
00:02:18,000 --> 00:02:24,000
כאן אנו רואים כי תכנית זו היא מצפה 2 טענות בדיוק.

42
00:02:24,000 --> 00:02:27,000
זכור שיש הטענה הראשונה זה אחד מיוחד

43
00:02:27,000 --> 00:02:29,000
זה תמיד השם של התכנית המתנהלת,

44
00:02:29,000 --> 00:02:31,000
את השם של קובץ ההפעלה.

45
00:02:31,000 --> 00:02:36,000
ואז מה שזה עושה זה מונע מהמשתמש להפעיל את התכנית

46
00:02:36,000 --> 00:02:42,000
עם יותר או פחות ויכוחים.

47
00:02:42,000 --> 00:02:44,000
הסיבה שאנחנו רוצים לבדוק את זה מייד היא משום

48
00:02:44,000 --> 00:02:52,000
אנחנו לא ממש יכולים לגשת למערך argv זה ממש כאן אמין

49
00:02:52,000 --> 00:02:55,000
עד שבדקנו לראות כמה הוא גדול.

50
00:02:55,000 --> 00:02:58,000
>> אחת השגיאות הנפוצות שראיתי היה אנשים היינו הולכים מייד

51
00:02:58,000 --> 00:03:01,000
ולתפוס argv [1].

52
00:03:01,000 --> 00:03:06,000
הם היו תופסים את טיעון המפתח מהמערך ואין לי לבדוק את זה,

53
00:03:06,000 --> 00:03:11,000
ואז הם היינו עושים את הבדיקה לargc, כמו גם את המבחן הבא,

54
00:03:11,000 --> 00:03:16,000
אם הטיעון הראשון אכן היה שלם באותו הזמן,

55
00:03:16,000 --> 00:03:20,000
וזה לא עובד כי במקרה שאין ויכוחים סופקו

56
00:03:20,000 --> 00:03:26,000
אתה תהיה תופס טענה שהוא לא שם או מנסה לתפוס אחד שהוא לא שם.

57
00:03:26,000 --> 00:03:29,000
>> הדבר הגדול האחר, כי אתה צריך לשים לב הוא ש

58
00:03:29,000 --> 00:03:32,000
אתה תמיד רוצה להדפיס איזה הודעת שגיאה מועילה

59
00:03:32,000 --> 00:03:34,000
למשתמש לכוון אותם.

60
00:03:34,000 --> 00:03:37,000
אני בטוח שיש לך את כל התוכניות שהופעלה בו פתאום שהוא מתרסק,

61
00:03:37,000 --> 00:03:41,000
ואתה מקבל את השיח הזה המגוחך הקטן שקופץ ואומר

62
00:03:41,000 --> 00:03:44,000
משהו נורא מסתורי ואולי נותן לך קוד שגיאה או משהו כזה

63
00:03:44,000 --> 00:03:47,000
שלא הגיוני.

64
00:03:47,000 --> 00:03:50,000
זה המקום בו אתה באמת רוצה לספק משהו מועיל

65
00:03:50,000 --> 00:03:54,000
וממוקד למשתמש, כך שכאשר הם מפעילים את זה הם הולכים "אה," כף פנים.

66
00:03:54,000 --> 00:03:58,000
"אני יודע בדיוק מה לעשות. אני יודע איך לתקן את זה."

67
00:03:58,000 --> 00:04:01,000
>> אם לא יפרסם הודעה, אז אתה בסופו של ממש

68
00:04:01,000 --> 00:04:04,000
משאיר את המשתמש ללכת לבדוק את קוד המקור שלך

69
00:04:04,000 --> 00:04:07,000
כדי להבין מה השתבש.

70
00:04:07,000 --> 00:04:11,000
יש גם כמה פעמים שאתה משתמש בקודי שגיאה שונים.

71
00:04:11,000 --> 00:04:14,000
כאן אנחנו פשוט השתמשנו באחד אומרים שיש שגיאה,

72
00:04:14,000 --> 00:04:16,000
הייתה טעות, הייתה טעות.

73
00:04:16,000 --> 00:04:20,000
תוכניות גדולות יותר, לעתים קרובות תוכניות שנקראות על ידי תוכניות אחרות,

74
00:04:20,000 --> 00:04:25,000
יחזור איזה קודי שגיאה מיוחדות בתרחישים שונים

75
00:04:25,000 --> 00:04:28,000
תכנותי כדי לתקשר את מה שהיית עושה אחרת

76
00:04:28,000 --> 00:04:32,000
פשוט להשתמש בהודעה אנגלית נחמדה ל.

77
00:04:32,000 --> 00:04:35,000
מגניב.

78
00:04:35,000 --> 00:04:37,000
כפי שאנו פועלים למטה, אתה יכול לראות שאנחנו מוציאים את המפתח.

79
00:04:37,000 --> 00:04:40,000
אנחנו בודקים אם המפתח מתאים.

80
00:04:40,000 --> 00:04:42,000
אנחנו מקבלים הודעה מהמשתמש.

81
00:04:42,000 --> 00:04:46,000
הסיבה שאנחנו עושים את זה בזה לעשות בעוד לולאה וזה משהו שאנחנו נכסה

82
00:04:46,000 --> 00:04:50,000
בקצת, אבל מתברר שאם תקליד השליטה D

83
00:04:50,000 --> 00:04:54,000
כאשר אתה מקבל GetString שפקודה במסוף

84
00:04:54,000 --> 00:04:59,000
מה שבעצם עושה זה שולח תו מיוחד

85
00:04:59,000 --> 00:05:01,000
לתכנית.

86
00:05:01,000 --> 00:05:05,000
זה נקרא ELF או סוף אופי קובץ.

87
00:05:05,000 --> 00:05:08,000
ובמקרה כזה, מחרוזת המסר שלנו תהיה ריקה,

88
00:05:08,000 --> 00:05:14,000
אז זה לא היה משהו שבדקנו בבעיה להגדיר את עצמו.

89
00:05:14,000 --> 00:05:17,000
>> אבל כמו שאנחנו הולכים, עכשיו שאנחנו כבר התחלנו לדבר על מצביעים

90
00:05:17,000 --> 00:05:21,000
והקצאת זיכרון דינמית על הערימה,

91
00:05:21,000 --> 00:05:25,000
בדיקת null בכל פעם שיש לך פונקציה שאולי

92
00:05:25,000 --> 00:05:30,000
תחזיר null כערך הוא משהו שאתה רוצה להשיג בנוהג לעשות.

93
00:05:30,000 --> 00:05:33,000
זה כאן בעיקר לאיור.

94
00:05:33,000 --> 00:05:36,000
אבל כשאתה רואה את GetString בעתיד,

95
00:05:36,000 --> 00:05:41,000
כל כך מבעית הגדרה 4 ב, אתה רוצה לשמור את זה בחשבון.

96
00:05:41,000 --> 00:05:44,000
שוב, זה לא בעיה בשביל בעית Set 3 או כיוון שעדיין לא כיסו אותו עדיין.

97
00:05:44,000 --> 00:05:53,000
לבסוף, אנחנו מגיעים לחלק הזה שבו אנחנו מגיעים ללולאת ההצפנה הראשית,

98
00:05:53,000 --> 00:05:57,000
ויש כמה דברים שעובד כאן.

99
00:05:57,000 --> 00:06:02,000
ראשית, שנעמיק את המחרוזת כל הודעה עצם.

100
00:06:02,000 --> 00:06:07,000
כאן אנו שמרנו strlen שיחה במצב,

101
00:06:07,000 --> 00:06:12,000
שמספר שציין הוא לא דרך מצוינת ללכת.

102
00:06:12,000 --> 00:06:15,000
מתברר שבמקרה זה זה גם לא גדול,

103
00:06:15,000 --> 00:06:20,000
גם בגלל שאנחנו משנים את התוכן של ההודעה עצם

104
00:06:20,000 --> 00:06:27,000
בתוך ללולאה, כך שאם יש לנו הודעה באורך 10 תווים,

105
00:06:27,000 --> 00:06:32,000
הפעם הראשונה שאנחנו מתחילים ללולאת strlen יחזיר מה?

106
00:06:32,000 --> 00:06:35,000
10.

107
00:06:35,000 --> 00:06:40,000
>> אבל אם לאחר מכן לשנות את ההודעה, אומרים לנו לשנות אופייה 5,

108
00:06:40,000 --> 00:06:46,000
ואנחנו זורקים ב\ 0 דמות בעמדת 5,

109
00:06:46,000 --> 00:06:49,000
באיטרציה באה strlen (הודעה) לא יחזיר את מה שעשה

110
00:06:49,000 --> 00:06:52,000
בפעם הראשונה שאנו איטרטיבי

111
00:06:52,000 --> 00:06:56,000
אבל זה יחזור במקום 5 כי זרק שבnull terminator,

112
00:06:56,000 --> 00:06:59,000
והאורך של המחרוזת מוגדר

113
00:06:59,000 --> 00:07:03,000
לפי עמדתו של ש\ 0.

114
00:07:03,000 --> 00:07:09,000
במקרה זה, זו היא דרך מצוינת ללכת כי אנחנו משנים אותו במקום.

115
00:07:09,000 --> 00:07:13,000
אבל שמתם לב שזה בעצם פשוט מפתיע להצפין

116
00:07:13,000 --> 00:07:16,000
אם אתה יכול להשיג את המתמטיקה נכונה.

117
00:07:16,000 --> 00:07:19,000
כל מה שנדרש הוא לבדוק האם המכתב שאתה מסתכל

118
00:07:19,000 --> 00:07:21,000
הוא רישיות או קטן.

119
00:07:21,000 --> 00:07:24,000
>> הסיבה שיש לנו רק כדי לבדוק את זה ואין לנו לבדוק

120
00:07:24,000 --> 00:07:27,000
מקרה אלפא הוא משום

121
00:07:27,000 --> 00:07:30,000
אם דמות היא אותיות גדולה או אם זה אותיות קטן

122
00:07:30,000 --> 00:07:33,000
אז זה בהחלט תו אלפביתי,

123
00:07:33,000 --> 00:07:38,000
משום שאין לנו ספרות גדולה וקטנה.

124
00:07:38,000 --> 00:07:41,000
הדבר ולעשות את זה הוא קצת מסובך, אחר אנחנו

125
00:07:41,000 --> 00:07:45,000
אנחנו שונים קיסר צופן הנוסחא הסטנדרטית

126
00:07:45,000 --> 00:07:49,000
שנתנו במפרט סט הבעיה.

127
00:07:49,000 --> 00:07:52,000
מה ששונה כאן הוא שאנחנו נגרענו

128
00:07:52,000 --> 00:07:58,000
במקרה הון אותיות הגדול, ולאחר מכן הוספנו הון

129
00:07:58,000 --> 00:08:02,000
לגבות בסוף.

130
00:08:02,000 --> 00:08:05,000
>> אני יודע כמה שעשיתי את זה בקוד שלך.

131
00:08:05,000 --> 00:08:09,000
האם מישהו מכם לעשות את זה בהגשות שלך?

132
00:08:09,000 --> 00:08:13,000
אתה עשית את זה. אתה יכול להסביר מה זה עושה, Sahb?

133
00:08:13,000 --> 00:08:18,000
על ידי הפחתה אותו החוצה, כי אתה עשית mod מייד אחריו,

134
00:08:18,000 --> 00:08:21,000
אתה צריך לקחת אותו החוצה, ולכן אופן שבו אתה מקבל [שיעול] עמדה.

135
00:08:21,000 --> 00:08:25,000
ולאחר מכן על ידי הוספתו שוב מאוחר יותר העביר מעליך אחד שאתה רוצה.

136
00:08:25,000 --> 00:08:27,000
כן, בדיוק.

137
00:08:27,000 --> 00:08:32,000
מה Sahb אמר היה שכאשר אנחנו רוצים להוסיף

138
00:08:32,000 --> 00:08:36,000
המסר שלנו והמפתח שלנו יחד

139
00:08:36,000 --> 00:08:42,000
ואז mod mod ש, כי על ידי NUM_LETTERS,

140
00:08:42,000 --> 00:08:50,000
אם אנחנו לא בקנה מידה שלנו להודעת 0-25 הטווח המתאים ראשון,

141
00:08:50,000 --> 00:08:54,000
אז אולי בסופו של דבר מקבל מספר ממש מוזר

142
00:08:54,000 --> 00:08:59,000
משום שהערכים שאנחנו מחפשים בכאשר אנו מסתכלים בהודעה [i],

143
00:08:59,000 --> 00:09:03,000
כאשר אנו מתבוננים בדמות ה-i של הודעת הטקסט הרגיל שלנו,

144
00:09:03,000 --> 00:09:08,000
הוא ערך אי שם ב65-122 טווח זה

145
00:09:08,000 --> 00:09:13,000
המבוסס על ערכי ASCII לאותיות גדולות באמצעות z אותיות הקטנים.

146
00:09:13,000 --> 00:09:18,000
ולכן כאשר אנו mod על ידי 26 או על ידי NUM_LETTERS,

147
00:09:18,000 --> 00:09:23,000
מאז שהיה שלנו # להגדיר בפינה הימנית העליונה עד כאן,

148
00:09:23,000 --> 00:09:28,000
זה הולך לתת לנו ערך זה בטווח 0-25,

149
00:09:28,000 --> 00:09:30,000
ואנחנו צריכים דרך ואז לקנה המידה שגבתה את

150
00:09:30,000 --> 00:09:32,000
ולקבל את זה בטווח ASCII המתאים.

151
00:09:32,000 --> 00:09:36,000
הדרך הקלה ביותר לעשות זאת היא פשוט לקצץ הכל

152
00:09:36,000 --> 00:09:39,000
לטווח 0-25 כדי להתחיל עם,

153
00:09:39,000 --> 00:09:43,000
ולאחר מכן להעביר את הכל בחזרה עד בסוף.

154
00:09:43,000 --> 00:09:46,000
>> טעות נפוצה נוספת שראיתי אנשים שנתקלו בהיא

155
00:09:46,000 --> 00:09:50,000
אם אתה לא באמת לעשות שינוי קנה מידה זה מייד

156
00:09:50,000 --> 00:09:53,000
ואתה מוסיף הודעה ומפתח ביחד ואתה מוסיף להם, למשל,

157
00:09:53,000 --> 00:09:58,000
למשתנת char, בעיה עם זה

158
00:09:58,000 --> 00:10:01,000
מאז הודעה היא [i] הוא מספר גדול יחסית להתחיל עם

159
00:10:01,000 --> 00:10:05,000
זוכר את זה לפחות 65 אם זה אותיות גדולות תווים

160
00:10:05,000 --> 00:10:09,000
אם יש לך מפתח גדול, יניח, משהו כמו 100,

161
00:10:09,000 --> 00:10:13,000
ואתה מוסיף אלה 2 ביחד לתוך char חתם אתה הולך לקבל בגלישה.

162
00:10:13,000 --> 00:10:17,000
אתה הולך לקבל את הערך שהוא גדול מ127,

163
00:10:17,000 --> 00:10:22,000
המהווה את הערך הגדול ביותר שמשתנה char יכול להחזיק.

164
00:10:22,000 --> 00:10:26,000
שוב, זה למה שהיית רוצה לעשות דברים מסוג הזה מלכתחילה.

165
00:10:26,000 --> 00:10:29,000
יש אנשים שעקפו את זה במקרה על ידי עושה אם אחר ובודקים

166
00:10:29,000 --> 00:10:33,000
כדי לראות אם זה היית הצפה לפני עושה את זה,

167
00:10:33,000 --> 00:10:36,000
אבל בדרך זו מקבלת סביב זה.

168
00:10:36,000 --> 00:10:40,000
ואז בפתרון זה שהדפסנו את כל המחרוזת בסוף מאוד.

169
00:10:40,000 --> 00:10:45,000
אנשים אחרים הדפיסו אופי בכל פעם. שניהם מדהימים.

170
00:10:45,000 --> 00:10:51,000
בשלב זה, לעשות יש לכם שאלות, הערות כלשהן על זה?

171
00:10:51,000 --> 00:10:56,000
דברים שאתה אוהב, דברים שאתה לא אוהב?

172
00:10:56,000 --> 00:10:58,000
>> היה לי שאלה.

173
00:10:58,000 --> 00:11:01,000
אולי פספסתי את זה בהסבר שלך, אבל איך עושה תכנית זו

174
00:11:01,000 --> 00:11:07,000
דלג על המרחבים לחיבור המפתח לאורכו של הטקסט?

175
00:11:07,000 --> 00:11:10,000
זה רק קיסר צופן. >> אה, סליחה, כן.

176
00:11:10,000 --> 00:11:13,000
כן, אנחנו נראה את זה.

177
00:11:13,000 --> 00:11:16,000
בצופן הקיסר ממש הספקנו כי בגלל

178
00:11:16,000 --> 00:11:18,000
אנחנו התהפכנו תווים בלבד.

179
00:11:18,000 --> 00:11:27,000
אנחנו מסובבים אותם רק אם הם היו רישיות או קטנים.

180
00:11:27,000 --> 00:11:32,000
אתם מרגישים די טובים בזה?

181
00:11:32,000 --> 00:11:34,000
תרגיש חופשי להעתיק את זה הביתה, קח אותה,

182
00:11:34,000 --> 00:11:37,000
להשוות את זה למה שאתם כתבתם.

183
00:11:37,000 --> 00:11:42,000
בהחלט אל תהסס לשלוח שאלות על זה יותר מדי.

184
00:11:42,000 --> 00:11:46,000
ושוב, מבין שהמטרה כאן עם הבעיה שלך קובעת

185
00:11:46,000 --> 00:11:50,000
לא לקבל אתכם לכתוב קוד מושלם לסטי הבעיה שלך.

186
00:11:50,000 --> 00:11:57,000
זה חוויה לימודית. כן.

187
00:11:57,000 --> 00:12:01,000
>> חזור לעשות בזמן לולאה, אם זה שווה אפס,

188
00:12:01,000 --> 00:12:06,000
כל כך ריק פשוט לא אומר כלום, הם פשוט פגעו להיכנס?

189
00:12:06,000 --> 00:12:12,000
Null הוא ערך מצביע מיוחד,

190
00:12:12,000 --> 00:12:17,000
ואנחנו משתמשים באפס כאשר אנו רוצים לומר

191
00:12:17,000 --> 00:12:23,000
יש לנו משתנה מצביע שמצביע על כלום.

192
00:12:23,000 --> 00:12:28,000
וכך בדרך כלל זה אומר שזה משתנה, משתנה הודעה זו

193
00:12:28,000 --> 00:12:35,000
הוא ריק, וכאן, מכיוון שאנחנו משתמשים בסוג מחרוזת CS50 המיוחד,

194
00:12:35,000 --> 00:12:37,000
מה הוא סוג המחרוזת CS50?

195
00:12:37,000 --> 00:12:42,000
ראית מה זה כאשר הדוד משך את הברדס בהרצאה?

196
00:12:42,000 --> 00:12:44,000
זה פאנקי-זה מצביע, נכון?

197
00:12:44,000 --> 00:12:48,000
בסדר, כן. >> זה * char.

198
00:12:48,000 --> 00:12:52,000
וכך באמת היינו יכול להחליף את זה

199
00:12:52,000 --> 00:12:56,000
ממש כאן בהודעה * char,

200
00:12:56,000 --> 00:13:04,000
וכן פונקצית GetString, אם הוא לא מקבל מחרוזת בהצלחה מהמשתמש,

201
00:13:04,000 --> 00:13:08,000
זה לא יכול לנתח מחרוזת, ומקרה אחד שבו לא ניתן לנתח את המחרוזת

202
00:13:08,000 --> 00:13:11,000
הוא אם המשתמש מקליד הקצה של אופי קובץ, שליטת D,

203
00:13:11,000 --> 00:13:17,000
וזה לא משהו שאתה בדרך כלל עושה, אבל אם זה קורה

204
00:13:17,000 --> 00:13:20,000
אז הפונקציה תחזיר ערך ריק זה כדרך של אמירה

205
00:13:20,000 --> 00:13:23,000
"היי, אני לא מקבל מחרוזת".

206
00:13:23,000 --> 00:13:27,000
מה היה קורה אם לא יכניס את ההודעה = null,

207
00:13:27,000 --> 00:13:30,000
וזה משהו שאנחנו לא היו עושים זאת?

208
00:13:30,000 --> 00:13:32,000
למה שזה יהיה בעיה כאן?

209
00:13:32,000 --> 00:13:38,000
כי אני יודע שדברנו קצת בהרצאה על דליפות זיכרון.

210
00:13:38,000 --> 00:13:42,000
כן, בואו נעשה את זה, ובואו נראים מה יקרה.

211
00:13:42,000 --> 00:13:44,000
>> שאלתו של באסל היא מה קורה אם אנחנו לא ממש צריכים

212
00:13:44,000 --> 00:13:48,000
הודעה זו = מבחן ריק?

213
00:13:48,000 --> 00:13:51,000
בואו לגלול עד למעלה.

214
00:13:51,000 --> 00:13:53,000
אתם יכולים להגיב על זה.

215
00:13:53,000 --> 00:13:55,000
למעשה, אני אשמור אותו במהדורה.

216
00:13:55,000 --> 00:13:58,000
זו תהיה גרסה 3.

217
00:13:58,000 --> 00:14:02,000
מה שתצטרך לעשות כדי להפעיל תכנית זו הוא שאתה צריך ללחוץ על סמל גלגל השיניים הזה כאן,

218
00:14:02,000 --> 00:14:04,000
ואתה תצטרך להוסיף טיעון אליו.

219
00:14:04,000 --> 00:14:10,000
אתה צריך לתת לו הנימוק המכריע מכיוון שאנחנו רוצים להעביר בארגומנט שורת פקודה.

220
00:14:10,000 --> 00:14:13,000
הנה אני הולך לתת לו את המספר 3. אני אוהב 3.

221
00:14:13,000 --> 00:14:19,000
עכשיו טס חזרה החוצה, להפעיל את התכנית.

222
00:14:19,000 --> 00:14:24,000
זה פועל, קומפילציה, בנייה.

223
00:14:24,000 --> 00:14:27,000
הנה אנחנו מתחילים. הוא מחכה שליתבקש.

224
00:14:27,000 --> 00:14:33,000
אם אני מקליד במשהו כמו שלום, להיכן שתלך?

225
00:14:33,000 --> 00:14:38,000
אה, התכנית שלי לקחה יותר מדי זמן כדי לרוץ. אני אפטפט יותר מדי זמן.

226
00:14:38,000 --> 00:14:40,000
הנה זה מתחיל.

227
00:14:40,000 --> 00:14:43,000
עכשיו אני מקליד בשלום.

228
00:14:43,000 --> 00:14:46,000
אנו רואים כי היא מצפינה כראוי.

229
00:14:46,000 --> 00:14:52,000
עכשיו מה קורה אם אנחנו עושים GetString פקודה להחזיר null?

230
00:14:52,000 --> 00:14:57,000
זכרו, אמרתי שעשינו את זה על ידי לחיצה על השלט D באותו הזמן.

231
00:14:57,000 --> 00:14:59,000
אני לגלול עד כאן. אנחנו נפעיל אותו שוב.

232
00:14:59,000 --> 00:15:01,000
בניין. הנה זה מתחיל.

233
00:15:01,000 --> 00:15:04,000
עכשיו כשאני מכה שליטה D

234
00:15:04,000 --> 00:15:12,000
יש לי את הקו הזה שאומר opt/sandbox50/bin/run.sh, אשמת פילוח.

235
00:15:12,000 --> 00:15:15,000
האם אתם ראיתם את זה קודם?

236
00:15:15,000 --> 00:15:17,000
>> [סטודנטים] מדוע אין->> מצטער?

237
00:15:17,000 --> 00:15:20,000
[סטודנטים] מדוע אין מזבלת ליבה במקרה זה?

238
00:15:20,000 --> 00:15:26,000
מזבלת הליבה היא השאלה מדוע אין מזבלת ליבה כאן?

239
00:15:26,000 --> 00:15:29,000
השאלה היא כי ייתכן שיש, אבל מזבלת הליבה היא קובץ

240
00:15:29,000 --> 00:15:31,000
שמאוחסן בכונן הקשיח.

241
00:15:31,000 --> 00:15:34,000
במקרה זה השבתנו מרוקן ליבה

242
00:15:34,000 --> 00:15:37,000
בשרת הטווח כך שאין לנו אנשי צינוק העתקים גיאולוגיים

243
00:15:37,000 --> 00:15:40,000
ובניית טונות של מצבורי ליבה.

244
00:15:40,000 --> 00:15:46,000
אבל אתה יכול לקבל אחד.

245
00:15:46,000 --> 00:15:48,000
מרוקן ליבה הוא מסוג דברים שלעתים קרובות אתה יכול לבטל,

246
00:15:48,000 --> 00:15:52,000
ולפעמים אתה עושה.

247
00:15:52,000 --> 00:15:55,000
אשמת הפילוח, כדי לענות על שאלתך, בזיל,

248
00:15:55,000 --> 00:16:00,000
הוא אומר שניסינו לגשת מצביע

249
00:16:00,000 --> 00:16:05,000
שלא הוקם כדי להצביע על שום דבר.

250
00:16:05,000 --> 00:16:09,000
זכור ינקי בוידאו כשהינקי מנסה

251
00:16:09,000 --> 00:16:12,000
ללכת לגשת מצביע שלא מצביע על שום דבר?

252
00:16:12,000 --> 00:16:16,000
במקרה זה אני מניח שטכני המצביע מצביע על משהו.

253
00:16:16,000 --> 00:16:20,000
זה מצביע על אפס, שהוא טכני 0,

254
00:16:20,000 --> 00:16:25,000
אבל זה מוגדר להיות בקטע שאינו נגיש

255
00:16:25,000 --> 00:16:28,000
לפי התכנית שלך, כך שאתה מקבל אשמת פילוח

256
00:16:28,000 --> 00:16:31,000
כי אתה לא גישה לזיכרון שהוא בקטע חוקי

257
00:16:31,000 --> 00:16:38,000
כמו קטע הערימה או מחסנית או קטע קטע הנתונים.

258
00:16:38,000 --> 00:16:40,000
מגניב.

259
00:16:40,000 --> 00:16:48,000
עוד שאלות על קיסר?

260
00:16:48,000 --> 00:16:51,000
>> בואו נעבור הלאה. בואו נסתכל על גרסה 2 ממש במהירות.

261
00:16:51,000 --> 00:17:00,000
זה Vigenère.

262
00:17:00,000 --> 00:17:04,000
כאן בVigenère

263
00:17:04,000 --> 00:17:06,000
נדריך אותו דרך האתר הזה די מהר כי, שוב,

264
00:17:06,000 --> 00:17:10,000
Vigenère וקיסר הם די דומים.

265
00:17:10,000 --> 00:17:12,000
תגובת הכותרת היא לפני,

266
00:17:12,000 --> 00:17:17,000
# Define הוא לפני להימנע משימוש במספרי הקסם האלה.

267
00:17:17,000 --> 00:17:21,000
דבר הנחמד הוא לומר שאנחנו רוצים לעבור ל

268
00:17:21,000 --> 00:17:23,000
האלפבית שונה או משהו כזה.

269
00:17:23,000 --> 00:17:26,000
במקום שיש ללכת לשנות באופן ידני את כל 26 של בקוד

270
00:17:26,000 --> 00:17:30,000
אנחנו יכולים לשנות את זה ל 27 או לשלשל אותה

271
00:17:30,000 --> 00:17:34,000
אם הייתי משתמשים באותיות שונות, בשפות שונות.

272
00:17:34,000 --> 00:17:38,000
שוב, יש לנו סימון זו של ספירת הוויכוח,

273
00:17:38,000 --> 00:17:42,000
ובאמת אתה כמעט יכול לקחת את זה כתבנית.

274
00:17:42,000 --> 00:17:46,000
די הרבה בכל תכנית שאתה כותב צריכה-

275
00:17:46,000 --> 00:17:50,000
אם זה לוקח שורת פקודת טיעונים-רצף כלשהו של קווים

276
00:17:50,000 --> 00:17:55,000
שקורא את זה כמו בהתחלה.

277
00:17:55,000 --> 00:17:59,000
זה אחד מבחני השפיות הראשונות שאתה רוצה לעשות.

278
00:17:59,000 --> 00:18:03,000
>> הנה מה שעשינו אנחנו בטוחים ש

279
00:18:03,000 --> 00:18:06,000
מילת המפתח הייתה בתוקף, וכי היה הבדיקה השנייה שעשינו.

280
00:18:06,000 --> 00:18:11,000
שים לב שוב שנפרדנו זה מargc ו 2.

281
00:18:11,000 --> 00:18:14,000
שים לב כי במקרה זה דבר אחד שיש לנו לעשות היה במקום

282
00:18:14,000 --> 00:18:18,000
של השימוש שלאנחנו רוצים לאמת את כל המחרוזת,

283
00:18:18,000 --> 00:18:21,000
וכדי לעשות את זה אתה באמת צריך ללכת תו אחר תו

284
00:18:21,000 --> 00:18:23,000
על המחרוזת.

285
00:18:23,000 --> 00:18:29,000
אין דרך טובה לקרוא משהו על זה

286
00:18:29,000 --> 00:18:31,000
כי גם, למשל, שלאחזיר 0

287
00:18:31,000 --> 00:18:37,000
אם הוא לא יכול לנתח מספר שלם, כך שגם זה לא עובד.

288
00:18:37,000 --> 00:18:42,000
שוב, הודעה נחמדה לספר למשתמש בדיוק מה שקרתה.

289
00:18:42,000 --> 00:18:45,000
אז הנה, שוב, אנחנו מטפלים גם במקרה שבו

290
00:18:45,000 --> 00:18:50,000
המשתמש מקליד באופי אקראי שליטת ד.

291
00:18:50,000 --> 00:18:54,000
>> ואז שארלוט הייתה קודם על שאלה איך אנחנו מצליחין לדלג חללים

292
00:18:54,000 --> 00:18:57,000
במחרוזת שלנו כאן.

293
00:18:57,000 --> 00:19:00,000
זה היה די דומה למה שעשינו עם תכנית Myspace

294
00:19:00,000 --> 00:19:04,000
שעשינו בסעיף, והדרך זה עבדה

295
00:19:04,000 --> 00:19:08,000
הוא שאנחנו אתרנו את מספר המכתבים שעדיין לא ראו.

296
00:19:08,000 --> 00:19:13,000
כשהלכנו על מחרוזת ההודעה, בלכתי על אופי של דמות,

297
00:19:13,000 --> 00:19:16,000
אנחנו אתרנו את המדד כחלקנו מלולאה, ואז גם במעקב

298
00:19:16,000 --> 00:19:21,000
מספר האותיות, כך תווים שאינם מיוחדים,-ספרות עישון, חלל שאינו לבן

299
00:19:21,000 --> 00:19:27,000
שאנחנו ראינו במשתנה הנפרדת.

300
00:19:27,000 --> 00:19:33,000
ואז פתרון זה משנה את המפתח

301
00:19:33,000 --> 00:19:41,000
כדי לקבל מספר שלם מפתח בפועל, והוא עושה את זה במהירות הבזק,

302
00:19:41,000 --> 00:19:47,000
ממש לפני שהתחיל אז ממשיך להצפין את אופי ההודעה בפועל.

303
00:19:47,000 --> 00:19:50,000
יש כמה פתרונות שהיו מושלם מדי גדולים

304
00:19:50,000 --> 00:19:58,000
שיהיה לשנות את המפתח כאשר בוחנים את תקפותו של המפתח.

305
00:19:58,000 --> 00:20:01,000
בנוסף לוודא שאופי ואת מילת המפתח

306
00:20:01,000 --> 00:20:05,000
היה תו אלפביתי זה גם הפך את זה למספר שלם

307
00:20:05,000 --> 00:20:13,000
ב0-25 לטווח אז לדלג על התהליך לעשות את זה בשלב מאוחר יותר בזה ללולאה.

308
00:20:13,000 --> 00:20:18,000
שוב, אתה רואה כאן זה באמת אותו הקוד המדויק

309
00:20:18,000 --> 00:20:22,000
שהשתמשנו בקיסר בשלב זה.

310
00:20:22,000 --> 00:20:25,000
אתה עושה בדיוק את אותו דבר, ולכן הטריק האמיתי הוא להבין

311
00:20:25,000 --> 00:20:30,000
איך להפוך את מילת המפתח במספר שלם.

312
00:20:30,000 --> 00:20:35,000
>> דבר אחד שעשינו כאן שהוא קצת צפוף

313
00:20:35,000 --> 00:20:39,000
הוא חזרנו על המשפט הזה, אני מניח שאפשר לקרוא לזה,

314
00:20:39,000 --> 00:20:45,000
3 פעמים נפרדות בקווים 58, 59, ו 61.

315
00:20:45,000 --> 00:20:52,000
מישהו יכול להסביר מה בדיוק עושה בביטוי הזה?

316
00:20:52,000 --> 00:20:55,000
זה גישה לאופי, כמו שאמרת.

317
00:20:55,000 --> 00:20:59,000
כן, זה [לא ברור] דמות במילת המפתח,

318
00:20:59,000 --> 00:21:04,000
ואז זה מספר המכתבים ראו כי אתה רק זזת יחד

319
00:21:04,000 --> 00:21:06,000
מילת המפתח ברגע שראית את המכתב,

320
00:21:06,000 --> 00:21:10,000
כך זה הולך בצורה יעילה כדי לדלג רווחים ודברים כאלה.

321
00:21:10,000 --> 00:21:12,000
כן, בדיוק.

322
00:21:12,000 --> 00:21:16,000
ואז ברגע שראית את חסר מילת המפתח אתה פשוט mod כך חזרת לגור בסביבה.

323
00:21:16,000 --> 00:21:18,000
בדיוק. זה הסבר מושלם.

324
00:21:18,000 --> 00:21:23,000
מה אמר קווין הוא שאנחנו רוצים ליצור אינדקס למילת המפתח.

325
00:21:23,000 --> 00:21:28,000
אנחנו רוצים לקבל את תו num_letters_seen, אם נרצה,

326
00:21:28,000 --> 00:21:32,000
אם num_letters_seen חורג מהאורך של מילת המפתח, אבל,

327
00:21:32,000 --> 00:21:37,000
הדרך בה אנו מקבלים בחזרה לתוך הטווח המתאים היא שאנו משתמשים במפעיל mod

328
00:21:37,000 --> 00:21:40,000
ביעילות כדי לעטוף.

329
00:21:40,000 --> 00:21:43,000
לדוגמה, כמו בבקיצור, מילת המפתח שלנו היא בייקון,

330
00:21:43,000 --> 00:21:46,000
וזה עוד 5 אותיות.

331
00:21:46,000 --> 00:21:50,000
אבל ראו כבר 6 אותיות בטקסט הרגיל שלנו בשלב זה

332
00:21:50,000 --> 00:21:52,000
ומוצפן 6.

333
00:21:52,000 --> 00:21:57,000
אנחנו בסופו של גישת num_letters_seen,

334
00:21:57,000 --> 00:22:00,000
שעומדים על 6, mod האורך של מילת המפתח, 5,

335
00:22:00,000 --> 00:22:04,000
ולכן אנחנו מקבלים 1, ואז מה שנעשינו הוא שנהיה

336
00:22:04,000 --> 00:22:14,000
לגשת בתוך התו הראשון של מילות המפתח שלנו בשלב זה.

337
00:22:14,000 --> 00:22:21,000
>> בסדר, כל שאלה על Vigenère

338
00:22:21,000 --> 00:22:26,000
לפני שנמשיך הלאה?

339
00:22:26,000 --> 00:22:31,000
אתם מרגישים די טובים בזה?

340
00:22:31,000 --> 00:22:35,000
מגניב, נהדר.

341
00:22:35,000 --> 00:22:38,000
אני רוצה לוודא שאתם מקבלים את ההזדמנות לראות את הקוד

342
00:22:38,000 --> 00:22:48,000
כי אנחנו חושבים שנראים טוב ויש לי את ההזדמנות ללמוד ממנו.

343
00:22:48,000 --> 00:22:53,000
זה הולך להיות אחרון שאנחנו משתמשים בי רווחים לעת עתה,

344
00:22:53,000 --> 00:22:59,000
ואנחנו הולכים למעבר עכשיו, ואני הולך לcs50.net/lectures

345
00:22:59,000 --> 00:23:06,000
כדי שנוכל לעשות קצת ביקורת חידון.

346
00:23:06,000 --> 00:23:10,000
הדרך הטובה ביותר שאני חושב להתחיל לעשות חידון ביקורת

347
00:23:10,000 --> 00:23:15,000
הוא להגיע לדף הרצאות זו, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
ומתחת לכל אחת מהכותרות בשבוע, כך שאם אני מסתכל כאן בשבוע 0,

349
00:23:20,000 --> 00:23:27,000
אני רואה שיש לנו רשימה של נושאים שכיסינו בשבוע 0.

350
00:23:27,000 --> 00:23:31,000
>> אם כל אחד מהנושאים האלה נראים זר לך

351
00:23:31,000 --> 00:23:34,000
אתה בהחלט רוצה לחזור ולסרוק את סיכומי הרצאות ואולי

352
00:23:34,000 --> 00:23:39,000
אפילו לרחף באמצעות הרצאות, לצפות בם שוב אם אתה רוצה

353
00:23:39,000 --> 00:23:44,000
כדי לקבל תחושה לגבי מה שקורה עם כל אחד מהנושאים האלה.

354
00:23:44,000 --> 00:23:49,000
אני אומר את זה שנה אחת של משאבים המגניבים שיש לנו בנוסף

355
00:23:49,000 --> 00:23:55,000
מכנסיים קצרים הוא אלה שיצרנו, ואם אתה מסתכל על שבוע 0,

356
00:23:55,000 --> 00:24:00,000
אין לנו כל הנושאים המכוסים, אבל יש לנו לא מעט מהם,

357
00:24:00,000 --> 00:24:03,000
כמה מאלה שהכי הממולחים, כך צופים המכנסים האלה שוב

358
00:24:03,000 --> 00:24:08,000
היא דרך טובה כדי להביא לך עד המהירות.

359
00:24:08,000 --> 00:24:15,000
בפרט, אני הולך לשים בתקע ל3 בתחתית, מאז שעשיתי אותם.

360
00:24:15,000 --> 00:24:20,000
אבל אם אתה נאבק עם בינארי, ביטים, hex, דברים כאלה,

361
00:24:20,000 --> 00:24:22,000
בינארי הוא מקום מצוין להתחיל בו.

362
00:24:22,000 --> 00:24:25,000
ASCII הוא עוד אחד זה טוב כדי להציג מדי.

363
00:24:25,000 --> 00:24:31,000
אתה יכול אפילו לצפות לי במהירות 1.5x אם אני מתקדם לאט מדי בשבילך.

364
00:24:31,000 --> 00:24:35,000
מאחר שהסקירה של זה, תרגיש חופשי לעשות את זה.

365
00:24:35,000 --> 00:24:40,000
>> רק כדי להתחיל ממש מהר, אנחנו הולכים לעבור כמה בעיות בחנים אלו

366
00:24:40,000 --> 00:24:44,000
רק כדי נטישה במהירות באמצעות אלה.

367
00:24:44,000 --> 00:24:50,000
לדוגמה, בואו נסתכל על בעיה 16 שיש לי חברים כאן בלוח.

368
00:24:50,000 --> 00:24:54,000
יש לנו חישוב הבא זה בינארי,

369
00:24:54,000 --> 00:24:56,000
ואנחנו רוצים להראות לכל עבודה.

370
00:24:56,000 --> 00:24:59,000
אוקיי, אני הולך לתת את זה זריקה.

371
00:24:59,000 --> 00:25:01,000
אתם צריכים לבצע יחד עם נייר,

372
00:25:01,000 --> 00:25:04,000
ואנחנו נעשה את זה ממש מהר.

373
00:25:04,000 --> 00:25:06,000
אנחנו רוצים לבצע את החישוב הבא בינארי.

374
00:25:06,000 --> 00:25:16,000
יש לי 00110010.

375
00:25:16,000 --> 00:25:27,000
ואני מתכוון להוסיף לזה 00110010.

376
00:25:27,000 --> 00:25:30,000
למתמטיקת גאונים הבאים יחד בבית,

377
00:25:30,000 --> 00:25:35,000
זאת ביעילות היא הכפלה פי 2.

378
00:25:35,000 --> 00:25:37,000
בואו נתחיל.

379
00:25:37,000 --> 00:25:39,000
אנחנו הולכים לבצע את אותו האלגוריתם בנוסף שאנחנו עושים

380
00:25:39,000 --> 00:25:43,000
כאשר מוסיפים מספרים עשרוניים יחד.

381
00:25:43,000 --> 00:25:46,000
באמת ההבדל היחיד כאן הוא שאנחנו לולאה סביב גב

382
00:25:46,000 --> 00:25:51,000
פעם אחת יש לנו 1 + 1 במקום ברגע שאנחנו מקבלים עד 10.

383
00:25:51,000 --> 00:25:53,000
>> אם תתחילו מימין, ממש מהר, מה הספרה ראשונה?

384
00:25:53,000 --> 00:25:55,000
[סטודנטים] 0. >> [נייט ח] 0.

385
00:25:55,000 --> 00:25:58,000
גדול, הספרה השנייה?

386
00:25:58,000 --> 00:26:00,000
[סטודנטים] 1.

387
00:26:00,000 --> 00:26:02,000
[נייט ח'] האם זה 1? 1 + 1 הוא?

388
00:26:02,000 --> 00:26:04,000
[סטודנטים] 10.

389
00:26:04,000 --> 00:26:08,000
[נייט ח] בדיוק, אז מה היא הספרות שאני כותב ממש מתחת ל2 אלה נוספו ביחד?

390
00:26:08,000 --> 00:26:11,000
[סטודנטים] 1, 0, או 0 ולאחר מכן לבצע 1.

391
00:26:11,000 --> 00:26:15,000
[נייט ח] 0 ולבצע 1, בדיוק.

392
00:26:15,000 --> 00:26:18,000
עד אחד, הזיל הבא, אתה למעלה.

393
00:26:18,000 --> 00:26:20,000
מה השלישי? >> [זיל] 1.

394
00:26:20,000 --> 00:26:23,000
[נייט ח] 1, מושלם. קווין?

395
00:26:23,000 --> 00:26:27,000
[קווין] 0. >> [נייט ח] 0, שרלוט?

396
00:26:27,000 --> 00:26:30,000
[שארלוט] 0. >> [נייט ח] כן, ומה עליי לעשות?

397
00:26:30,000 --> 00:26:32,000
[סטודנטים] 1.

398
00:26:32,000 --> 00:26:34,000
[נייט ח] ומה עליי לעשות? ואז אני נושא 1.

399
00:26:34,000 --> 00:26:36,000
מושלם, Sahb? >> [Sahb] עכשיו יש לך 1.

400
00:26:36,000 --> 00:26:40,000
[נייט ח] ועליי לעשות פה משהו?

401
00:26:40,000 --> 00:26:43,000
[Sahb] ואז לאחד הבא יש לך 1 בגלל שנשאת מעל 1.

402
00:26:43,000 --> 00:26:49,000
[נייט ח'] גדול, אז הנה אנחנו יכולים לגמור אותו.

403
00:26:49,000 --> 00:26:51,000
מגניב.

404
00:26:51,000 --> 00:26:54,000
[סטודנטים] האם 0 + 0 = 0?

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0.

406
00:26:56,000 --> 00:27:01,000
1 + 1, כמו שאמרת, הוא 10 או 1, 0, ולא.

407
00:27:01,000 --> 00:27:07,000
10 הן שם מטעים, כי אליי 10 אומרים את המספר 10,

408
00:27:07,000 --> 00:27:12,000
וזה השיגיון של איך אנחנו מייצגים את זה כאשר אנחנו כותבים את זה.

409
00:27:12,000 --> 00:27:20,000
אנחנו מייצגים את המספר 2 על ידי 1, 0, והמספר 10 הוא שונה במקצת.

410
00:27:20,000 --> 00:27:23,000
>> מה סוג של נחמד על בינארי הוא שבאמת אין כל כך הרבה

411
00:27:23,000 --> 00:27:25,000
מקרים שאתה צריך ללמוד.

412
00:27:25,000 --> 00:27:30,000
יש 0 + 0 = 0, 0 + 1 = 1,

413
00:27:30,000 --> 00:27:34,000
1 + 1 הוא 0, ולאחר מכן לבצע 1,

414
00:27:34,000 --> 00:27:37,000
ואז אתה יכול לראות כאן בטור השלישי מימין

415
00:27:37,000 --> 00:27:40,000
היו לנו זה 1, 1, ו 1.

416
00:27:40,000 --> 00:27:43,000
ו1 + 1 + 1 הוא 1,

417
00:27:43,000 --> 00:27:45,000
ואתה נושא עוד 1.

418
00:27:45,000 --> 00:27:48,000
כשאתה עושה בנוסף ינארי, די פשוט.

419
00:27:48,000 --> 00:27:51,000
הייתי עושה עוד כמה מאלה לשפיות לבדוק את עצמכם

420
00:27:51,000 --> 00:27:54,000
לפני שאתה הולך בכי זה

421
00:27:54,000 --> 00:28:00,000
כנראה משהו שנראה בחידון.

422
00:28:00,000 --> 00:28:03,000
עכשיו בואו נעשה הבא זה גם כן.

423
00:28:03,000 --> 00:28:06,000
בואו נעשה את הבעיה 17.

424
00:28:06,000 --> 00:28:12,000
אנחנו הולכים להמיר את המספר הבינארי הבא לעשרוניים.

425
00:28:12,000 --> 00:28:28,000
יש לי 10100111001.

426
00:28:28,000 --> 00:28:33,000
זכור בוידאו בינארי שאני עשיתי

427
00:28:33,000 --> 00:28:36,000
הלכתי דרך כמה דוגמאות, והראיתי כיצד

428
00:28:36,000 --> 00:28:41,000
הכל עובד כשאתה עושה את זה בנקודה עשרונית.

429
00:28:41,000 --> 00:28:45,000
כשאתה עובד בייצוג עשרוני אני חושב שאנחנו

430
00:28:45,000 --> 00:28:48,000
בנקודה זו בחיינו כל כך מומחה בזה כי

431
00:28:48,000 --> 00:28:53,000
זה די קל לחפות על המכניקה של איך זה עובד בפועל.

432
00:28:53,000 --> 00:28:59,000
>> אבל כדי לעשות סיכום מהיר, אם יש לי מספר 137

433
00:28:59,000 --> 00:29:06,000
זה באמת אומר, ושוב, זה בייצוג עשרוני-

434
00:29:06,000 --> 00:29:19,000
המספר 137 בעשרוני פירושו שיש לי 100 + 1 x 3 x 10 + 7 x 1.

435
00:29:19,000 --> 00:29:22,000
כל זה נשאר על המסך.

436
00:29:22,000 --> 00:29:29,000
ואז אם אתה מסתכל על המספרים האלה ממש כאן,

437
00:29:29,000 --> 00:29:34,000
100, 10 ו 1, אתה רואים שהם למעשה כל הסמכויות של 10.

438
00:29:34,000 --> 00:29:43,000
יש לי 10 מ"ר, 10 ¹, ו 10 לאפס.

439
00:29:43,000 --> 00:29:48,000
יש לנו סוג דומה של דבר בינארי,

440
00:29:48,000 --> 00:29:55,000
חוץ מזה שהבסיס שלנו, כפי שאנו מכנים אותו, 2 במקום 10.

441
00:29:55,000 --> 00:29:58,000
10s אלה שכתבתי כאן למטה בתחתית,

442
00:29:58,000 --> 00:30:02,000
10 ² זה, 10 ¹, 10 לאפס, 10 הוא הבסיס שלנו,

443
00:30:02,000 --> 00:30:08,000
והמעריך, 0, 1 או 2,

444
00:30:08,000 --> 00:30:14,000
משתמע מהמיקום של הספרה במספר שאנחנו כותבים.

445
00:30:14,000 --> 00:30:21,000
1, אם אנחנו מסתכלים על זה, זה 1 הוא בעמדת 2.

446
00:30:21,000 --> 00:30:27,000
3 הם בעמדת 1, ו7 הם בעמדת 0.

447
00:30:27,000 --> 00:30:35,000
ככה אנחנו מקבלים את המעריכים השונים מתחת לבסיס שלנו.

448
00:30:35,000 --> 00:30:40,000
>> בעקבות כל להכין מ- למעשה זה, אתה יודע מה?

449
00:30:40,000 --> 00:30:43,000
אנחנו נעשה-איפה כפתורי לבטל ללכת?

450
00:30:43,000 --> 00:30:45,000
הנה זה מתחיל.

451
00:30:45,000 --> 00:30:47,000
אני אוהב את זה לבטל דבר.

452
00:30:47,000 --> 00:30:51,000
בעקבות זאת אני חושב שבשבילי לפחות

453
00:30:51,000 --> 00:30:54,000
הדרך הקלה ביותר להתחיל המרת מספר בינארי

454
00:30:54,000 --> 00:30:57,000
או מספר הקסדצימלי בו הבסיס הוא 16

455
00:30:57,000 --> 00:31:02,000
ולא 10 או 2 הם להמשיך ולכתוב את

456
00:31:02,000 --> 00:31:09,000
הבסיסים ופרשנים לכל המספרים במספר בינארי בראש.

457
00:31:09,000 --> 00:31:14,000
אם נתחיל משמאל לימין שוב,

458
00:31:14,000 --> 00:31:17,000
וזה די מנוגד,

459
00:31:17,000 --> 00:31:23,000
אני אשנה בחזרה לשחור כאן, יש לנו 2 לעמדת 0,

460
00:31:23,000 --> 00:31:27,000
ואז יש לנו 2 ¹, 2 ²,

461
00:31:27,000 --> 00:31:33,000
ולאחר מכן 2 עד 3, 2 ל4, 2 עד 5, 6,

462
00:31:33,000 --> 00:31:39,000
7, 8, 9, 10.

463
00:31:39,000 --> 00:31:41,000
מספרים אלה שכתבתי את כל את המעריכים.

464
00:31:41,000 --> 00:31:48,000
אני כתבתי רק את הבסיסים כאן ב3 ראשונים רק בשביל רווח.

465
00:31:48,000 --> 00:31:50,000
>> בשלב זה אני הולך קדימה, ובעצם אני הולך למחוק

466
00:31:50,000 --> 00:31:53,000
הדברים שעשינו בעשרוני, אם זה בסדר.

467
00:31:53,000 --> 00:31:57,000
כל שיש לך את זה.

468
00:31:57,000 --> 00:32:05,000
אלה מכם צופים באינטרנט אני בטוח שנוכל להחזיר לאחור אותי אם תרצה.

469
00:32:05,000 --> 00:32:07,000
מעבר בחזרה למכלאה.

470
00:32:07,000 --> 00:32:12,000
עכשיו, מה שאנחנו יכולים לעשות, אם אתם לא לגמרי עד מהירות על הכוחות שלך של 2,

471
00:32:12,000 --> 00:32:15,000
זה מגניב לגמרי.

472
00:32:15,000 --> 00:32:18,000
זה קורה. אני מבין.

473
00:32:18,000 --> 00:32:23,000
פעם הייתה לי ראיון עבודה שבו נאמרתי לי שאני צריך לדעת את כל הסמכויות של 2

474
00:32:23,000 --> 00:32:26,000
דרך 2 עד 30.

475
00:32:26,000 --> 00:32:29,000
זה לא היה תפקיד שקבלתי.

476
00:32:29,000 --> 00:32:32,000
בכל מקרה, אתם יכולים ללכת ולעשות את המתמטיקה כאן,

477
00:32:32,000 --> 00:32:35,000
אבל עם ינארי זה לא ממש הגיוני,

478
00:32:35,000 --> 00:32:38,000
וגם לא הגיוני עם עשרוני או הקסדצימאלי או,

479
00:32:38,000 --> 00:32:43,000
כדי לעשות את החשבון שבו אתה צריך אפסים.

480
00:32:43,000 --> 00:32:49,000
אתה יכול לראות שיש לי 0 כאן, כאן 0, 0 כאן, 0 כאן, 0 כאן, 0 כאן.

481
00:32:49,000 --> 00:32:52,000
למה אולי זה לא הגיוני לעשות את המתמטיקה בפועל

482
00:32:52,000 --> 00:32:56,000
כדי לחשב את הכח המתאים של 2 עבור אותה העמדה?

483
00:32:56,000 --> 00:32:59,000
בדיוק כמו שרלוט אמרה, זה יהיה 0.

484
00:32:59,000 --> 00:33:05,000
גם זה עשוי לחסוך לעצמך את הזמן אם חישוב חזק של 2 הוא לא הצד החזק שלך.

485
00:33:05,000 --> 00:33:10,000
במקרה זה אנו רק צריכים לחשב את זה עבור 2 עד 0 שהם?

486
00:33:10,000 --> 00:33:12,000
[סטודנטים] 1.

487
00:33:12,000 --> 00:33:14,000
[נייט ח] 1, 2 ל3 שהם?

488
00:33:14,000 --> 00:33:16,000
[סטודנטים] 8. >> [נייט ח] 8.

489
00:33:16,000 --> 00:33:18,000
2 עד 4?

490
00:33:18,000 --> 00:33:21,000
[סטודנטים] 2. אני מצטער, 1.

491
00:33:21,000 --> 00:33:26,000
[נייט ח] 2 עד 4 הוא 16, בדיוק.

492
00:33:26,000 --> 00:33:28,000
2 עד 5, קווין? >> 32.

493
00:33:28,000 --> 00:33:32,000
[נייט ח] 32, 2 עד 8?

494
00:33:32,000 --> 00:33:38,000
[סטודנטים] 32 x 8, 256.

495
00:33:38,000 --> 00:33:41,000
[נייט ח] מושלם.

496
00:33:41,000 --> 00:33:43,000
ו2 עד 10?

497
00:33:43,000 --> 00:33:45,000
[סטודנטים] 1024.

498
00:33:45,000 --> 00:33:49,000
[נייט ח] כן, 1024.

499
00:33:49,000 --> 00:33:57,000
>> ברגע שיש לנו את המספרים האלה נוכל לסכם את כולם.

500
00:33:57,000 --> 00:34:01,000
וזה המקום שבו באמת חשוב לעשות כמה דברים.

501
00:34:01,000 --> 00:34:07,000
אחד הולך להאט ולבדוק את העבודה שלך.

502
00:34:07,000 --> 00:34:10,000
אתה יכול להגיד שיש 1 בסוף של מספר זה,

503
00:34:10,000 --> 00:34:15,000
אז אני בהחלט צריך לקבל מספר אי זוגי כתוצאה שלי,

504
00:34:15,000 --> 00:34:18,000
משום שכל האחרים הולכים להיות אפילו מספרים

505
00:34:18,000 --> 00:34:21,000
בהתחשב בעובדה שמדובר במספר בינארי.

506
00:34:21,000 --> 00:34:24,000
הדבר השני הוא לעשות אם אתה להגיע לנקודה הזאת במבחן

507
00:34:24,000 --> 00:34:27,000
ואתה כתבת את זה כל כך רחוק

508
00:34:27,000 --> 00:34:30,000
ואתה הולך ואוזל הזמן

509
00:34:30,000 --> 00:34:33,000
מסתכל על מספר הנקודות שבעיה זו היא שווה.

510
00:34:33,000 --> 00:34:40,000
בעיה זו, כפי שאתה יכול לראות, אם אני מדפדף חזרה למחשב הנייד שלי ממש מהר,

511
00:34:40,000 --> 00:34:44,000
בעיה זו היא שווה 2 נקודות, אז זה לא מהסוג בנוסף

512
00:34:44,000 --> 00:34:47,000
אתה צריך ללכת דרך אם אתה באמת לחוץ בזמן.

513
00:34:47,000 --> 00:34:52,000
אבל אנחנו לחזור לאייפד, ואנחנו נעבור את זה ממש מהר.

514
00:34:52,000 --> 00:34:54,000
>> אני אוהב לעשות את המספרים הקטנים 1

515
00:34:54,000 --> 00:34:56,000
משום שאני מוצא שיותר קל.

516
00:34:56,000 --> 00:35:00,000
אני אוהב את 32 ו 8 כי הם הולכים ביחד די בקלות, ואנחנו מקבלים 50.

517
00:35:00,000 --> 00:35:03,000
16 ו 1 מקבלים 17.

518
00:35:03,000 --> 00:35:05,000
יש לנו לקבל 57,

519
00:35:05,000 --> 00:35:14,000
ואז אנחנו יכולים לעשות את השאר לכך, ולכן אנחנו יכולים לעשות 57, 156.

520
00:35:14,000 --> 00:35:16,000
נו באמת.

521
00:35:16,000 --> 00:35:19,000
גבר, טוב, בואו נראים.

522
00:35:19,000 --> 00:35:27,000
היו לנו 57, 256, ו1024.

523
00:35:27,000 --> 00:35:31,000
בשלב זה, אני מעדיף לעבור.

524
00:35:31,000 --> 00:35:35,000
אין לי מושג. הייתי לי ברור שאצטרך לקרוא על זה.

525
00:35:35,000 --> 00:35:40,000
7, 6, 4, אתה מקבלים 17.

526
00:35:40,000 --> 00:35:42,000
1, 5, 5, 2, 13.

527
00:35:42,000 --> 00:35:45,000
ואז אנחנו מקבלים 3, ואז אנחנו מקבלים 1.

528
00:35:45,000 --> 00:35:52,000
1337.

529
00:35:52,000 --> 00:35:55,000
ביצת פסחא, מישהו?

530
00:35:55,000 --> 00:35:59,000
מישהו זיהה את המספר הזה?

531
00:35:59,000 --> 00:36:02,000
כריס מזהה את המספר. מה זה אומר, כריס?

532
00:36:02,000 --> 00:36:04,000
[כריס] לאת.

533
00:36:04,000 --> 00:36:11,000
לאת, כך שאם אתה מסתכל על זה, זה נראה כמו leet.

534
00:36:11,000 --> 00:36:15,000
דברי האקר. היזהר מסוג הזה במבחן מחצית או החידון, ולא.

535
00:36:15,000 --> 00:36:19,000
אם אתה רואה דברים כאלה ואתה תוהה "אה,"

536
00:36:19,000 --> 00:36:22,000
שאולי בעצם אומר משהו.

537
00:36:22,000 --> 00:36:24,000
אני לא יודע. דוד אוהב לשים אותו פנימה

538
00:36:24,000 --> 00:36:26,000
זוהי דרך טובה לשפיות לבדוק את זה.

539
00:36:26,000 --> 00:36:30,000
כמו בסדר, אני יכול לראות מה קורה.

540
00:36:30,000 --> 00:36:34,000
>> זה שבוע דברי 0/Week 1.

541
00:36:34,000 --> 00:36:39,000
אם לחזור למחשב הנייד שלנו עכשיו,

542
00:36:39,000 --> 00:36:46,000
להתרחק, וכמה דברים אחרים.

543
00:36:46,000 --> 00:36:50,000
יש ASCII, שאנחנו כבר עושים הרבה עם קבוצות הבעייתיות.

544
00:36:50,000 --> 00:36:55,000
רעיון זה של ההון א 'מה זה באמת?

545
00:36:55,000 --> 00:36:57,000
לדעת שזה המספר העשרוני השלם.

546
00:36:57,000 --> 00:37:00,000
65 הם מה זה ממופה בטבלת ASCII,

547
00:37:00,000 --> 00:37:03,000
וזה כן איך המחשב כותב אותו,

548
00:37:03,000 --> 00:37:06,000
וככה אנחנו כבר מקבלים משם עם הכתיבה ממש

549
00:37:06,000 --> 00:37:09,000
הון הדמות ודמות אותיות קטנות

550
00:37:09,000 --> 00:37:14,000
בחלק מהפתרונים הללו וערכות בעיה שאתה כבר עושה.

551
00:37:14,000 --> 00:37:16,000
כמה דברים אחרים.

552
00:37:16,000 --> 00:37:25,000
יש לנו הצהרות, הבעות וליאניות, תנאים, לולאות, משתנה וחוטים.

553
00:37:25,000 --> 00:37:29,000
>> כל אלו נראים הגיוניים ברוב המקרים?

554
00:37:29,000 --> 00:37:35,000
חלק ממינוח זה קצת מסריח בזמנים.

555
00:37:35,000 --> 00:37:46,000
אני אוהב לחשוב על הדברים כעל משהו החלק ביותר שמסתיים בנקודת פסיק.

556
00:37:46,000 --> 00:37:51,000
הצהרות כמו x = 7, אשר קובעה משתנית,

557
00:37:51,000 --> 00:37:54,000
קרא כנראה x = 7.

558
00:37:54,000 --> 00:38:01,000
יש להניח x הוא גם סוג שיכול לאחסן המספר 7,

559
00:38:01,000 --> 00:38:05,000
כך שזה int או אולי לצוף או קצר או char,

560
00:38:05,000 --> 00:38:07,000
משהו כזה.

561
00:38:07,000 --> 00:38:12,000
ביטוי הבוליאני משתמש כפול אלה שווים

562
00:38:12,000 --> 00:38:17,000
והמפץ שווה או לא שווה, פחות מ, גדול מ,

563
00:38:17,000 --> 00:38:22,000
קטן או שווה לכל סוג כזה של דברים.

564
00:38:22,000 --> 00:38:28,000
תנאים אז הם הצהרות אם אחרות.

565
00:38:28,000 --> 00:38:32,000
אני זוכר שאתה לא יכול להיות אחר, בלי מקביל אם.

566
00:38:32,000 --> 00:38:37,000
כמו כן, אתה לא יכול להיות אחר אם ללא אם מקביל.

567
00:38:37,000 --> 00:38:40,000
לולאות, זוכרות את 3 סוגים של לולאות אנחנו כבר מכים בך

568
00:38:40,000 --> 00:38:43,000
לזוג האחרון של קטעים וערכות בעייתיות.

569
00:38:43,000 --> 00:38:46,000
שימוש לעשות בשעה שכאשר אתה מקבל קלט משתמש,

570
00:38:46,000 --> 00:38:51,000
באמצעות לולאות בזמן עד מצב מסוים הן אמיתיות,

571
00:38:51,000 --> 00:38:56,000
ולאחר מכן באמצעות אלה ללולאות אם אתה צריך

572
00:38:56,000 --> 00:39:01,000
יודע שאיטרציה של הלולאה אתה כרגע על הדרך בה אני חושב על זה.

573
00:39:01,000 --> 00:39:07,000
או אם אתה עושה עבור כל תו במחרוזת שאני רוצה לעשות משהו,

574
00:39:07,000 --> 00:39:15,000
לכל רכיב במערך שאני רוצה לעשות משהו כדי שהאלמנט.

575
00:39:15,000 --> 00:39:18,000
>> נושאים ואירועים.

576
00:39:18,000 --> 00:39:21,000
אנחנו אלה שאינם מכוסים על כך במפורש ב-C,

577
00:39:21,000 --> 00:39:23,000
אבל זוכר את זה מהתחלה.

578
00:39:23,000 --> 00:39:26,000
זה הרעיון שיש תסריטים שונים.

579
00:39:26,000 --> 00:39:32,000
זהו גם רעיון זה של שידור אירוע.

580
00:39:32,000 --> 00:39:37,000
יש אנשים שלא השתמש בשידור בפרויקטים שלהם בתחילה,

581
00:39:37,000 --> 00:39:40,000
שהוא מגניב לגמרי,

582
00:39:40,000 --> 00:39:46,000
אבל אלה הם 2 דרכים שונות לטיפול בנושא הגדול הזה שנקראים מקביליות,

583
00:39:46,000 --> 00:39:49,000
אשר הוא איך אתה מקבל תוכניות לביצוע

584
00:39:49,000 --> 00:39:54,000
לכאורה או לבצע באותו הזמן?

585
00:39:54,000 --> 00:39:59,000
משימות שונות פועלות בזמן משימות אחרות גם פועלות.

586
00:39:59,000 --> 00:40:01,000
כך מערכת ההפעלה שלך נראית עבודה.

587
00:40:01,000 --> 00:40:04,000
זו הסיבה שלמרות ש, למשל,

588
00:40:04,000 --> 00:40:10,000
אני כבר הלכתי לדפדפן שלי פועל, אני יכול גם להפעיל את Spotify ולנגן שיר.

589
00:40:10,000 --> 00:40:14,000
זה יותר עניין רעיוני להבנה.

590
00:40:14,000 --> 00:40:17,000
הייתי אסתכל על אשכולות הקצרים

591
00:40:17,000 --> 00:40:21,000
אם אתה רוצה ללמוד יותר על זה.

592
00:40:21,000 --> 00:40:26,000
>> בואו נראים, אני מאמין שאולי היה

593
00:40:26,000 --> 00:40:31,000
בעיה בזה באחד מאלה.

594
00:40:31,000 --> 00:40:35,000
שוב, אני חושב שנושאים ואירועים הם לא משהו שאנחנו נכסה ב-C

595
00:40:35,000 --> 00:40:41,000
רק בגלל שזה הרבה יותר קשה מאשר בהתחלה.

596
00:40:41,000 --> 00:40:44,000
אתה לא צריך לדאוג בקשר לזה שם, אבל בהחלט מבין את המושגים,

597
00:40:44,000 --> 00:40:47,000
להבין מה קורה.

598
00:40:47,000 --> 00:40:52,000
לפני שנמשיך הלאה, כל שאלות בשבוע 0 חומריות?

599
00:40:52,000 --> 00:40:55,000
כולם מרגישים די טובים?

600
00:40:55,000 --> 00:41:03,000
משתני הבנה ומה שמשתנה הם?

601
00:41:03,000 --> 00:41:08,000
>> ימשיך הלאה. שבוע 1.

602
00:41:08,000 --> 00:41:12,000
כמה דברים כאן שלא היו מכוסים במיוחד

603
00:41:12,000 --> 00:41:21,000
בביקורת החידון בהכרח וגם דברים רעיוניים יותר לחשוב עליהם.

604
00:41:21,000 --> 00:41:30,000
הראשון הוא זה מושג מה קוד מקור, מהדרים וקוד אובייקט נמצאים.

605
00:41:30,000 --> 00:41:32,000
מישהו? זיל.

606
00:41:32,000 --> 00:41:37,000
האם אובייקט קוד אני מתכוון קוד המקור הוא מה שאתה מכניס את הצלצול,

607
00:41:37,000 --> 00:41:42,000
וגם קוד אובייקט הוא מה שמוציא צלצול, כך שהמחשב שלך יכול לקרוא את התכנית.

608
00:41:42,000 --> 00:41:44,000
בדיוק.

609
00:41:44,000 --> 00:41:47,000
קוד המקור הוא קוד C שאתה בעצם מקליד את.

610
00:41:47,000 --> 00:41:50,000
קוד יעד הוא מה שאתה מקבל מצלצול.

611
00:41:50,000 --> 00:41:54,000
זה 0s ו 1s שבתבנית בינארית.

612
00:41:54,000 --> 00:41:59,000
ואז מה שקורה הוא כאשר יש לך חבורה של קבצי אובייקט,

613
00:41:59,000 --> 00:42:04,000
אומר אתה קומפילצית פרויקט או תכנית שמשתמשת בקוד מקור קבצים מרובים,

614
00:42:04,000 --> 00:42:09,000
אשר לפי אמנה ניתנת. סיומת קובץ ג.

615
00:42:09,000 --> 00:42:13,000
זו הסיבה שיש לנו caesar.c, vigenère.c.

616
00:42:13,000 --> 00:42:18,000
אם אתה כותב תוכניות Java אתה נותן להם את הסיומת. Java.

617
00:42:18,000 --> 00:42:24,000
תוכניות פייתון יש סיומת. py לעתים קרובות.

618
00:42:24,000 --> 00:42:26,000
>> ברגע שיש לך קבצים מרובים ג., אתה לקמפל אותם.

619
00:42:26,000 --> 00:42:29,000
קלאנג יורק את כל זבל בינארי זה.

620
00:42:29,000 --> 00:42:33,000
אז בגלל שאתה רוצה תכנית 1 בלבד

621
00:42:33,000 --> 00:42:37,000
יש לך קישור המקשר כל אובייקט אלה קבצים יחד

622
00:42:37,000 --> 00:42:40,000
לקובץ הפעלה 1.

623
00:42:40,000 --> 00:42:45,000
זה גם מה שקורה כאשר אתה משתמש בספריית CS50, למשל.

624
00:42:45,000 --> 00:42:50,000
ספריית CS50 היא גם ש. קובץ כותרת h

625
00:42:50,000 --> 00:42:53,000
שאתה קורא, ש# includecs50.h.

626
00:42:53,000 --> 00:42:58,000
ואז זה גם קובץ בינארי ספרייה מיוחד

627
00:42:58,000 --> 00:43:02,000
זה שנאסף היא 0s ו 1s,

628
00:43:02,000 --> 00:43:08,000
וש- l דגל, אז אם אנחנו חוזרים למקומות שלנו ואנחנו נראים ממש מהר

629
00:43:08,000 --> 00:43:11,000
במה שקורה כאן כאשר אנו מסתכלים בפקודת הצלצול שלנו,

630
00:43:11,000 --> 00:43:15,000
מה שיש לנו הוא זה קובץ קוד המקור שלנו כאן.

631
00:43:15,000 --> 00:43:18,000
אלה הם חבורה של דגלי מהדר.

632
00:43:18,000 --> 00:43:22,000
ואז ממש בסוף, אלה-l קישור בדגלים

633
00:43:22,000 --> 00:43:30,000
את הקבצים בינאריים בפועל עבור 2 ספריות אלה, CS50 ספרייה ואז ספריית המתמטיקה.

634
00:43:30,000 --> 00:43:35,000
>> הבנה כל סוג של המטרה 'קבצים

635
00:43:35,000 --> 00:43:38,000
בתהליך ההידור הוא משהו שאתה רוצה להיות מסוגל

636
00:43:38,000 --> 00:43:43,000
לתת לפחות סקירת רמה גבוהה של.

637
00:43:43,000 --> 00:43:46,000
קוד המקור נכנס קוד אובייקט שיוצא.

638
00:43:46,000 --> 00:43:53,000
קבצי קוד אובייקט לקשר יחד, ואתה מקבל קובץ יפה, הפעלה.

639
00:43:53,000 --> 00:43:55,000
מגניב.

640
00:43:55,000 --> 00:43:58,000
זהו גם איפה אתה יכול לקבל טעויות בנקודות מרובות

641
00:43:58,000 --> 00:44:00,000
בתהליך ההידור.

642
00:44:00,000 --> 00:44:04,000
זה המקום בו, למשל, אם אתה לוקח את דגל הקישור הזה,

643
00:44:04,000 --> 00:44:10,000
CS50 הדגל, ואתה משמיט אותו בחדרים או כאשר אתה מפעיל את הקוד שלך,

644
00:44:10,000 --> 00:44:13,000
זה שבו יקבל שגיאה בשלב הקישור,

645
00:44:13,000 --> 00:44:18,000
והמקשר יגידו, "היי, אתה נקרא GetString פונקציה

646
00:44:18,000 --> 00:44:20,000
זה בCS50 הספרייה. "

647
00:44:20,000 --> 00:44:25,000
"אתה אמרת לי שזה היה בCS50 הספרייה, ואני לא מצליח למצוא את הקוד שלו."

648
00:44:25,000 --> 00:44:28,000
זה שבו אתה צריך לקשר אותו ב, וזה נפרד

649
00:44:28,000 --> 00:44:33,000
משגיאת מהדר כי המהדר הוא מחפש בתחביר ובסוג כזה של דברים.

650
00:44:33,000 --> 00:44:38,000
זה טוב לדעת מה קורה מתי.

651
00:44:38,000 --> 00:44:42,000
>> דברים אחרים כדי לדעת.

652
00:44:42,000 --> 00:44:49,000
הייתי אומר שאתה בהחלט רוצה להעיף מבט הקצר על ליהוק שחקנים נעשה על ידי ירדן

653
00:44:49,000 --> 00:44:55,000
כדי להבין מה ints הוא מתחת למכסת המנוע,

654
00:44:55,000 --> 00:44:58,000
מה תווים הם מתחת למכסת המנוע.

655
00:44:58,000 --> 00:45:02,000
כאשר אנו מדברים על ASCII ואנחנו באמת מסתכלים על טבלת ASCII,

656
00:45:02,000 --> 00:45:07,000
מה שהוא עושה הוא נותן לנו תחת מבט הברדס

657
00:45:07,000 --> 00:45:13,000
כיצד המחשב מייצג הון בפועל ו7 ספרות

658
00:45:13,000 --> 00:45:17,000
ופסיק וסימן שאלה.

659
00:45:17,000 --> 00:45:20,000
המחשב יש גם דרכים מיוחדות כדי לייצג

660
00:45:20,000 --> 00:45:23,000
המספר 7 כמספר שלם.

661
00:45:23,000 --> 00:45:27,000
יש לו דרך מיוחדת כדי לייצג את המספר 7 כמספר עשרוני,

662
00:45:27,000 --> 00:45:29,000
ואלה הם שונים מאוד.

663
00:45:29,000 --> 00:45:32,000
ליהוק שחקנים הוא איך אתה מספר למחשב "היי, אני רוצה להמיר

664
00:45:32,000 --> 00:45:37,000
מייצוג אחד לייצוג אחר. "

665
00:45:37,000 --> 00:45:40,000
למה שלא נסתכל על זה.

666
00:45:40,000 --> 00:45:44,000
>> הייתי גם להעיף מבט הקצר על ספריות והקצרות על מהדרים.

667
00:45:44,000 --> 00:45:47,000
מי מדבר על התהליך של לקט,

668
00:45:47,000 --> 00:45:53,000
מה היא ספרייה, ולעבור על חלק מהשאלות הללו, כי ייתכן ששואלים.

669
00:45:53,000 --> 00:45:55,000
שאלות על חומר 1 שבוע?

670
00:45:55,000 --> 00:46:03,000
האם יש נושאים כלשהם בכאן שנראים מרתיעים אתה רוצה לכסות?

671
00:46:03,000 --> 00:46:07,000
אני מנסה לפוצץ דרך רוב הנושאים אלה קודם לכן, כדי שנוכל להגיע ל

672
00:46:07,000 --> 00:46:13,000
מצביעים ועושים מעט סיבי של רקורסיה.

673
00:46:13,000 --> 00:46:15,000
מחשבות?

674
00:46:15,000 --> 00:46:19,000
עיקר לכסות?

675
00:46:19,000 --> 00:46:21,000
הגיע זמן לקצת שוקולד אולי?

676
00:46:21,000 --> 00:46:23,000
אתם עובדים דרכו.

677
00:46:23,000 --> 00:46:26,000
אני הולך לשמור על לוגם את הקפה שלי.

678
00:46:26,000 --> 00:46:31,000
שבוע 2.

679
00:46:31,000 --> 00:46:34,000
שיחה טובה, שיחה טובה.

680
00:46:34,000 --> 00:46:38,000
בשבוע 2 שדברנו קצת יותר על פונקציות.

681
00:46:38,000 --> 00:46:43,000
>> בכמה סטי הבעיה הראשונות לא באמת לכתוב כל פונקציות בכל

682
00:46:43,000 --> 00:46:45,000
מלבד איזה תפקיד?

683
00:46:45,000 --> 00:46:47,000
[סטודנטים] ראשי. >> ראשי, בדיוק.

684
00:46:47,000 --> 00:46:51,000
וכך אנו רואים את התלבושות השונות שעיקריים לובשת.

685
00:46:51,000 --> 00:46:54,000
יש אחד שבו לא לוקח טיעונים,

686
00:46:54,000 --> 00:46:58,000
ואנחנו רק אומרים בחלל בין הסוגריים,

687
00:46:58,000 --> 00:47:01,000
ואז יש את האחר שבו אנחנו רוצים לקחת את הארגומנטים בשורת פקודה,

688
00:47:01,000 --> 00:47:08,000
וכפי שראינו, זה שבו יש לך int argc ומערך argv מחרוזת

689
00:47:08,000 --> 00:47:13,000
עכשיו או שבעצם אנחנו נחשפים מחרוזת להיות * char שזה

690
00:47:13,000 --> 00:47:20,000
אנחנו הולכים להתחיל לכתוב אותו כchar * argv ואז סוגריים.

691
00:47:20,000 --> 00:47:22,000
בסט הבעיה 3, אתם ראיתם חבורה של פונקציות,

692
00:47:22,000 --> 00:47:27,000
ואתה יישמת חבורה של פונקציות, לצייר, להסתכל למעלה, לטפס.

693
00:47:27,000 --> 00:47:31,000
אבות הטיפוס כולם כתובים שם בשבילך.

694
00:47:31,000 --> 00:47:33,000
>> מה שאני רוצה לדבר עליו כאן עם פונקציות ממש מהר

695
00:47:33,000 --> 00:47:38,000
הם שיש 3 חלקים אליהם בכל פעם שאתה כותב פונקציה.

696
00:47:38,000 --> 00:47:43,000
אתה צריך לציין את סוג ההחזרה של הפונקציה.

697
00:47:43,000 --> 00:47:46,000
אתה חייב לציין שם לפונקציה, ואז אתה צריך לציין

698
00:47:46,000 --> 00:47:51,000
רשימת הטיעון או רשימת הפרמטרים.

699
00:47:51,000 --> 00:47:57,000
לדוגמה, אם אני הייתי צריך לכתוב פונקציה לסכם חבורה של מספרים שלמים

700
00:47:57,000 --> 00:48:03,000
ואז תחזור אליי הסכום מה יהיה סוג החזרה שלי

701
00:48:03,000 --> 00:48:06,000
אם אני רוצה לסכם מספרים שלמים ולאחר מכן להחזיר את הסכום?

702
00:48:06,000 --> 00:48:12,000
ואז את השם של הפונקציה.

703
00:48:12,000 --> 00:48:27,000
אם אני ממשיך וכותב בירוק, החלק הזה הוא סוג התמורה.

704
00:48:27,000 --> 00:48:34,000
חלק זה הוא שם.

705
00:48:34,000 --> 00:48:40,000
ואז בסוגריים

706
00:48:40,000 --> 00:48:46,000
מקום שבו אני נותן את הטיעונים,

707
00:48:46,000 --> 00:48:56,000
לעתים קרובות מקוצר כמו ארגומנטים, הנקראים לפעמים params לפרמטרים.

708
00:48:56,000 --> 00:49:00,000
ואם יש לך אחד, אתה פשוט לציין את אחד.

709
00:49:00,000 --> 00:49:06,000
אם יש לך מספר רב לך להפריד כל אחד מהם בפסיק.

710
00:49:06,000 --> 00:49:13,000
ולכל טיעון שאתה נותן לו 2 דברים שהם, קווין?

711
00:49:13,000 --> 00:49:18,000
[קווין] אתה צריך לתת את הסוג ולאחר מכן את השם.

712
00:49:18,000 --> 00:49:21,000
ואז את השם, והשם הוא השם שאתה הולך להשתמש

713
00:49:21,000 --> 00:49:25,000
כדי להתייחס לטענה שבתוך פונקצית הסכום,

714
00:49:25,000 --> 00:49:27,000
בתוך הפונקציה שכרגע אתה כותב.

715
00:49:27,000 --> 00:49:32,000
>> אתה לא צריך, למשל, אם אני הולך לסיכום,

716
00:49:32,000 --> 00:49:41,000
אומרים, מערך של מספרים שלמים להכין מלעשות מערך int,

717
00:49:41,000 --> 00:49:46,000
ואני אתן לעצמי כמה סוגריים מסולסלים שם,

718
00:49:46,000 --> 00:49:51,000
אז כשאני עובר על מערך לפונקצית הסכום

719
00:49:51,000 --> 00:49:55,000
אני מעביר אותו במקום הראשון של רשימת הוויכוח.

720
00:49:55,000 --> 00:49:59,000
אבל המערך שאני עובר באינו צריך את השם arr.

721
00:49:59,000 --> 00:50:07,000
Arr הולך להיות איך אני מתייחס לטענה שבתוך הגוף של הפונקציה.

722
00:50:07,000 --> 00:50:10,000
הדבר השני שאנחנו צריכים לקחת בחשבון,

723
00:50:10,000 --> 00:50:14,000
וזה קצת שונה מפונקציות, אבל אני חושב שזה נקודה חשובה,

724
00:50:14,000 --> 00:50:20,000
הוא כי ב-C כאשר אני כותב בפונקציה כמו זו

725
00:50:20,000 --> 00:50:29,000
איך אני יודע כמה אלמנטים במערך הזה?

726
00:50:29,000 --> 00:50:31,000
זה במידה מסוימת של שאלה מכשילה.

727
00:50:31,000 --> 00:50:35,000
דברנו על זה קצת בקטע של השבוע שעבר.

728
00:50:35,000 --> 00:50:40,000
איך אני יודע את המספר של אלמנטים בתוך מערך ב-C?

729
00:50:40,000 --> 00:50:44,000
האם יש דרך?

730
00:50:44,000 --> 00:50:49,000
>> מתברר שאין שום דרך לדעת.

731
00:50:49,000 --> 00:50:52,000
אתה צריך לעבור אותו בנפרד.

732
00:50:52,000 --> 00:50:55,000
יש טריק שאתה יכול לעשות

733
00:50:55,000 --> 00:51:00,000
אם אתה נמצא באותה הפונקציה שבמערך הוכרז,

734
00:51:00,000 --> 00:51:04,000
ואתה עובד עם מערך מחסנית.

735
00:51:04,000 --> 00:51:06,000
אבל זה עובד רק אם אתה נמצא באותה הפונקציה.

736
00:51:06,000 --> 00:51:09,000
ברגע שתעבור מערך לפונקציה אחרת או אם הכרזת מערך

737
00:51:09,000 --> 00:51:12,000
ואתה שם את מערך שעל הערימה, שבה השתמש malloc

738
00:51:12,000 --> 00:51:15,000
 ודברים כאלה, אז כל ההימורים מבוטלים.

739
00:51:15,000 --> 00:51:18,000
אז אתה בעצם צריך לעבור מסביב

740
00:51:18,000 --> 00:51:21,000
טיעון מיוחד או פרמטר נוסף

741
00:51:21,000 --> 00:51:23,000
אומר לך כמה גדול הוא המערך.

742
00:51:23,000 --> 00:51:28,000
במקרה זה, הייתי רוצה להשתמש בפסיקים אני מצטער, זה הולך מחוץ למסך כאן

743
00:51:28,000 --> 00:51:32,000
ואני אפגוש אותו בטענה אחרת

744
00:51:32,000 --> 00:51:40,000
 וקוראים לזה int len ​​לאורכו.

745
00:51:40,000 --> 00:51:44,000
>> דבר אחד שעשויה לבוא על החידון

746
00:51:44,000 --> 00:51:49,000
אינו מבקש ממך לכתוב או ליישם פונקציה מסוימת קראה משהו.

747
00:51:49,000 --> 00:51:54,000
אם אנחנו לא נותנים לך את אב טיפוס, ולכן כל העניין הזה כאן,

748
00:51:54,000 --> 00:51:58,000
כל הבלגן הזה נקרא הכרזת פונקציה או אב טיפוס הפונקציה,

749
00:51:58,000 --> 00:52:01,000
זה אחד הדברים הראשונים שאתה רוצה להגדיר בבירור אם זה לא נתון

750
00:52:01,000 --> 00:52:03,000
אליך מייד בחידון.

751
00:52:03,000 --> 00:52:06,000
הטריק האחר שלמדתי הוא ש

752
00:52:06,000 --> 00:52:11,000
אומר שאנחנו עושים לך אב טיפוס של פונקציה, ואנחנו אומרים, "היי, יש לך לכתוב אותו."

753
00:52:11,000 --> 00:52:16,000
בתוך הסוגריים המסולסלים שיש לך על החידון

754
00:52:16,000 --> 00:52:20,000
אם אתה שם לב שיש סוג שיבה ואתה שם לב שטיפוס ההחזרה

755
00:52:20,000 --> 00:52:25,000
הוא משהו אחר מהחלל, מה שאומר שהפונקציה לא מחזירה שום דבר,

756
00:52:25,000 --> 00:52:28,000
אז דבר אחד אתה בהחלט רוצה לעשות הוא לכתוב

757
00:52:28,000 --> 00:52:33,000
איזה משפט חוזר בסופו של הפונקציה.

758
00:52:33,000 --> 00:52:40,000
תמורה, ובמקרה הזה, אנו מכניסים ריקים כי אנחנו רוצים למלא את החסר.

759
00:52:40,000 --> 00:52:44,000
אבל זה גורם לך לחשוב בצורה הנכונה על איך אני הולך לגשת לבעיה זו?

760
00:52:44,000 --> 00:52:49,000
וזה מזכיר לך שאתה הולך לעשות כדי להחזיר ערך

761
00:52:49,000 --> 00:52:51,000
למתקשר של הפונקציה.

762
00:52:51,000 --> 00:52:54,000
>> כן. >> [סטודנטים] האם סגנון יחול כאשר אנחנו כותבים קוד בחידון?

763
00:52:54,000 --> 00:52:58,000
כמו היישור וחומר מסוג הזה? >> [סטודנטים] כן.

764
00:52:58,000 --> 00:53:00,000
לא, לא באותה מידה.

765
00:53:00,000 --> 00:53:09,000
אני חושב שהרבה מזה משהו, אנחנו נבהיר בחידון ביום,

766
00:53:09,000 --> 00:53:15,000
אבל בדרך כלל # לדאוג כולל ודברים כאלה, זה סוג של מחוץ.

767
00:53:15,000 --> 00:53:17,000
[סטודנטים] האם אתה צריך להגיב הקוד הכתוב בכתב היד שלך?

768
00:53:17,000 --> 00:53:19,000
אתה צריך להגיב הקוד הכתוב בכתב היד שלך?

769
00:53:19,000 --> 00:53:24,000
בהתייחסו תמיד טוב, אם אתם מודאגים לגבי זיכוי חלקי

770
00:53:24,000 --> 00:53:29,000
או שאתה רוצה שכוונתך לכיתה.

771
00:53:29,000 --> 00:53:33,000
אבל, שוב, יבהיר בחידון עצמו וביום החידון,

772
00:53:33,000 --> 00:53:39,000
אבל אני לא מאמין שאתה תהיה נדרש כדי לכתוב הערות, לא.

773
00:53:39,000 --> 00:53:42,000
בדרך כלל לא, אבל זה בהחלט מסוג הדברים שבי

774
00:53:42,000 --> 00:53:45,000
אתה יכול לתקשר הכוונה שלך, כמו "היי, זה לאן אני הולך עם זה".

775
00:53:45,000 --> 00:53:49,000
ולפעמים זה יכול לעזור עם זיכוי חלקי.

776
00:53:49,000 --> 00:53:51,000
מגניב.

777
00:53:51,000 --> 00:53:53,000
>> זיל.

778
00:53:53,000 --> 00:53:56,000
[זיל] מה ההבדל בין הכרזה, אומר, int lang

779
00:53:56,000 --> 00:54:03,000
בטיעונים או הפרמטרים לעומת הכרזה משתנית בתוך הפונקציה?

780
00:54:03,000 --> 00:54:05,000
וואו, קפה ירד לקנה הנשימה.

781
00:54:05,000 --> 00:54:07,000
[זיל] כמו שדברים שאנחנו רוצים לשים בטענות.

782
00:54:07,000 --> 00:54:09,000
כן, זה שאלה גדולה.

783
00:54:09,000 --> 00:54:11,000
איך אתה בוחר מה דברים שאתה רוצה לשים בטענות

784
00:54:11,000 --> 00:54:17,000
לעומת מה דברים שאתה צריך לעשות בתוך הפונקציה?

785
00:54:17,000 --> 00:54:24,000
במקרה זה כללנו את שני אלה כטיעונים

786
00:54:24,000 --> 00:54:29,000
בגלל שהם משהו שכל מי שהולך להשתמש בפונקצית הסכום

787
00:54:29,000 --> 00:54:32,000
צריך לציין את הדברים האלה.

788
00:54:32,000 --> 00:54:35,000
>> פונקצית הסכום, כמו שדברנו עליה, אין כל דרך לדעת

789
00:54:35,000 --> 00:54:40,000
כמה גדול הוא המערך שהיא מקבלת מהמתקשר שלה או מי שמשתמש בפונקצית הסכום.

790
00:54:40,000 --> 00:54:44,000
יש לו כל דרך לדעת כמה גדול הוא מערך ש.

791
00:54:44,000 --> 00:54:48,000
הסיבה שאנו עוברים באורך זה ממש כאן כטיעון

792
00:54:48,000 --> 00:54:51,000
בגלל שזה משהו שאנחנו בעצם אומרים את המתקשר של הפונקציה,

793
00:54:51,000 --> 00:54:55,000
מי שמתכוון להשתמש בפונקציית הסיכום, "היי, לא רק שאתה צריך לתת לנו מערך

794
00:54:55,000 --> 00:54:59,000
של ints, אתה גם צריך לספר לנו עד כמה גדול המערך שנתת לנו הוא ".

795
00:54:59,000 --> 00:55:03,000
[זיל] אלה יהיו גם יהיו טיעוני שורת פקודה?

796
00:55:03,000 --> 00:55:06,000
לא, אלה הם טענות ממשיות שתעברו לפונקציה.

797
00:55:06,000 --> 00:55:10,000
>> תן לי לעשות דף חדש כאן.

798
00:55:10,000 --> 00:55:13,000
[הזיל] כמו שם יעבור-

799
00:55:13,000 --> 00:55:24,000
[נייט ח] אם יש לי int ראשי (ריק),

800
00:55:24,000 --> 00:55:27,000
ואני הולך לשים ב0 החזרה שלי כאן למטה בתחתית,

801
00:55:27,000 --> 00:55:31,000
ואומר שאני רוצה לקרוא את פונקצית הסכום.

802
00:55:31,000 --> 00:55:42,000
אני רוצה לומר int x = סכום ();

803
00:55:42,000 --> 00:55:46,000
כדי להשתמש בפונקציית הסכום אני צריך לעבור גם במערך שאני רוצה לסכם

804
00:55:46,000 --> 00:55:51,000
והאורך של המערך, כך שזה המקום שבי

805
00:55:51,000 --> 00:55:54,000
בהנחה שיש לי מערך של ints,

806
00:55:54,000 --> 00:56:12,000
אומרים לי int numbaz [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
סוג של שימוש שטבח את התחביר נכון לשם,

808
00:56:16,000 --> 00:56:21,000
אז מה הייתי עושה הוא בסכום שהייתי רוצה להעביר ב

809
00:56:21,000 --> 00:56:27,000
שניהם numbaz והמספר 3

810
00:56:27,000 --> 00:56:30,000
לספר את פונקצית הסכום "אוקיי, הנה המערך אני רוצה לסכם".

811
00:56:30,000 --> 00:56:34,000
"הנה הגודל שלה".

812
00:56:34,000 --> 00:56:39,000
האם זה הגיוני? זה עונה על שאלתך?

813
00:56:39,000 --> 00:56:42,000
>> במובנים רבים הוא עושה במקביל את מה שאנחנו עושים עם ראשיים

814
00:56:42,000 --> 00:56:44,000
כאשר יש לנו את טיעוני שורת הפקודה.

815
00:56:44,000 --> 00:56:47,000
תכנית כמו קיסר צופן, למשל, שצריכה

816
00:56:47,000 --> 00:56:53,000
הארגומנטים בשורת פקודה לא יהיו מסוגלים לעשות כל דבר.

817
00:56:53,000 --> 00:56:57,000
זה לא הייתי יודע איך להצפין אם אתה לא אומר לו מה מפתח לשימוש

818
00:56:57,000 --> 00:57:03,000
או אם אתה לא אומר לו מה אתה רוצה מחרוזת להצפנה.

819
00:57:03,000 --> 00:57:08,000
הצגת הודעה לקלט, זה שבו יש לנו 2 מנגנונים שונים

820
00:57:08,000 --> 00:57:14,000
לקחת קלט במשתמש, ללקיחת מידע מהמשתמש.

821
00:57:14,000 --> 00:57:19,000
לבעית הגדרה 1 ראינו GetInt זה GetString הדרך, GetFloat

822
00:57:19,000 --> 00:57:26,000
של הנחיה לקלט, וזה נקרא שימוש בזרימת הקלט הסטנדרטית.

823
00:57:26,000 --> 00:57:28,000
זה קצת שונה.

824
00:57:28,000 --> 00:57:31,000
זה משהו שאתה יכול לעשות בזמן זה בניגוד ל

825
00:57:31,000 --> 00:57:35,000
כשאתה מזכיר את התכנית, כאשר אתה מפעיל את תכנית ריצה.

826
00:57:35,000 --> 00:57:41,000
טיעוני שורת הפקודה כולם ציינו בעת להתחיל להפעיל את התכנית.

827
00:57:41,000 --> 00:57:47,000
אנחנו כבר ערבוב שני אלה.

828
00:57:47,000 --> 00:57:52,000
כאשר אנו משתמשים בטיעונים לפונקציה, זה הרבה יותר כמו טיעוני שורת פקודה לראשית.

829
00:57:52,000 --> 00:57:56,000
זה כשאתה מזכיר את הפונקציה אתה צריך להגיד את זה

830
00:57:56,000 --> 00:58:05,000
מה בדיוק הוא צריך על מנת לבצע את משימותיו.

831
00:58:05,000 --> 00:58:08,000
עוד דבר טוב להסתכל ואני אתן לך להסתכל על זה בזמנך הפנוי,

832
00:58:08,000 --> 00:58:11,000
והיא הייתה מכוסית בחידון, הייתה זו תפיסה של היקף

833
00:58:11,000 --> 00:58:15,000
ומשתנים מקומיים לעומת משתנים הגלובליים.

834
00:58:15,000 --> 00:58:18,000
האם לשים לב לזה.

835
00:58:18,000 --> 00:58:23,000
>> עכשיו שאנחנו מקבלים על דברים אחרים,

836
00:58:23,000 --> 00:58:27,000
בשבוע 3 התחלנו לדבר על חיפוש ומיון.

837
00:58:27,000 --> 00:58:32,000
חיפוש ומיון, לפחות בCS50,

838
00:58:32,000 --> 00:58:39,000
היא מאוד הקדמה לחלק מהחלקים התיאורטיים יותר של מדעי מחשב.

839
00:58:39,000 --> 00:58:42,000
הבעיה של חיפוש, הבעיה של מיון

840
00:58:42,000 --> 00:58:46,000
בעיות גדולות, קנוניות.

841
00:58:46,000 --> 00:58:52,000
איך אתה מוצא מספר מסוים במערך של מליארד מספרים שלמים?

842
00:58:52,000 --> 00:58:55,000
איך אתה מוצא שם מסוים בתוך ספר טלפונים

843
00:58:55,000 --> 00:58:59,000
שמאוחסן במחשב הנייד?

844
00:58:59,000 --> 00:59:04,000
וכך אנחנו מציגים את הרעיון הזה של לרוץ פעמי asymptotic

845
00:59:04,000 --> 00:59:11,000
באמת לכמת כמה זמן, כמה קשה בעיה אלה,

846
00:59:11,000 --> 00:59:14,000
כמה זמן לוקחים לפתרון.

847
00:59:14,000 --> 00:59:20,000
ב, אני מאמין, חידון של 2011 יש בעיה שאני חושב שראויים

848
00:59:20,000 --> 00:59:27,000
מכסה מהר מאוד, שהוא זה, הבעיה 12.

849
00:59:27,000 --> 00:59:32,000
הו, לא, זה אומגה.

850
00:59:32,000 --> 00:59:41,000
>> כאן אנחנו מדברים על זמן הריצה המהירה ביותר האפשרי

851
00:59:41,000 --> 00:59:46,000
לאלגוריתם מסוים ולאחר מכן זמן הריצה האיטי ביותר האפשרי.

852
00:59:46,000 --> 00:59:52,000
אומגה וO זה הם באמת רק קיצורי דרך.

853
00:59:52,000 --> 00:59:55,000
הם קיצורי סימנים, על שאמרו

854
00:59:55,000 --> 00:59:59,000
כמה מהר במקרה הטוב ניתן יהיה להפעיל האלגוריתם שלנו,

855
00:59:59,000 --> 01:00:06,000
וכיצד איטיים במקרה הגרוע ביותר האפשרי יהיה האלגוריתם שלנו להפעיל?

856
01:00:06,000 --> 01:00:10,000
בואו נעשה כמה כאלה, ואלה היו גם מכוסים

857
01:00:10,000 --> 01:00:13,000
בטווח הקצר בסימון אסימפטוטי, שאני מאוד ממליץ.

858
01:00:13,000 --> 01:00:17,000
ג'קסון עשה עבודה ממש טובה.

859
01:00:17,000 --> 01:00:23,000
בחיפוש בינארי, אנחנו מדברים על חיפוש בינארי כאלגוריתם,

860
01:00:23,000 --> 01:00:28,000
ואנחנו בדרך כלל מדברים על זה במונחים של הגדול O.

861
01:00:28,000 --> 01:00:30,000
מה הוא הגדול O?

862
01:00:30,000 --> 01:00:34,000
מהו זמן הריצה האיטית ביותר האפשרי של החיפוש בינארי?

863
01:00:34,000 --> 01:00:36,000
[סטודנטים] N ²?

864
01:00:36,000 --> 01:00:41,000
סגור, אני מניח דומה לזה.

865
01:00:41,000 --> 01:00:43,000
זה הרבה יותר מהר מאשר זה.

866
01:00:43,000 --> 01:00:45,000
[סטודנטים] בינארי? >> כן, חיפוש בינארי.

867
01:00:45,000 --> 01:00:47,000
[סטודנטים] זה log n.

868
01:00:47,000 --> 01:00:49,000
היכנס n, אז מה עושה להתחבר n אומר?

869
01:00:49,000 --> 01:00:51,000
זה חצי זה כל איטרציה.

870
01:00:51,000 --> 01:00:56,000
בדיוק, אז במקרה האיטי ביותר האפשרי,

871
01:00:56,000 --> 01:01:00,000
אומר שאם יש לך מערך ממוין

872
01:01:00,000 --> 01:01:08,000
של מיליון מספרים שלמים והמספר שאתה מחפש

873
01:01:08,000 --> 01:01:14,000
הוא גם האלמנט הראשון במערך או האלמנט האחרון במערך.

874
01:01:14,000 --> 01:01:18,000
זכור, אלגוריתם החיפוש הבינארי עובד על ידי ההתבוננות באלמנט האמצע,

875
01:01:18,000 --> 01:01:21,000
לראות אם זה המשחק שאתה מחפש.

876
01:01:21,000 --> 01:01:23,000
אם זה הוא, אז נהדר, מצא את זה.

877
01:01:23,000 --> 01:01:27,000
>> במקרה הטוב ביותר, כמה מהר עושה ריצת חיפוש בינארי?

878
01:01:27,000 --> 01:01:29,000
[סטודנטים] 1.

879
01:01:29,000 --> 01:01:32,000
1, זה זמן קבוע, הגדול O של 1. כן.

880
01:01:32,000 --> 01:01:36,000
[סטודנטים] יש לי שאלה. כשאתה אומר להיכנס של n, אתה מתכוון ביחס לבסיס 2, נכון?

881
01:01:36,000 --> 01:01:40,000
כן, אז זה דבר האחר.

882
01:01:40,000 --> 01:01:44,000
אנחנו אומרים n יומן, ואני מניח שכשאני הייתי בתיכון

883
01:01:44,000 --> 01:01:48,000
תמיד הנחית שהיומן היה בסיס 10.

884
01:01:48,000 --> 01:01:57,000
כן, אז כן, להיכנס 2 בסיס בדרך כלל הוא מה שאנו משתמשים.

885
01:01:57,000 --> 01:02:02,000
שוב, לחזור לחיפוש בינארי, אם אתה מחפש או

886
01:02:02,000 --> 01:02:05,000
אלמנט ממש בסוף או האלמנט בהתחלה,

887
01:02:05,000 --> 01:02:08,000
בגלל שאתה מתחיל באמצע ואז אתה זורק

888
01:02:08,000 --> 01:02:13,000
לפי 1/2 אינה עומד בקריטריונים שאתה מחפש,

889
01:02:13,000 --> 01:02:15,000
ואתה הולך למחצית הבאה והמחצית הבאה ובמחצית הבאה.

890
01:02:15,000 --> 01:02:19,000
אם אני מחפש את האלמנט הגבוה ביותר במערך השלם מ'

891
01:02:19,000 --> 01:02:25,000
אני הולך לחצות אותו ביומן ביותר של 1 מ'פעמים

892
01:02:25,000 --> 01:02:28,000
לפני שאני סוף הסוף לבדוק ולראות שהאלמנט שאני מחפש

893
01:02:28,000 --> 01:02:33,000
הוא בגודל או במדד הגבוה ביותר במערך,

894
01:02:33,000 --> 01:02:38,000
ושייקח את היומן של n, היכנס של 1 מ'פעמים.

895
01:02:38,000 --> 01:02:40,000
>> מיון בועות.

896
01:02:40,000 --> 01:02:43,000
האם אתם זוכרים את אלגוריתם מיון הבועות?

897
01:02:43,000 --> 01:02:47,000
קווין, האם אתה יכול לתת לי סיכום מהיר של מה שקרה באלגוריתם מיון הבועות?

898
01:02:47,000 --> 01:02:50,000
[קווין] בעיקרון זה עובר את כל מה שברשימה.

899
01:02:50,000 --> 01:02:52,000
הוא מסתכל על שני הראשונים.

900
01:02:52,000 --> 01:02:55,000
אם הראשון הוא גדול יותר משניית אחת שהחילופים אותם.

901
01:02:55,000 --> 01:02:58,000
לאחר מכן משווה אותו דבר שני ושלישי,, החלפות,

902
01:02:58,000 --> 01:03:00,000
השלישית ורביעית, כל הדרך למטה.

903
01:03:00,000 --> 01:03:03,000
מספרים גדולים יעקבו עד הסוף.

904
01:03:03,000 --> 01:03:07,000
ואחרי לולאות אולם רבות שתסיים.

905
01:03:07,000 --> 01:03:11,000
בדיוק, אז מה אמר קווין הוא שאנחנו נבדוק את המספרים גדולים

906
01:03:11,000 --> 01:03:15,000
בועה עד סוף המערך.

907
01:03:15,000 --> 01:03:19,000
לדוגמה, אכפת לך ללכת דרך דוגמה זו אם זה המערך שלנו?

908
01:03:19,000 --> 01:03:21,000
[קווין] אתה תיקח את 2 ו 3.

909
01:03:21,000 --> 01:03:23,000
3 הם יותר גדולים מ 2, כך שאתה להחליף אותם.

910
01:03:23,000 --> 01:03:29,000
[נייט ח] נכון, ולכן אנחנו להחליפם, ולכן אנחנו מקבלים 2, 3, 6, 4, ו 9.

911
01:03:29,000 --> 01:03:31,000
[קווין] ואז אתה משווה את 3 ו 6.

912
01:03:31,000 --> 01:03:33,000
3 הם יותר קטנים מ 6, אז אתה משאיר אותם,

913
01:03:33,000 --> 01:03:37,000
ו 6 ו 4, שהיית מתחלף איתם, כי 4 הם קטנים יותר מאשר 6.

914
01:03:37,000 --> 01:03:42,000
[נייט ח] נכון, אז אני מקבל 2, 3, 4, 6, 9.

915
01:03:42,000 --> 01:03:46,000
[קווין] ו9 הם גדולים יותר מ 6, ולכן תשאיר אותה.

916
01:03:46,000 --> 01:03:48,000
ואתה הייתי חוזר על זה שוב.

917
01:03:48,000 --> 01:03:50,000
>> [נייט ח'] האם אני עושה בשלב זה? >> [קווין] מס

918
01:03:50,000 --> 01:03:52,000
ולמה אני לא עושה בשלב זה?

919
01:03:52,000 --> 01:03:54,000
כי הוא נראה כמו המערך שלי הוא מסודר. אני מסתכל עליו.

920
01:03:54,000 --> 01:03:57,000
[קווין] עובר על זה שוב ולוודא שאין יותר החלפות

921
01:03:57,000 --> 01:04:00,000
לפני שתוכל להפסיק באופן מלא.

922
01:04:00,000 --> 01:04:04,000
בדיוק, כך שאתה צריך לשמור על עובר ולוודא שאין החלפות

923
01:04:04,000 --> 01:04:06,000
כי אתה יכול לעשות בשלב זה.

924
01:04:06,000 --> 01:04:08,000
למעשה היה זה רק מזל, כמו שאמרת, שאנחנו בסופו

925
01:04:08,000 --> 01:04:12,000
רק שאצטרך להחליט לעבור 1 עד ואנחנו מסודרים.

926
01:04:12,000 --> 01:04:16,000
אבל כדי לעשות זאת במקרה הכללי אנחנו באמת צריכים לעשות את זה שוב ושוב.

927
01:04:16,000 --> 01:04:20,000
ואכן, זו הייתה דוגמה למקרה הטוב ביותר האפשרי,

928
01:04:20,000 --> 01:04:24,000
כמו שראינו בבעיה.

929
01:04:24,000 --> 01:04:28,000
ראה שהמקרה טוב אפשר היה N.

930
01:04:28,000 --> 01:04:32,000
עברנו זמן 1 המערך.

931
01:04:32,000 --> 01:04:35,000
מהו מקרה הגרוע ביותר האפשרי עבור אלגוריתם זה?

932
01:04:35,000 --> 01:04:37,000
[קווין] N ².

933
01:04:37,000 --> 01:04:41,000
ומה זה נראה? מה היית מראה מערך כזה ייקח זמן ² n?

934
01:04:41,000 --> 01:04:43,000
[קווין] [לא ברור] מיון.

935
01:04:43,000 --> 01:04:51,000
בדיוק, כך שאם היה לי את המערך 9, 7, 6, 5, 2,

936
01:04:51,000 --> 01:04:54,000
1 9 הייתם בועה את כל הדרך.

937
01:04:54,000 --> 01:04:59,000
לאחר איטרציה 1 שנהיה לנו 7, 6, 5, 2, 9.

938
01:04:59,000 --> 01:05:07,000
ואז היית בועה עד 7, 6, 5, 2, 7, 9, וכן הלאה וכן הלאה.

939
01:05:07,000 --> 01:05:13,000
>> היינו צריך לעבור את כל המערך n פעמים,

940
01:05:13,000 --> 01:05:16,000
ואתה יכול למעשה לקבל מעט יותר מדויק מזה

941
01:05:16,000 --> 01:05:23,000
כי ברגע שאנחנו כבר עברנו 9 כל הדרך עד למקום האחרון האפשרי שלה

942
01:05:23,000 --> 01:05:26,000
אנחנו יודעים שאנחנו לא צריכים להשוות מול שהרכיב שוב.

943
01:05:26,000 --> 01:05:29,000
ברגע שנתחיל מבעבע 7

944
01:05:29,000 --> 01:05:35,000
אנחנו יודעים שאנחנו יכולים לעצור ברגע נכון לפני 7 9

945
01:05:35,000 --> 01:05:37,000
מאז אנחנו כבר לעומת 9 לזה.

946
01:05:37,000 --> 01:05:46,000
אם אתה עושה את זה בצורה חכמה זה לא באמת, אני מניח, כל כך הרבה זמן.

947
01:05:46,000 --> 01:05:49,000
אתה לא מתכוון להשוות את כל [לא ברור] הצירופים האפשריים

948
01:05:49,000 --> 01:05:55,000
בכל פעם שאתה עובר כל איטרציה.

949
01:05:55,000 --> 01:05:59,000
אבל עדיין, כאשר אנו מדברים על זה גבול עליון שאנו אומרים כי

950
01:05:59,000 --> 01:06:04,000
אתה מסתכל n ² ​​השוואות לאורך כל הדרך.

951
01:06:04,000 --> 01:06:12,000
>> בואו נחזור, ומכיוון שאנחנו מתחילים לקבל קצת קצרים בזמן

952
01:06:12,000 --> 01:06:15,000
הייתי אומר שאתה בהחלט צריך לעבור את שאר טבלה זו,

953
01:06:15,000 --> 01:06:17,000
מלא את כל זה.

954
01:06:17,000 --> 01:06:20,000
לחשוב על דוגמאות. לחשוב על דוגמאות קונקרטיות.

955
01:06:20,000 --> 01:06:22,000
זה ממש שימושי ומועיל לעשות.

956
01:06:22,000 --> 01:06:25,000
למשוך אותו החוצה.

957
01:06:25,000 --> 01:06:28,000
זהו הסוג של טבלה הכמו שאתה עובר במדעי מחשב

958
01:06:28,000 --> 01:06:32,000
אתה באמת צריך להתחיל לדעת אלה על ידי לב.

959
01:06:32,000 --> 01:06:34,000
אלה הם סוגים של שאלות שאתה מקבל בראיונות.

960
01:06:34,000 --> 01:06:36,000
אלה הם מיני דברים שטוב לדעת,

961
01:06:36,000 --> 01:06:41,000
ולחשוב על מקרי הקצה האלה, באמת להבין איך לחשוב על

962
01:06:41,000 --> 01:06:45,000
ידיעה כי לבועה למיין את המערך הגרוע ביותר האפשרי

963
01:06:45,000 --> 01:06:52,000
כדי למיין שבהוא אחד שזה בסדר הפוך.

964
01:06:52,000 --> 01:06:58,000
>> מצביעים. בואו נדבר קצת על מצביעים.

965
01:06:58,000 --> 01:07:03,000
בדקות האחרונות שיש לנו כאן

966
01:07:03,000 --> 01:07:11,000
אני יודע שזה משהו יחד עם קובץ I / O שהוא די חדש.

967
01:07:11,000 --> 01:07:19,000
כאשר אנו מדברים על מצביעי הסיבה שאנחנו רוצים לדבר על מצביעים

968
01:07:19,000 --> 01:07:24,000
משום, אחד, כאשר אנחנו עובדים ב-C

969
01:07:24,000 --> 01:07:33,000
אנחנו באמת ברמה נמוכה למדי בהשוואה לשפות תכנות המודרניות ביותר.

970
01:07:33,000 --> 01:07:38,000
אנחנו למעשה מסוגלים לתפעל את המשתנים בזיכרון,

971
01:07:38,000 --> 01:07:43,000
להבין איפה הם נמצאים ממש בתוכנו זכרון RAM.

972
01:07:43,000 --> 01:07:46,000
לאחר שהלכת על מנת לקחת שיעורים של מערכת הפעלה שתראו

973
01:07:46,000 --> 01:07:48,000
שזה, שוב, סוג של הפשטה.

974
01:07:48,000 --> 01:07:50,000
זה לא באמת המקרה.

975
01:07:50,000 --> 01:07:52,000
יש לנו זיכרון וירטואלי שמסתיר פרטים אלה מאתנו.

976
01:07:52,000 --> 01:07:58,000
>> אבל נכון לעכשיו אתה יכול להניח שכאשר יש לך תכנית,

977
01:07:58,000 --> 01:08:02,000
לדוגמה, כאשר אתה מתחיל לרוץ-תכנית צופן קיסרך

978
01:08:02,000 --> 01:08:06,000
אני אעבור חזרה לiPad שלי ממש מהר,

979
01:08:06,000 --> 01:08:12,000
כי בתכנית מאוד מתחילה, אם יש לך, יניח,

980
01:08:12,000 --> 01:08:15,000
4 ג'יגה RAM של המחשב הנייד שלך,

981
01:08:15,000 --> 01:08:21,000
אתה מקבל להפריש הנתח הזה, ואנחנו קוראים לזה זיכרון RAM.

982
01:08:21,000 --> 01:08:25,000
וזה מתחיל במקום שאנחנו הולכים להתקשר 0,

983
01:08:25,000 --> 01:08:30,000
והיא מסתיימת במקום שאנחנו קוראים 4 ג'יגה.

984
01:08:30,000 --> 01:08:37,000
אני באמת לא יכול לכתוב. ואווה, זה פרוץ.

985
01:08:37,000 --> 01:08:40,000
כאשר התכנית שלך מבצעת

986
01:08:40,000 --> 01:08:44,000
מערכת ההפעלה חורטת את זכרון RAM,

987
01:08:44,000 --> 01:08:51,000
והוא מציין פלחים שונים לחלקים שונים של התכנית שלך לחיות בה

988
01:08:51,000 --> 01:08:58,000
כאן למטה האזור הזה הוא סוג של שטח הפקר.

989
01:08:58,000 --> 01:09:02,000
כשאתה עולה מעט יותר כאן

990
01:09:02,000 --> 01:09:05,000
יש לך את המקום שבו למעשה

991
01:09:05,000 --> 01:09:09,000
הקוד לחיי התכנית שלך.

992
01:09:09,000 --> 01:09:13,000
זה קוד בינארי בפועל, שלמעשה מקבל קובץ ההפעלה נטען לזיכרון

993
01:09:13,000 --> 01:09:17,000
כשאתה מפעיל את תכנית, והוא חי בקטע הקוד.

994
01:09:17,000 --> 01:09:22,000
וכפי שהתכנית שלך מבצעת את המעבד נראה בקטע הקוד הזה

995
01:09:22,000 --> 01:09:24,000
כדי להבין מה היא ההוראה הבאה?

996
01:09:24,000 --> 01:09:27,000
מהי השורה הבאה של קוד אני צריך לבצע?

997
01:09:27,000 --> 01:09:31,000
>> יש גם קטע נתונים, וזה המקום בו אלה קבועי המחרוזת

998
01:09:31,000 --> 01:09:34,000
לקבל מאוחסנים שאתה כבר משתמש.

999
01:09:34,000 --> 01:09:42,000
ואז, קצת יותר למעלה יש המקום הזה שנקרא הערימה.

1000
01:09:42,000 --> 01:09:46,000
אנחנו לגשת לזיכרון לשם באמצעות malloc,

1001
01:09:46,000 --> 01:09:49,000
ולאחר מכן לכיוון חלקו עליון של התכנית שלך

1002
01:09:49,000 --> 01:09:52,000
יש ערימה,

1003
01:09:52,000 --> 01:09:57,000
וזה שבו אנחנו כבר משחקים ברוב של ההתחלה.

1004
01:09:57,000 --> 01:09:59,000
זה לא סולם או משהו.

1005
01:09:59,000 --> 01:10:03,000
הרבה זה מאוד תלוי מכשיר,

1006
01:10:03,000 --> 01:10:10,000
מערכת הפעלה תלויה, אבל זה יחסית איך דברים מקבלים הכו בעד.

1007
01:10:10,000 --> 01:10:17,000
כאשר אתה מפעיל תכנית ומצהיר על משתנה בשם x-

1008
01:10:17,000 --> 01:10:27,000
אני הולך לצייר קופסה אחרת למטה, וזה הולך להיות זכרון RAM גם כן.

1009
01:10:27,000 --> 01:10:29,000
ואני הולך לחפש.

1010
01:10:29,000 --> 01:10:34,000
אנחנו לצייר קווים משוננים, כדי לציין שזה רק קטע קטן של זכרון RAM

1011
01:10:34,000 --> 01:10:38,000
ולא את כולו כפי שאנו מציירים בראש.

1012
01:10:38,000 --> 01:10:43,000
>> אם אני מצהיר משתנה שלם בשם x,

1013
01:10:43,000 --> 01:10:49,000
אז בעצם מה שאני מקבל הוא מיפוי

1014
01:10:49,000 --> 01:10:54,000
שמאוחסן בטבלת הסמל של התכנית שלי

1015
01:10:54,000 --> 01:11:00,000
שמחבר את השם x לאזור זה בזיכרון שאני נמשך

1016
01:11:00,000 --> 01:11:03,000
ממש כאן בין הקווים האנכיים.

1017
01:11:03,000 --> 01:11:08,000
אם יש לי שורת הקוד בתכנית שלי שאומרת x = 7

1018
01:11:08,000 --> 01:11:15,000
המעבד יודע "אה, בסדר, אני יודע שחיי x במיקום זה בזיכרון".

1019
01:11:15,000 --> 01:11:25,000
"אני הולך להמשיך ולכתוב 7 שם."

1020
01:11:25,000 --> 01:11:28,000
איך זה לדעת מה מיקום זה הוא בזיכרון?

1021
01:11:28,000 --> 01:11:30,000
טוב, זה הכל נעשה בזמן הידור.

1022
01:11:30,000 --> 01:11:34,000
המהדר דואג להקצאה שבו כל אחד מהמשתנים מתכוונים ללכת

1023
01:11:34,000 --> 01:11:40,000
ויצירת מיפוי מיוחד או יותר נכון חיבור הנקודות

1024
01:11:40,000 --> 01:11:43,000
בין סמל ולאן היא הולכת, שמו של משתנה

1025
01:11:43,000 --> 01:11:46,000
ואיפה זה הולך לגור בזיכרון.

1026
01:11:46,000 --> 01:11:50,000
אבל מתברר שאנחנו באמת יכולים לגשת אליו בתוכניות שלנו גם כן.

1027
01:11:50,000 --> 01:11:55,000
זה מקבל חשוב כאשר אנחנו מתחילים לדבר על כמה ממבני הנתונים,

1028
01:11:55,000 --> 01:11:58,000
שהוא מושג שאנחנו הולכים להציג בהמשך.

1029
01:11:58,000 --> 01:12:09,000
>> אבל לעת עתה, מה שאתה יכול לדעת הוא שאני יכול ליצור מצביע למיקום זה, x.

1030
01:12:09,000 --> 01:12:12,000
לדוגמה, אני יכול ליצור משתנה מצביע.

1031
01:12:12,000 --> 01:12:16,000
כאשר אנו יוצרים משתנים מצביע אנו משתמשים בסימון הכוכבים.

1032
01:12:16,000 --> 01:12:21,000
במקרה זה, זה אומר שאני הולך ליצור מצביע לint.

1033
01:12:21,000 --> 01:12:24,000
זה בדיוק כמו כל סוג אחר.

1034
01:12:24,000 --> 01:12:27,000
אנחנו נותנים לו משתנים כמו y,

1035
01:12:27,000 --> 01:12:32,000
ואז להגדיר אותו שווה לכתובת, לכתובת.

1036
01:12:32,000 --> 01:12:38,000
במקרה זה, אנו יכולים להגדיר y להצביע על x

1037
01:12:38,000 --> 01:12:43,000
על ידי לקיחה את הכתובת של x, שאנחנו עושים עם אמפרסנד זה,

1038
01:12:43,000 --> 01:12:55,000
ואז הקים y להצביע עליו.

1039
01:12:55,000 --> 01:12:59,000
מה זה בעצם עושה הוא אם אנחנו מסתכלים על זכרון RAM שלנו

1040
01:12:59,000 --> 01:13:02,000
זה יוצר משתנה נפרדת.

1041
01:13:02,000 --> 01:13:04,000
זה הולך לקרוא לזה y,

1042
01:13:04,000 --> 01:13:06,000
ומתי הקו הזה של קוד מבצע

1043
01:13:06,000 --> 01:13:13,000
זה באמת הולך ליצור מצביע קטן שאנחנו בדרך כלל לצייר כחץ,

1044
01:13:13,000 --> 01:13:15,000
והוא מגדיר y להצביע על x.

1045
01:13:15,000 --> 01:13:17,000
כן.

1046
01:13:17,000 --> 01:13:19,000
[סטודנטים] אם x הוא כבר מצביע, היית פשוט לעשות

1047
01:13:19,000 --> 01:13:22,000
int * y = x במקום שיש אמפרסנד?

1048
01:13:22,000 --> 01:13:24,000
כן.

1049
01:13:24,000 --> 01:13:27,000
אם x הוא כבר מצביע, אז אתה יכול להגדיר 2 מצביעים שווים זה לזה,

1050
01:13:27,000 --> 01:13:30,000
ובמקרה זה לא הייתי נקודת y ל x,

1051
01:13:30,000 --> 01:13:34,000
אבל זה כל מה שהייתי מצביע על x כדי להצביע.

1052
01:13:34,000 --> 01:13:37,000
לדאבוננו, מחוץ לזמן.

1053
01:13:37,000 --> 01:13:44,000
>> מה הייתי אומר בשלב זה, אנחנו יכולים לדבר על זה מנותק,

1054
01:13:44,000 --> 01:13:49,000
אבל הייתי אומר להתחיל לעבוד דרך בעיה זו, # 14.

1055
01:13:49,000 --> 01:13:53,000
אתה יכול לראות שיש כבר קצת מלא בבשבילך כאן.

1056
01:13:53,000 --> 01:13:57,000
אתה יכול לראות שכאשר אנו מצהירים 2 מצביעים, int * x * y ו,

1057
01:13:57,000 --> 01:14:01,000
ושים לב שמצביע * הבא למשתנה היה משהו שנעשה בשנה שעברה.

1058
01:14:01,000 --> 01:14:05,000
מתברר שזה דומה למה שאנחנו עושים את זה שנה.

1059
01:14:05,000 --> 01:14:11,000
זה לא משנה איפה אתה כותב * כשאתה מצהיר על המצביע.

1060
01:14:11,000 --> 01:14:17,000
אבל יש לנו בכתב * לצד הסוג

1061
01:14:17,000 --> 01:14:24,000
כי זה עושה את זה מאוד ברור שאתה מצהיר על משתנה מצביע.

1062
01:14:24,000 --> 01:14:27,000
אתה יכול לראות שהכרזת על 2 מצביעים נותן לנו 2 תיבות.

1063
01:14:27,000 --> 01:14:31,000
כאן כשקבענו x השווה לmalloc

1064
01:14:31,000 --> 01:14:34,000
מה שזה אומר הוא הקצאת זיכרון בערימה.

1065
01:14:34,000 --> 01:14:41,000
התיבה הקטנה ממש כאן, המעגל הזה, נמצאת בערימה.

1066
01:14:41,000 --> 01:14:43,000
X הוא מצביע עליו.

1067
01:14:43,000 --> 01:14:46,000
שים לב ש-y עדיין לא מצביע על שום דבר.

1068
01:14:46,000 --> 01:14:50,000
כדי לקבל זיכרון לאחסון המספר 42 לx

1069
01:14:50,000 --> 01:14:55,000
היינו להשתמש במה סימון?

1070
01:14:55,000 --> 01:14:59,000
[סטודנטים] * x = 42.

1071
01:14:59,000 --> 01:15:01,000
בדיוק, * x = 42.

1072
01:15:01,000 --> 01:15:06,000
כלומר, פעל על החץ ולזרוק 42 שם.

1073
01:15:06,000 --> 01:15:09,000
כאן ושם סדר Y ו X יש לנו y מצביע על x.

1074
01:15:09,000 --> 01:15:13,000
שוב, זה בדיוק כמו שאמר קווין ושם סדר y שווה ל-x.

1075
01:15:13,000 --> 01:15:15,000
Y אינו מצביע על x.

1076
01:15:15,000 --> 01:15:19,000
למעשה, הוא מצביע על מה x הוא מצביע גם כן.

1077
01:15:19,000 --> 01:15:24,000
>> ואז סוף הסוף בתיבה האחרונה זה יש 2 דברים אפשריים שאנחנו יודעים לעשות.

1078
01:15:24,000 --> 01:15:28,000
אחת הוא שאנחנו יכולים לומר * x = 13.

1079
01:15:28,000 --> 01:15:33,000
הדבר השני הוא שאנחנו יכולים לומר, אלכס, אתה יודע מה הייתי יכול לעשות כאן?

1080
01:15:33,000 --> 01:15:37,000
אפשר לומר * x = 13-או

1081
01:15:37,000 --> 01:15:41,000
[סטודנטים] אתה יכול להגיד מה שint.

1082
01:15:41,000 --> 01:15:45,000
[נייט ח] אם זה מכונה משתנה int שאנחנו יכולים לעשות את זה.

1083
01:15:45,000 --> 01:15:49,000
כמו כן, אנו יכולים לומר * y = 13 משום ששניהם מצביעים לאותו המקום,

1084
01:15:49,000 --> 01:15:51,000
כדי שנוכל להשתמש במשתנה כדי להגיע לשם.

1085
01:15:51,000 --> 01:15:56,000
כן. >> [סטודנטים] מה היה נראה אם ​​אנחנו רק אומרים x int הוא 13?

1086
01:15:56,000 --> 01:16:00,000
שיהיה הכרזה משתנות חדש בשם X, שלא היה עובדים.

1087
01:16:00,000 --> 01:16:04,000
הייתה לנו התנגשות בגלל שאנחנו הכרזנו x להיות מצביע עד כאן.

1088
01:16:04,000 --> 01:16:10,000
[סטודנטים] אם רק הייתה הצהרה כי על ידי עצמו כיצד היה נראה כמו במונחים של המעגל?

1089
01:16:10,000 --> 01:16:14,000
אם היו לנו X = 13 אז יהיו לנו תיבה, ובמקום שחץ

1090
01:16:14,000 --> 01:16:16,000
יוצא מהקופסה היינו לצייר אותו כרק 13.

1091
01:16:16,000 --> 01:16:19,000
[סטודנטים] בתיבה. אוקיי.

1092
01:16:19,000 --> 01:16:24,000
>> תודה שצפית, ומזל טוב על חידון 0.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]