1
00:00:00,000 --> 00:00:11,200

2
00:00:11,200 --> 00:00:12,580
>> דוד Malan: בסדר, ברוך שובך.

3
00:00:12,580 --> 00:00:13,290
זה CS50.

4
00:00:13,290 --> 00:00:15,130
זו תחילתו של השבוע שבע.

5
00:00:15,130 --> 00:00:18,890
אז זה כבר זמן מה, ולכן אני חשבתי ש
לקחת סיור סופה של איפה אנחנו

6
00:00:18,890 --> 00:00:20,760
הפסיק ולאן אנחנו הולכים עכשיו.

7
00:00:20,760 --> 00:00:23,310
>> אז הדבר הזה כאן אולי יש לי
גרם לחרדה בהתחלה.

8
00:00:23,310 --> 00:00:27,680
אבל אני מקווה, שאתה מתחיל
להסתגל למה שזה מציין כאן -

9
00:00:27,680 --> 00:00:32,670
כוכב המייצג את מצביע, שהוא
רק מה, במונחים של הדיוט יותר?

10
00:00:32,670 --> 00:00:33,400
אז זה כתובת.

11
00:00:33,400 --> 00:00:35,490
>> אז זה את הכתובת של
משהו בזיכרון.

12
00:00:35,490 --> 00:00:38,260
והתחלנו לקלף את השכבות
לפני כמה שבועות, דברים כמו

13
00:00:38,260 --> 00:00:41,800
פונקציות כאלה ואחרות GetString
כל הזמן הזה כבר חוזר

14
00:00:41,800 --> 00:00:46,010
כתובות של דברים בזיכרון, כמו
כתובת של התו הראשון ב

15
00:00:46,010 --> 00:00:46,990
איזה רצף.

16
00:00:46,990 --> 00:00:50,360
>> אז אנחנו גם הצגנו valgrind, אשר
תוכל להתחיל להשתמש לבעיה זו

17
00:00:50,360 --> 00:00:53,380
נקבע, במיוחד לבא
בעיה להגדיר גם כן.

18
00:00:53,380 --> 00:00:54,980
וvalgrind עושה את מה שעבורנו?

19
00:00:54,980 --> 00:00:57,520

20
00:00:57,520 --> 00:01:01,020
בודק אותו לדליפות זיכרון, וזה
גם בודק לניצול לרעה של זיכרון.

21
00:01:01,020 --> 00:01:05,890
>> זה יכול, בהסתברות כלשהי, לזהות אם
הקוד שלך הולך לגעת בזיכרון

22
00:01:05,890 --> 00:01:07,100
כי זה פשוט לא צריך.

23
00:01:07,100 --> 00:01:10,410
אז לא בהכרח דליפה, אבל אם אתה
ללכת מעבר לגבולות של חלק

24
00:01:10,410 --> 00:01:14,730
מערך, ואתה בעצם להפעיל valgrind
ולגרום להתנהגות שבעוד

25
00:01:14,730 --> 00:01:17,870
valgrind פועל בתכנית שלך הוא
פועל בתוכו, תקבל

26
00:01:17,870 --> 00:01:21,460
הודעות כמו זו - "לא חוקית לכתוב של
גודל 4 ", אשר, זוכר כמה

27
00:01:21,460 --> 00:01:25,880
לפני שבועות התכוונו שהיה לי בטעות
כמו בint אחד רחוק מדי

28
00:01:25,880 --> 00:01:27,250
מעבר לגבולות מערך.

29
00:01:27,250 --> 00:01:30,790
וכך הגודל 4 אומר כאן את הגודל
של int המסוים.

30
00:01:30,790 --> 00:01:35,260
>> אז לקחת חיזוקים בעובדה כי
הפלט של valgrind, את הפורמט שלו,

31
00:01:35,260 --> 00:01:36,170
הוא פשוט זוועתי.

32
00:01:36,170 --> 00:01:40,180
זה ממש קשה לראות דרך הבלגן
למידע המעניין.

33
00:01:40,180 --> 00:01:42,910
אז מה שעשינו כאן הוא רק קטע
חלק מבני הזוג של יותר

34
00:01:42,910 --> 00:01:43,850
קווים מעניינים.

35
00:01:43,850 --> 00:01:46,760
אבל מבין כי 80% מvalgrind של
הפלט הולך להיות קצת

36
00:01:46,760 --> 00:01:47,650
הסחת דעת.

37
00:01:47,650 --> 00:01:52,820
>> רק לחפש דפוסים כמו אלה -
לא חוקי הנכון, לקרוא לא חוקי, 40 בתים

38
00:01:52,820 --> 00:01:56,690
וחלק מספר בלוקים הם בהחלט
איבד, מילות מפתח כגון זה.

39
00:01:56,690 --> 00:02:01,920
ומה שאתה מקווה שתראה הוא חלק
סוג של עקבות של מה פונקציה

40
00:02:01,920 --> 00:02:03,340
טעות היא בעצם פנימה

41
00:02:03,340 --> 00:02:07,195
במקרה זה כאן, במה ששורה של
הקוד שלי היה השגיאה כנראה?

42
00:02:07,195 --> 00:02:09,729

43
00:02:09,729 --> 00:02:14,130
>> 26 בקובץ שנקרא memory.c, שהיה
הדוגמא שאנחנו משחקים עם

44
00:02:14,130 --> 00:02:14,890
באותו הזמן.

45
00:02:14,890 --> 00:02:16,460
אז זה כנראה לא בmalloc.

46
00:02:16,460 --> 00:02:18,630
זה היה כנראה בקוד שלי במקום.

47
00:02:18,630 --> 00:02:20,910
אז אנחנו תראו את זה שוב
ושוב לפני זמן רב.

48
00:02:20,910 --> 00:02:24,080
>> אז scanf, זה עלה ב
כמה צורות עד כה.

49
00:02:24,080 --> 00:02:26,410
ראינו sscanf לזמן קצר.

50
00:02:26,410 --> 00:02:28,330
זה היה משהו מספר
אתה צלל לתוך בך

51
00:02:28,330 --> 00:02:29,535
הכנות לחידון.

52
00:02:29,535 --> 00:02:33,130
וscanf הוא למעשה מה CS50
הספרייה הייתה באמצעות מתחת

53
00:02:33,130 --> 00:02:36,560
מכסה המנוע די הרבה זמן על מנת
כדי לקבל קלט מהמשתמש.

54
00:02:36,560 --> 00:02:40,420
>> למשל, אם אני עובר לCS50
מכשיר כאן, בואו תפתחו אותי

55
00:02:40,420 --> 00:02:45,315
למשל היום שנקרא scanf-0.c
וזה סופר פשוט.

56
00:02:45,315 --> 00:02:46,590
זה רק כמה שורות של קוד.

57
00:02:46,590 --> 00:02:50,880
אבל זה באמת מדגים איך getInt
עובד כל הזמן הזה.

58
00:02:50,880 --> 00:02:54,710
>> בתכנית זו כאן, בקו 16
, שים לב שאני מצהיר int.

59
00:02:54,710 --> 00:02:57,270
אז לא מצביע, שום דבר קסום
שם, רק int.

60
00:02:57,270 --> 00:03:00,330
לאחר מכן, בקו 17, שאנחה
משתמש למספר, בבקשה.

61
00:03:00,330 --> 00:03:02,930
ואז בסוף 18, אני משתמש scanf כאן.

62
00:03:02,930 --> 00:03:06,910
ואני שצוינו, כמו סוג של printf,
שאני מצפה ציטוט

63
00:03:06,910 --> 00:03:08,110
סוף ציטוט אני אחוזים.

64
00:03:08,110 --> 00:03:10,920
>> אז אחוזים אני, כמובן,
מציין int.

65
00:03:10,920 --> 00:03:14,580
אבל שים לב למה השני
טיעון לscanf הוא.

66
00:03:14,580 --> 00:03:17,350
איך היית מתאר את השני
טיעון אחרי הפסיק?

67
00:03:17,350 --> 00:03:19,450
מה זה?

68
00:03:19,450 --> 00:03:20,670
>> זה את הכתובת של x.

69
00:03:20,670 --> 00:03:25,490
אז זה שימושי כי על ידי מתן
scanf עם הכתובת של x, מה עושה

70
00:03:25,490 --> 00:03:29,560
כי להעצים את הפונקציה שיעשה?

71
00:03:29,560 --> 00:03:33,010
לא רק ללכת לשם, אבל גם לעשות את מה?

72
00:03:33,010 --> 00:03:34,060
>> לבצע שינוי זה.

73
00:03:34,060 --> 00:03:38,080
כי אתה יכול ללכת לשם, זה סוג של
כמו מפה למיקום בזיכרון.

74
00:03:38,080 --> 00:03:41,900
וscanf כל עוד אתה מספק, או
כל פונקציה עם מפה כזאת, כי

75
00:03:41,900 --> 00:03:45,840
פונקציה יכולה ללכת לשם, ולא רק
מסתכל על הערך, אבל זה גם יכול

76
00:03:45,840 --> 00:03:49,670
לשנות את הערך של זה, וזה שימושי אם
המטרה בחיים של scanf היא

77
00:03:49,670 --> 00:03:53,060
סריקת קלט מהמשתמש, במיוחד
מהמקלדת.

78
00:03:53,060 --> 00:03:57,830
וF מציין מעוצב, בדיוק כמו
printf, F מציין מעוצב

79
00:03:57,830 --> 00:03:58,930
מחרוזת שברצונך להדפיס.

80
00:03:58,930 --> 00:04:04,430
>> אז בקיצור, 18 קו זה פשוט אומר,
תנסה לקרוא int מהמשתמש של

81
00:04:04,430 --> 00:04:10,420
מקלדת ולאחסן אותו בתוך X, בשעה
מה כתובת x קורה לחיות ב.

82
00:04:10,420 --> 00:04:14,860
ואז לבסוף, קו 19 רק אומר,
תודה על int, במקרה זה.

83
00:04:14,860 --> 00:04:15,940
>> אז הרשה לי להמשיך ולעשות את זה.

84
00:04:15,940 --> 00:04:18,570
אז להפוך את scanf 0.

85
00:04:18,570 --> 00:04:20,130
תנו לי להמשיך ולהתמקד פנימה

86
00:04:20,130 --> 00:04:22,960
אני אלך ולרוץ עם זה
נקודות לקצץ scanf 0.

87
00:04:22,960 --> 00:04:24,020
מספר, בבקשה?

88
00:04:24,020 --> 00:04:24,720
50.

89
00:04:24,720 --> 00:04:25,730
תודה על 50.

90
00:04:25,730 --> 00:04:27,270
אז זה די פשוט.

91
00:04:27,270 --> 00:04:28,160
>> עכשיו מה זה לא עושה?

92
00:04:28,160 --> 00:04:29,940
זה לא עושה את כל חבורה
מבדיקת שגיאות.

93
00:04:29,940 --> 00:04:33,000
למשל, אם אני לא אשתף פעולה,
ואני לא מקליד מספר, אבל

94
00:04:33,000 --> 00:04:37,860
במקום שאני כותב משהו כמו "שלום",
זה רק סוג של מוזר.

95
00:04:37,860 --> 00:04:41,130
וכך, אחד הדברים CS50
ספרייה כבר עושה עבורנו לחלק

96
00:04:41,130 --> 00:04:43,440
זמן הוא שreprompting
וreprompting.

97
00:04:43,440 --> 00:04:49,320
>> זוכר הביטוי לנסות שוב היה בcs50.c,
וזו הסיבה שgetInt ב

98
00:04:49,320 --> 00:04:51,670
ספריית CS50 היא למעשה כולו
חבורה של תורים ארוכים, בגלל שאנחנו

99
00:04:51,670 --> 00:04:53,190
בדיקה לדברי טיפשים כמו זה.

100
00:04:53,190 --> 00:04:55,730
האם המשתמש לא נותן
לנו, למעשה, int?

101
00:04:55,730 --> 00:04:57,910
האם הוא או היא נותנת לנו משהו
כמו מכתב אלפביתי?

102
00:04:57,910 --> 00:05:01,410
אם כן, אנו רוצים לזהות
ושצועק עליהם.

103
00:05:01,410 --> 00:05:03,915
>> אבל דברים יותר מעניינים
בדוגמה זו הבאה.

104
00:05:03,915 --> 00:05:09,840
אם אני הולך לscanf-1.c, מה הוא אחד
דבר שהשתנה באופן מהותי ב

105
00:05:09,840 --> 00:05:11,135
הדוגמא הבאה זה?

106
00:05:11,135 --> 00:05:13,690

107
00:05:13,690 --> 00:05:16,010
אני משתמש * char, כמובן,
במקום int.

108
00:05:16,010 --> 00:05:19,210
>> אז זה מעניין, כי * char,
כזכור, הוא באמת רק

109
00:05:19,210 --> 00:05:20,190
אותו דבר כמו מחרוזת.

110
00:05:20,190 --> 00:05:23,840
אז זה מרגיש כאילו אולי זה סופר
יישום פשוט של GetString.

111
00:05:23,840 --> 00:05:26,010
אבל אני כבר קלפתי את השכבה
של ספריית CS50, ולכן אני

112
00:05:26,010 --> 00:05:27,550
קורא * char זה עכשיו.

113
00:05:27,550 --> 00:05:30,070
אז בואו לראות איפה, אם בכלל,
אנו להשתבש.

114
00:05:30,070 --> 00:05:30,840
>> קו 17 -

115
00:05:30,840 --> 00:05:33,950
אני שוב אומר, תן לי בבקשה משהו,
במקרה זה, מחרוזת.

116
00:05:33,950 --> 00:05:37,940
ולאחר מכן בשורה הבאה, אני קורא scanf,
שוב, זה נותן קוד תבנית,

117
00:05:37,940 --> 00:05:39,310
אבל אחוזים של הזמן הזה.

118
00:05:39,310 --> 00:05:41,900
ולאחר מכן הפעם, אני
זה נותן חיץ.

119
00:05:41,900 --> 00:05:43,550
>> עכשיו שם לב, אני לא משתמש
האמפרסנד.

120
00:05:43,550 --> 00:05:47,120
אבל למה זה כנראה בסדר כאן?

121
00:05:47,120 --> 00:05:49,760
כי מה הוא כבר חיץ?

122
00:05:49,760 --> 00:05:50,770
זה כבר מצביע.

123
00:05:50,770 --> 00:05:51,650
זה כבר כתובת.

124
00:05:51,650 --> 00:05:54,510
>> ובוא מילה זו "לבלבל", תן לי
פשוט קוראים לזה של, למשל, עבור

125
00:05:54,510 --> 00:05:55,050
פשטות.

126
00:05:55,050 --> 00:05:58,250
אבל אני קראתי לזה משום שבמאגר
בכלל, בתכנות, אם יש לך

127
00:05:58,250 --> 00:06:02,130
נתח של זיכרון, שחוט באמת
פשוט, אתה יכול לקרוא לזה מאגר.

128
00:06:02,130 --> 00:06:04,460
זה מקום לאחסון מידע.

129
00:06:04,460 --> 00:06:07,400
>> בדומה לדברים כמו YouTube, כאשר
הם חציצה, אם אפשר לומר כך, כי

130
00:06:07,400 --> 00:06:10,270
רק אומר שזה הורדה מסיבית
האינטרנט ואחסונם

131
00:06:10,270 --> 00:06:14,160
מערך מקומי, נתח מקומי של זיכרון כל כך
כי אתה יכול לצפות בו מאוחר יותר ללא

132
00:06:14,160 --> 00:06:16,830
זה דילוג או תלוי על
שלך בעת ששחק בחזרה.

133
00:06:16,830 --> 00:06:20,930
>> אז למרות שיש כאן בעיה,
כי אני אומר לי scanf, מצפה

134
00:06:20,930 --> 00:06:22,320
מחרוזת מהמשתמש.

135
00:06:22,320 --> 00:06:24,410
הנה הכתובת של
נתח של זיכרון.

136
00:06:24,410 --> 00:06:26,180
שים מחרוזת שיש.

137
00:06:26,180 --> 00:06:31,230
למה זה קשור לתת
צרותינו, אם כי?

138
00:06:31,230 --> 00:06:33,490
>> מה זה?

139
00:06:33,490 --> 00:06:35,510
האם מותר לי לגשת
חלק הזה של זיכרון?

140
00:06:35,510 --> 00:06:36,250
אתה יודע, אני לא יודע.

141
00:06:36,250 --> 00:06:39,210
בגלל אותחל חיץ
לשום דבר?

142
00:06:39,210 --> 00:06:39,820
לא ממש.

143
00:06:39,820 --> 00:06:43,090
ואז זה מה שאנחנו כבר קוראים
ערך אשפה, אשר

144
00:06:43,090 --> 00:06:44,040
היא לא מילה רשמית.

145
00:06:44,040 --> 00:06:49,200
זה רק אומר שאין לנו מושג מה ביטים
נמצאים בתוך מארבעת הבתים ש

146
00:06:49,200 --> 00:06:51,240
יש לי הוקצה כחיץ.

147
00:06:51,240 --> 00:06:52,450
>> אני לא קראתי malloc.

148
00:06:52,450 --> 00:06:53,940
אני בהחלט כבר לא נקרא GetString.

149
00:06:53,940 --> 00:06:56,380
אז מי יודע מה היא בעצם
בתוך חיץ?

150
00:06:56,380 --> 00:07:00,550
ובכל זאת אומרת לי scanf בצורה עיוורת, ילכו לשם
ולשים את מה שמשתמש הקליד.

151
00:07:00,550 --> 00:07:04,460
>> אז מה זה עלול לגרום
בקוד שלנו, אם אנחנו מפעילים את זה?

152
00:07:04,460 --> 00:07:05,700
כנראה segfault.

153
00:07:05,700 --> 00:07:07,970
אולי לא, אבל כנראה segfault.

154
00:07:07,970 --> 00:07:10,620
ואני אומר אולי לא כי לפעמים
אתה עושה, לפעמים

155
00:07:10,620 --> 00:07:11,380
אתה לא מקבל segfault.

156
00:07:11,380 --> 00:07:14,280
לפעמים אתה פשוט לקבל מזל, אבל
זה בכל זאת הולך להיות

157
00:07:14,280 --> 00:07:15,340
באג בתכנית שלנו.

158
00:07:15,340 --> 00:07:17,060
>> אז תן לי להמשיך ולעבד את זה.

159
00:07:17,060 --> 00:07:18,280
אני הולך לעשות את זה דרך בית הספר הישן.

160
00:07:18,280 --> 00:07:23,825
אז מקף צלצול 0, scanf-1,
scanf-1.c, Enter.

161
00:07:23,825 --> 00:07:24,720
אופס, בית ספר ישן מדי.

162
00:07:24,720 --> 00:07:26,550
בואו נראה.

163
00:07:26,550 --> 00:07:28,440
לאן אני הולך?

164
00:07:28,440 --> 00:07:29,700
אה, חיץ * char.

165
00:07:29,700 --> 00:07:33,595

166
00:07:33,595 --> 00:07:35,130
הו, תודה לך -

167
00:07:35,130 --> 00:07:36,930
שמור, בסדר -

168
00:07:36,930 --> 00:07:37,690
בית הספר ישן מאוד.

169
00:07:37,690 --> 00:07:38,900
בסדר, זה כבר זמן מה.

170
00:07:38,900 --> 00:07:41,720
>> אז פשוט שמרתי את הקובץ לאחר
מה שהופך את זה זמני

171
00:07:41,720 --> 00:07:42,700
לשנות לפני רגע.

172
00:07:42,700 --> 00:07:46,090
ועכשיו יש לי מלוקט זה
באופן ידני עם קלאנג.

173
00:07:46,090 --> 00:07:49,500
ועכשיו אני הולך קדימה
ולהריץ scanf-1, Enter.

174
00:07:49,500 --> 00:07:50,290
מחרוזת בבקשה.

175
00:07:50,290 --> 00:07:51,600
אני סוג של "שלום".

176
00:07:51,600 --> 00:07:54,070
>> ועכשיו, הנה, שם בכנות, printf
יכול הוא קצת מעצבן.

177
00:07:54,070 --> 00:07:56,020
זה לא ממש הולך
segfault במקרה זה.

178
00:07:56,020 --> 00:07:59,860
Printf הוא קצת מיוחד כי
זה כל כך נפוץ שסופר

179
00:07:59,860 --> 00:08:03,570
בעצם הוא עושה printf
לנו טובה והגשמה,

180
00:08:03,570 --> 00:08:04,830
זה לא מצביע תקף.

181
00:08:04,830 --> 00:08:09,080
תן לי לקחת את זה על עצמי רק להדפיס
בסוגריים ריקים, אפילו

182
00:08:09,080 --> 00:08:13,340
למרות שזה לא בהכרח מה
אנחנו בעצמנו ציפינו לו.

183
00:08:13,340 --> 00:08:16,940
>> אז אנחנו לא יכולים לגרום ממש בקלות
segfault עם זה, אבל ברור שזה

184
00:08:16,940 --> 00:08:18,600
לא ההתנהגות שאני רוצה.

185
00:08:18,600 --> 00:08:19,800
אז מה הפתרון פשוט?

186
00:08:19,800 --> 00:08:25,650
ובכן, בscanf-2, הרשה לי להציע כי
במקום באמת רק הקצאה

187
00:08:25,650 --> 00:08:30,100
* Char, הרשו לי להיות קצת יותר חכם על
זה, ותן לי להקצות זיכרון

188
00:08:30,100 --> 00:08:32,940
כרצף של 16 תווים.

189
00:08:32,940 --> 00:08:34,200
>> אז אני יכול לעשות את זה בכמה דרכים.

190
00:08:34,200 --> 00:08:35,610
בהחלט אני יכול להשתמש malloc.

191
00:08:35,610 --> 00:08:38,980
אבל אני יכול לחזור לשניים כאשר בשבוע
אני רק זקוק לחבורה שלמה של

192
00:08:38,980 --> 00:08:39,620
תווים.

193
00:08:39,620 --> 00:08:40,860
זה בדיוק מערך.

194
00:08:40,860 --> 00:08:44,870
אז תן לי במקום להגדיר מחדש את החיץ
להיות מערך של 16 תווים.

195
00:08:44,870 --> 00:08:47,340
>> ועכשיו, כשאני עובר בחיץ -

196
00:08:47,340 --> 00:08:49,940
וזה משהו שאנחנו לא
לדבר על שניים בשבוע -

197
00:08:49,940 --> 00:08:53,730
אבל אתה יכול להתייחס למערך כ
למרות שזה כתובת.

198
00:08:53,730 --> 00:08:56,390
מבחינה טכנית, כפי שראינו, הם
קצת שונה.

199
00:08:56,390 --> 00:09:01,290
אבל scanf לא אכפת לי אם אתה עובר אותו
שמו של מערך, משום מה

200
00:09:01,290 --> 00:09:05,030
צלצול יעשה עבורנו הוא למעשה
טיפול בשם של מערך שכ

201
00:09:05,030 --> 00:09:08,280
כתובת של הנתח של 16 בתים.

202
00:09:08,280 --> 00:09:09,550
>> אז זה טוב יותר.

203
00:09:09,550 --> 00:09:12,110
משמעות דבר היא שעכשיו אני מקווה שאני יכול
בצע את הפעולות הבאות.

204
00:09:12,110 --> 00:09:16,800
תן לי להתרחק לרגע ו
עושה scanf-2, שחוברו על אישור.

205
00:09:16,800 --> 00:09:19,390
עכשיו תן לי לעשות לי לוכסן scanf-2.

206
00:09:19,390 --> 00:09:22,430
מחרוזת בבקשה. "הלו". וזה
נראה לעבוד במשרה זו.

207
00:09:22,430 --> 00:09:26,020
>> אבל מישהו יכול להציע תרחיש
שבו עדיין לא יכול לעבוד?

208
00:09:26,020 --> 00:09:28,550
כן?

209
00:09:28,550 --> 00:09:30,640
משהו ארוך יותר מ -16 תווים.

210
00:09:30,640 --> 00:09:32,020
ולמעשה, אנחנו יכולים להיות
קצת יותר מדויק.

211
00:09:32,020 --> 00:09:36,540
משהו כבר אז 15 תווים,
כי באמת שאנחנו צריכים לזכור

212
00:09:36,540 --> 00:09:39,920
כי אנחנו צריכים קו נטוי שאפס
במרומז בסוף המחרוזת,

213
00:09:39,920 --> 00:09:42,950
וזה בדרך כלל יהיה בצד scanf
תדאג לנו.

214
00:09:42,950 --> 00:09:46,210
>> אז תן לי לעשות משהו כמו -

215
00:09:46,210 --> 00:09:48,040
לפעמים אנחנו יכולים רק
להשאיר את זה ככה.

216
00:09:48,040 --> 00:09:50,630
אוקיי, אז יש לנו עכשיו מושרה
פילוח אשמתנו.

217
00:09:50,630 --> 00:09:51,000
למה?

218
00:09:51,000 --> 00:09:54,940
כי אני הקלדתי ליותר מ -15
דמויות, וכך יש לנו למעשה

219
00:09:54,940 --> 00:09:58,280
זיכרון שאני ממש נגעתי
לא צריכים.

220
00:09:58,280 --> 00:10:00,180
>> אז מה באמת הפתרון כאן?

221
00:10:00,180 --> 00:10:02,210
ובכן, מה אם אנחנו צריכים מחרוזת ארוכה יותר?

222
00:10:02,210 --> 00:10:03,960
ובכן, אנחנו עושים את זה אולי 32 בתים.

223
00:10:03,960 --> 00:10:05,160
ובכן, מה אם זה לא מספיק זמן?

224
00:10:05,160 --> 00:10:06,040
מה דעתך על 64 בתים?

225
00:10:06,040 --> 00:10:07,080
מה אם זה לא מספיק זמן?

226
00:10:07,080 --> 00:10:09,640
מה דעתך על 128 או 200 בתים?

227
00:10:09,640 --> 00:10:12,660
מה באמת הוא הפתרון כאן ב
מקרה כללי, אם אנחנו לא יודעים ב

228
00:10:12,660 --> 00:10:14,460
לקדם את מה שהמשתמש עומד להקליד?

229
00:10:14,460 --> 00:10:20,000

230
00:10:20,000 --> 00:10:23,050
>> זה פשוט סוג של כאב גדול בתחת,
אם להיות כנים, וזו הסיבה

231
00:10:23,050 --> 00:10:29,050
יש CS50 ספרייה כמה עשרות שורות של
קוד שקולקטיבי ליישם

232
00:10:29,050 --> 00:10:32,390
GetString מחרוזת בצורה שאנחנו לא יודעים
צריך לדעת מראש מה

233
00:10:32,390 --> 00:10:33,430
המשתמש עומד להקליד.

234
00:10:33,430 --> 00:10:37,370
בפרט, אם אתה מסתכל אחורה
cs50.c מלפני שבועיים, תוכל לראות

235
00:10:37,370 --> 00:10:40,480
GetString שבעצם עושה
אין להשתמש בscanf בדרך זו.

236
00:10:40,480 --> 00:10:43,720
במקום זאת, היא קורא תו אחד
בכל פעם.

237
00:10:43,720 --> 00:10:46,010
>> בגלל דבר אחד נחמד על
קריאת תו אחד היא שאנחנו יכולים

238
00:10:46,010 --> 00:10:48,490
להבטיח את עצמנו לתמיד
יש לי char אחד לפחות.

239
00:10:48,490 --> 00:10:51,740
אני רק יכול להכריז char, ואז לקחת
צעדים אלה לתינוק באמת רק

240
00:10:51,740 --> 00:10:54,380
לקרוא תו אחד ב
זמן מהמקלדת.

241
00:10:54,380 --> 00:10:58,240
ואז, מה שתראה GetString
עושה הוא כל פעם שהוא נגמר,

242
00:10:58,240 --> 00:11:02,280
אומרים, 16 בתים של זיכרון, היא משתמשת
malloc, או בן דוד שלה, כדי

243
00:11:02,280 --> 00:11:06,810
תקצה יותר זיכרון, העתקה הישנה
זיכרון לזחילה חדשה, ולאחר מכן

244
00:11:06,810 --> 00:11:09,900
יחד, מקבל תו אחד בכל פעם,
וכאשר הוא פועל מתוך ש

245
00:11:09,900 --> 00:11:13,370
נתח של זיכרון, זורק אותו משם, תופס
נתח גדול יותר של זיכרון, מעתיק ישן

246
00:11:13,370 --> 00:11:14,750
לתוך חדש וחוזר,.

247
00:11:14,750 --> 00:11:18,480
וזה באמת כאב בעצם
ליישם משהו פשוט כמו

248
00:11:18,480 --> 00:11:19,710
מקבל קלט ממשתמש.

249
00:11:19,710 --> 00:11:21,090
>> אז אתה יכול להשתמש scanf.

250
00:11:21,090 --> 00:11:22,430
אתה יכול להשתמש בפונקציות דומות אחרות.

251
00:11:22,430 --> 00:11:25,420
והרבה ספרי לימוד באינטרנט
דוגמאות לעשות, אבל הם כולם

252
00:11:25,420 --> 00:11:27,210
פגיע לבעיות כאלה.

253
00:11:27,210 --> 00:11:29,550
וסופו של דבר, מקבל segfault
הוא סוג של מעצבן.

254
00:11:29,550 --> 00:11:30,680
זה לא טוב למשתמש.

255
00:11:30,680 --> 00:11:33,560
>> אבל במקרה הגרוע ביותר, מה עושה
זה יסודו לשים את שלך

256
00:11:33,560 --> 00:11:37,160
קוד בסיכון?

257
00:11:37,160 --> 00:11:39,250
איזה התקף, באופן פוטנציאלי.

258
00:11:39,250 --> 00:11:41,680
דיברנו על התקפה אחת כזו -
עולה על גדותיו המחסנית.

259
00:11:41,680 --> 00:11:44,660
אבל באופן כללי, אם מותר לך
גלישת מאגר, כמו שעשינו

260
00:11:44,660 --> 00:11:48,070
לפני כמה שבועות, רק עם הכתיבה
יותר מ "שלום" בערימה, אתה

261
00:11:48,070 --> 00:11:52,330
אכן יכול להשתלט, באופן פוטנציאלי,
מחשב, או לפחות לקבל בנתונים ה

262
00:11:52,330 --> 00:11:53,510
לא שייך לך.

263
00:11:53,510 --> 00:11:55,970
>> אז בקיצור, זו הסיבה שיש לנו
גלגלי העזר הללו.

264
00:11:55,970 --> 00:11:59,090
אבל עכשיו, אנחנו מתחילים לקחת אותם,
כמו התוכניות שלנו כבר לא צריכים,

265
00:11:59,090 --> 00:12:00,610
בהכרח, קלט מהמשתמש.

266
00:12:00,610 --> 00:12:03,960
אבל במקרה של בעיה להגדיר שש,
הקלט שלך יבוא מענק

267
00:12:03,960 --> 00:12:07,520
קובץ מילון עם כ -150
אלף מילים מוזרות.

268
00:12:07,520 --> 00:12:10,330
>> אז אתה לא צריך לדאוג
הקלט השרירותי של המשתמש.

269
00:12:10,330 --> 00:12:13,720
אנו נותנים לך כמה הנחות
על קובץ זה.

270
00:12:13,720 --> 00:12:20,340
כל שאלות על מצביעים או Scanf
או קלט משתמש באופן כללי?

271
00:12:20,340 --> 00:12:24,450
>> בסדר, אז מבט מהיר ואז באחד
נגרר מנושא לפני כשבועיים.

272
00:12:24,450 --> 00:12:28,590
וזה היה הרעיון הזה של struct.

273
00:12:28,590 --> 00:12:34,180
לא ש-- הרעיון הזה של
struct, שהיה מה?

274
00:12:34,180 --> 00:12:35,430
מה struct עשה בשבילנו?

275
00:12:35,430 --> 00:12:39,280

276
00:12:39,280 --> 00:12:39,860
>> הגדרה -

277
00:12:39,860 --> 00:12:41,710
מצטער?

278
00:12:41,710 --> 00:12:42,820
להגדיר סוג משתנה.

279
00:12:42,820 --> 00:12:44,410
אז בערך.

280
00:12:44,410 --> 00:12:46,180
אנחנו למעשה שילוב של שני נושאים.

281
00:12:46,180 --> 00:12:49,510
אז עם typedef, זוכר שאנחנו יכולים
להכריז על סוג שלנו, כמו

282
00:12:49,510 --> 00:12:51,500
מילה נרדפת, כמו מחרוזת לדמות *.

283
00:12:51,500 --> 00:12:56,200
אבל באמצעות typedef struct ו, אנחנו יכולים
באמת ליצור מבני נתונים משלנו.

284
00:12:56,200 --> 00:12:59,600
>> למשל, אם אני חוזר לgedit
כאן רק לרגע, ואני הולך קדימה

285
00:12:59,600 --> 00:13:08,230
ולעשות משהו כזה, תן לי לחסוך
זה כמו, נניח, structs.c

286
00:13:08,230 --> 00:13:10,840
באופן זמני, אני רק הולך
ללכת קדימה וכולל

287
00:13:10,840 --> 00:13:14,360
standardio.h, החלל עיקרי int.

288
00:13:14,360 --> 00:13:18,960
ולאחר מכן בכאן, נניח שאני רוצה
כדי לכתוב תכנית שמאחסנת

289
00:13:18,960 --> 00:13:21,840
תלמידים רבים ממספר רב של
בתים, למשל.

290
00:13:21,840 --> 00:13:24,430
אז זה כמו registrarial
מסד הנתונים. כלשהו

291
00:13:24,430 --> 00:13:29,550
>> אז אם אני צריך את שם תלמיד אחד, אני
אולי לעשות משהו כמו שם * char,

292
00:13:29,550 --> 00:13:31,570
ואני אעשה משהו כמו -

293
00:13:31,570 --> 00:13:34,410
בעצם, בואו להשתמש בספרייה CS50
רק לרגע כדי להפוך את זה

294
00:13:34,410 --> 00:13:38,380
קצת יותר פשוט, ולכן אנחנו יכולים לשאול
אלה עשרות שורות קוד.

295
00:13:38,380 --> 00:13:39,340
ובואו סתם לשמור את זה פשוט.

296
00:13:39,340 --> 00:13:42,610
אנחנו נשמור אותו חוט,
ועכשיו GetString.

297
00:13:42,610 --> 00:13:47,420
>> אז אני טוען עכשיו שאני כבר מאוחסן שם
של איזה סטודנט, ואת ביתו של

298
00:13:47,420 --> 00:13:50,240
איזה סטודנט, פשוט באמצעות משתנים
כמו שעשינו ובשבוע אחד.

299
00:13:50,240 --> 00:13:52,370
אבל נניח שעכשיו אני רוצה לתמוך
תלמידים רבים.

300
00:13:52,370 --> 00:13:58,460
בסדר, אז האינסטינקטים שלי הם לעשות
מחרוזת NAME2, מקבלת GetString, מחרוזת

301
00:13:58,460 --> 00:14:01,370
house2 מקבל GetString.

302
00:14:01,370 --> 00:14:05,850
ולאחר מכן התלמיד השלישי שלנו,
בואו נעשה NAME3 GetString.

303
00:14:05,850 --> 00:14:09,170
>> בסדר, אז אני מקווה שזה מדהים
שלך כסוג של טיפשים,

304
00:14:09,170 --> 00:14:11,580
משום שהתהליך הזה הוא באמת אף פעם לא
הולך עד הסוף, וזה רק הולך

305
00:14:11,580 --> 00:14:13,130
להפוך את הקוד שלי נראה יותר גרוע
ויותר ויותר גרוע.

306
00:14:13,130 --> 00:14:14,810
אבל פתרנו את זה יותר מדי בשבועות.

307
00:14:14,810 --> 00:14:19,450
מה היה הפתרון שלנו הנקי יחסית
כאשר היו לנו מספר רב של משתנים

308
00:14:19,450 --> 00:14:23,580
אותו סוג נתונים שכולם קשורים, אבל
אנחנו לא רוצים הבלגן הזוועתי הזה

309
00:14:23,580 --> 00:14:26,870
של משתנים בשם דומה?

310
00:14:26,870 --> 00:14:30,060
מה שאנחנו עושים במקום זה?

311
00:14:30,060 --> 00:14:31,260
>> אז אני חושב ששמעתי כמה מקומות.

312
00:14:31,260 --> 00:14:32,590
היו לנו מערך.

313
00:14:32,590 --> 00:14:37,110
אם אתה רוצה מספר מופעים של
משהו, למה שלא לנקות את כל זה

314
00:14:37,110 --> 00:14:39,540
ורק אומר, תן לי
נקרא מערך שמות?

315
00:14:39,540 --> 00:14:41,640
>> ועכשיו, בואו 3 קוד קשיח של.

316
00:14:41,640 --> 00:14:44,450
ולאחר מכן לתת לי עוד מערך
בשם בתים, ותן לי ל

317
00:14:44,450 --> 00:14:45,800
עכשיו קוד קשה 3.

318
00:14:45,800 --> 00:14:49,220
ואני כבר ניקיתי מסיבי
בלגן שיצרתי זה עתה.

319
00:14:49,220 --> 00:14:52,400
עכשיו, אני עדיין יש מקודד קשה 3, אבל אפילו
3 יכולים לבוא מאופן דינמי

320
00:14:52,400 --> 00:14:54,350
משתמש, או argv, או משהו דומה.

321
00:14:54,350 --> 00:14:55,720
אז זה כבר נקי.

322
00:14:55,720 --> 00:15:00,100
>> אבל מה שמעצבן על זה כי
עכשיו, למרות ששם הוא איכשהו

323
00:15:00,100 --> 00:15:02,280
יסוד מקושר ל
ביתו של תלמיד -

324
00:15:02,280 --> 00:15:04,720
זה סטודנט שאני באמת
רוצה לייצג -

325
00:15:04,720 --> 00:15:08,080
עכשיו יש לי שני מערכים שנמצאים במקביל
במובן זה שהם

326
00:15:08,080 --> 00:15:13,930
אותו גודל, ושמות סוגר 0
כנראה מפות לבתי סוגר 0,

327
00:15:13,930 --> 00:15:16,600
ושמות סוגר מפות 1
לבתי סוגר 1.

328
00:15:16,600 --> 00:15:19,280
במילים אחרות, חיי סטודנטים שב
בית ההוא, ושתלמיד אחר

329
00:15:19,280 --> 00:15:20,530
גר באותו בית אחר.

330
00:15:20,530 --> 00:15:23,720
אבל אין ספק שזה יכול להיות
נעשה עוד יותר נקי.

331
00:15:23,720 --> 00:15:24,990
>> ובכן, זה יכול, למעשה.

332
00:15:24,990 --> 00:15:28,730
ותנו לי להמשיך ולפתוח
עד structs.h, ואתה

333
00:15:28,730 --> 00:15:31,130
לראות את הרעיון הזה כאן.

334
00:15:31,130 --> 00:15:34,905
שימו לב שאני השתמשתי typedef, כפי שאתה
רמז לפני רגע להכריזנו

335
00:15:34,905 --> 00:15:35,570
סוג הנתונים שלו.

336
00:15:35,570 --> 00:15:39,660
אבל אני גם משתמש במילת מפתח אחרת זה
בשם struct אשר נותן לי חדש

337
00:15:39,660 --> 00:15:40,790
מבנה הנתונים.

338
00:15:40,790 --> 00:15:43,980
>> ומבנה נתונים זה אני טוען שהוא הולך
יש שני דברים בתוך

339
00:15:43,980 --> 00:15:47,060
זה - מחרוזת בשם שם, ו
מחרוזת שנקראת בית.

340
00:15:47,060 --> 00:15:49,820
ושם אני הולך לתת לי
מבנה נתונים זה הולך

341
00:15:49,820 --> 00:15:51,005
להיקרא תלמיד.

342
00:15:51,005 --> 00:15:54,030
אני יכול לקרוא לזה מה שאני רוצה,
אבל זה עושה סמנטי

343
00:15:54,030 --> 00:15:55,810
נשמע לי הגיוני בראש שלי.

344
00:15:55,810 --> 00:15:59,160
>> אז עכשיו, אם אני פותח את גרסה טובה יותר
של התכנית שהתחלתי לכתוב

345
00:15:59,160 --> 00:16:00,390
שם, תן לי לגלול לחלק העליון.

346
00:16:00,390 --> 00:16:03,190
ויש עוד כמה שורות הקוד
כאן, אבל תנו לי להתמקד על

347
00:16:03,190 --> 00:16:04,160
הרגע על אחד.

348
00:16:04,160 --> 00:16:07,790
אני כבר הכרזתי על סטודנטים שנקראו קבועים
וקשה מקודד 3 לעת עתה.

349
00:16:07,790 --> 00:16:11,110
אבל עכשיו, שים לב כמה נקי
הקוד שלי מתחיל לקבל.

350
00:16:11,110 --> 00:16:15,030
>> בקו 22, אני מצהיר
מערך של סטודנטים.

351
00:16:15,030 --> 00:16:18,760
ושים לב שהתלמיד הוא ככל הנראה
עכשיו סוג הנתונים.

352
00:16:18,760 --> 00:16:23,360
כי בחלק העליון של קובץ זה, שים לב
צירפתי קובץ הכותרת ש

353
00:16:23,360 --> 00:16:24,820
שמשכתי עד לפני רגע.

354
00:16:24,820 --> 00:16:28,820
וקובץ הכותרת שפשוט היה לי
הגדרה זו של תלמיד.

355
00:16:28,820 --> 00:16:32,470
>> אז עכשיו, יצרתי נתונים האישיים שלי
סוג שהמחברים של השנים C

356
00:16:32,470 --> 00:16:33,890
לפני לא חשב מראש.

357
00:16:33,890 --> 00:16:34,570
אבל אין בעיה.

358
00:16:34,570 --> 00:16:35,870
אני יכול לעשות את זה בעצמי.

359
00:16:35,870 --> 00:16:39,050
אז זה נקרא מערך תלמידים,
כל אחד מחבריה

360
00:16:39,050 --> 00:16:41,100
הוא מבנה תלמיד.

361
00:16:41,100 --> 00:16:44,270
ואני רוצה שלושה מאלו
במערך.

362
00:16:44,270 --> 00:16:46,030
>> ועכשיו, מה שעושה את השאר
של תכנית זו עושה?

363
00:16:46,030 --> 00:16:47,550
אני צריך משהו קצת שרירותי.

364
00:16:47,550 --> 00:16:51,450
אז מ -24 ואילך באינטרנט,
אני לחזר 0 עד 3.

365
00:16:51,450 --> 00:16:54,000
אז אני שואל את המשתמש עבור
שמו של התלמיד.

366
00:16:54,000 --> 00:16:56,110
ואז אני משתמש GetString כמו קודם.

367
00:16:56,110 --> 00:16:59,410
ואז אני שואל לביתו של התלמיד,
ואני משתמש בGetString כמו קודם.

368
00:16:59,410 --> 00:17:01,780
>> אבל שימו לב - מעט חדש
חתיכת התחביר -

369
00:17:01,780 --> 00:17:07,010
אני יכול עדיין מדד לתלמיד i-ה,
אבל איך אני מקבל את הנתונים הספציפיים

370
00:17:07,010 --> 00:17:08,354
בתוך שדה של struct?

371
00:17:08,354 --> 00:17:11,770
ובכן, מה שככל הנראה
יצירה חדשה של תחביר?

372
00:17:11,770 --> 00:17:13,339
זה רק מפעיל הנקודה.

373
00:17:13,339 --> 00:17:14,510
>> אנחנו כבר לא ממש ראינו את זה קודם.

374
00:17:14,510 --> 00:17:17,819
ראית את זה בחמש pset אם יש לך
קפצתי כבר עם קבצי מפת סיביות.

375
00:17:17,819 --> 00:17:22,372
אבל רק אומרת שהנקודה פנימית של זה
מבנה או שדות מרובים, נותנים נקודה

376
00:17:22,372 --> 00:17:24,510
שם, או לתת לי נקודת בית.

377
00:17:24,510 --> 00:17:28,690
זה אומר ללכת בתוך struct
ולקבל את השדות האלה בפרט.

378
00:17:28,690 --> 00:17:30,200
>> מה שאר תכנית זו עושה?

379
00:17:30,200 --> 00:17:31,190
זה לא כל כך סקסי.

380
00:17:31,190 --> 00:17:34,640
שים לב שאני לחזר 0 עד 3 שוב,
ואני פשוט ליצור אנגלית

381
00:17:34,640 --> 00:17:40,500
ביטוי כמו כך וכך הוא ובכך
בית כזה, עובר בנקודה משם

382
00:17:40,500 --> 00:17:43,320
תלמיד ה i-ו
בית גם כן.

383
00:17:43,320 --> 00:17:47,560
>> ואז לבסוף, עכשיו נתחיל להגיע
אנאלי על זה, עכשיו שאנחנו

384
00:17:47,560 --> 00:17:49,580
מכיר את מה malloc ו
פונקציות אחרות כבר

385
00:17:49,580 --> 00:17:50,570
עושה כל הזמן הזה.

386
00:17:50,570 --> 00:17:54,220
למה אני צריך לשחרר את שניהם שם
ובית, למרות שאני

387
00:17:54,220 --> 00:17:56,960
לא קרא malloc?

388
00:17:56,960 --> 00:17:58,020
>> GetString עשה.

389
00:17:58,020 --> 00:18:00,930
וזה היה הסוד הקטן והמלוכלך של
מספר שבועות, אבל יש GetString

390
00:18:00,930 --> 00:18:03,530
כבר דולף זיכרון בכל רחבי
למקם את כל הסמסטר עד כה.

391
00:18:03,530 --> 00:18:05,990
וvalgrand יהיה סוף סוף
תגלו לנו את זה.

392
00:18:05,990 --> 00:18:10,730
>> אבל זה לא עניין גדול, כי אני יודע
שאני פשוט יכול לשחרר את השם

393
00:18:10,730 --> 00:18:15,750
והבית, אם כי מבחינה טכנית, ל
יהיה בטוח סופר, סופר, אני צריך להיות

394
00:18:15,750 --> 00:18:17,890
עושה קצת בדיקת שגיאות כאן.

395
00:18:17,890 --> 00:18:19,040
מה האינסטינקטים שלך אומרים לך?

396
00:18:19,040 --> 00:18:22,480
מה שאני צריך להיות בדיקה
לפני שאשחרר את מה שהוא

397
00:18:22,480 --> 00:18:25,470
מחרוזת, aka ש* char?

398
00:18:25,470 --> 00:18:33,460
>> אני באמת צריך לבדוק אם תלמידים
שם סוגר אני לא עושה נקודה

399
00:18:33,460 --> 00:18:34,840
null שווה.

400
00:18:34,840 --> 00:18:40,400
ואז זה תהיה בסדר להמשיך ובחינם
מצביע זה, ואותו או אחר

401
00:18:40,400 --> 00:18:41,160
אחד גם כן.

402
00:18:41,160 --> 00:18:46,860
אם תלמידים סוגר לי נקודת הבית הוא לא
שווה לריקים, זה עכשיו יגן

403
00:18:46,860 --> 00:18:52,520
נגד מקרה הפינה שבי
GetString מחזיר משהו כמו אפס.

404
00:18:52,520 --> 00:18:57,310
וראינו לפני רגע, printf יהיה
להגן עלינו עד לכאן על ידי סתם אומר

405
00:18:57,310 --> 00:18:58,990
ריק, שהולך נראה מוזר.

406
00:18:58,990 --> 00:19:02,340
אבל לפחות זה לא יהיה segfault,
כפי שכבר ראו.

407
00:19:02,340 --> 00:19:05,990
>> ובכן, הרשה לי לעשות את דבר אחד כאן.
structs-0 הוא סוג של תכנית טיפשית

408
00:19:05,990 --> 00:19:09,700
כי אני להזין את כל הנתונים הללו, ולאחר מכן
הוא איבד פעם אחת את התכנית מסתיימת.

409
00:19:09,700 --> 00:19:10,940
אבל הרשה לי ללכת ולעשות את זה.

410
00:19:10,940 --> 00:19:12,830
תן לי לעשות את הטרמינל
חלון קצת יותר גדול.

411
00:19:12,830 --> 00:19:17,000
תן לי לעשות structs-1, אשר
היא גרסה חדשה של זה.

412
00:19:17,000 --> 00:19:18,520
>> אני להתקרב קצת.

413
00:19:18,520 --> 00:19:21,620
ועכשיו תן לי לרוץ נקודה
לקצץ structs-1.

414
00:19:21,620 --> 00:19:22,590
שמו של התלמיד -

415
00:19:22,590 --> 00:19:31,500
דוד מאת'ר, בואו אעשה את רוב קירקלנד,
בואו נעשה את לורן וורט.

416
00:19:31,500 --> 00:19:33,650
מה שמעניין עכשיו הוא הודעה -

417
00:19:33,650 --> 00:19:35,540
ואני רק יודע את זה כי
אני כתבתי את התכנית -

418
00:19:35,540 --> 00:19:38,930
יש קובץ עכשיו על הנוכחי שלי
ספרייה בשם students.csv.

419
00:19:38,930 --> 00:19:40,420
חלק מכם אולי ראה
אלה בעולם האמיתי.

420
00:19:40,420 --> 00:19:42,980
>> מה קובץ CSV?

421
00:19:42,980 --> 00:19:44,170
ערכים מופרדים בפסיקים.

422
00:19:44,170 --> 00:19:46,670
זה כמו סוג של גבר של עניים
גרסה של קובץ Excel.

423
00:19:46,670 --> 00:19:50,580
זה שולחן של שורות ועמודות ש
אתה יכול לפתוח בתכנית כמו Excel,

424
00:19:50,580 --> 00:19:51,800
או במספרים על MAC.

425
00:19:51,800 --> 00:19:55,180
>> ואם אני פותח את הקובץ הזה כאן על gedit,
הודעה - והמספרים הם לא שם.

426
00:19:55,180 --> 00:19:57,360
זה פשוט אומר לי gedit
שלי מספרי שורות.

427
00:19:57,360 --> 00:19:59,740
שים לב בשורה הראשונה של
קובץ הוא דוד ומאת'ר.

428
00:19:59,740 --> 00:20:01,450
השורה הבאה היא רוב הפסיק קירקלנד.

429
00:20:01,450 --> 00:20:04,170
והקו השלישי הוא לורן
פסיק וורט.

430
00:20:04,170 --> 00:20:05,480
>> אז מה שאני יצרתי?

431
00:20:05,480 --> 00:20:09,580
עכשיו אני כתבתי תכנית C ש
יכול למעשה ליצור גיליונות אלקטרוניים

432
00:20:09,580 --> 00:20:11,840
שניתן לפתוח ב
תכנית כמו אקסל.

433
00:20:11,840 --> 00:20:15,520
לא כל כך משכנע ערכת נתונים, אבל
אם יש לך גושים גדולים יותר של

434
00:20:15,520 --> 00:20:18,440
הנתונים שאתה בעצם רוצה
לתמרן ולעשות את הגרפים של ואת

435
00:20:18,440 --> 00:20:21,260
אוהבים, זה אולי אחד
דרך ליצור את הנתונים.

436
00:20:21,260 --> 00:20:25,370
יתר על כן, קובצי CSV הם סופר למעשה משותפים
פשוט לאחסון נתונים פשוטים -

437
00:20:25,370 --> 00:20:28,940
האוצר יאהו, למשל, אם אתה מקבל
מניות באמצעות ציטוטים כביכול שלהם

438
00:20:28,940 --> 00:20:33,180
ה-API, שירות חינם המאפשר לך
לקבל מניות עד לתאריך שוטפים

439
00:20:33,180 --> 00:20:35,650
ציטוטים לחברות, הם
לתת את הנתונים בחזרה ב

440
00:20:35,650 --> 00:20:37,800
פורמט CSV פשוט סופר.

441
00:20:37,800 --> 00:20:39,380
>> אז איך אנחנו עושים את זה?

442
00:20:39,380 --> 00:20:42,530
גם שם לב, רוב התכנית של זה
כמעט אותו הדבר.

443
00:20:42,530 --> 00:20:46,870
שלא להבחין כאן למטה, ולא הדפסה
התלמידים החוצה, על קו 35

444
00:20:46,870 --> 00:20:51,040
הלאה, אני טוען שאני חוסך
סטודנטים לדיסק, ולכן שמירה של קובץ.

445
00:20:51,040 --> 00:20:53,630
>> אז שם לב שאני מכריז קובץ * -

446
00:20:53,630 --> 00:20:57,260
עכשיו, זה סוג של אנומליה בג
מהסיבה כלשהי, קובץ הוא כל כמוסות,

447
00:20:57,260 --> 00:21:00,690
שלא כמו רוב סוגי נתונים אחרים
בג אבל זה מובנה

448
00:21:00,690 --> 00:21:02,320
סוג הנתונים, קובץ *.

449
00:21:02,320 --> 00:21:05,900
ואני מכריז מצביע לקובץ,
איך אתה יכול לחשוב על זה.

450
00:21:05,900 --> 00:21:08,070
>> fopen אומר קובץ פתוח.

451
00:21:08,070 --> 00:21:09,470
מה קובץ שאתה רוצה לפתוח?

452
00:21:09,470 --> 00:21:12,620
אני רוצה לפתוח קובץ שאני יהיה
באופן שרירותי לקרוא students.csv.

453
00:21:12,620 --> 00:21:14,480
אני יכול להתקשר לכל דבר שאני רוצה.

454
00:21:14,480 --> 00:21:15,200
>> ואז לקחת את ניחוש.

455
00:21:15,200 --> 00:21:18,960
מה עושה הטיעון השני
לfopen כנראה מתכוון?

456
00:21:18,960 --> 00:21:21,480
העכבר, W לכתיבה, יכל
להיות R לקריאה.

457
00:21:21,480 --> 00:21:24,120
יש להוספה אם אתה
רוצה להוסיף שורות ולא

458
00:21:24,120 --> 00:21:25,200
להחליף את כל העניין.

459
00:21:25,200 --> 00:21:28,005
>> אבל אני פשוט רוצה ליצור קובץ זה
פעם אחת, אז אני אשתמש במירכאות W.

460
00:21:28,005 --> 00:21:31,880
ואני יודע שרק שמקראתי
תיעוד, או דף האדם.

461
00:21:31,880 --> 00:21:35,100
אם קובץ הוא לא ריק - או במילים אחרות,
אם שום דבר לא השתבש שם -

462
00:21:35,100 --> 00:21:37,820
תן לי לחזר על
סטודנטים 0 עד 3.

463
00:21:37,820 --> 00:21:40,410
>> ועכשיו שם לב שיש משהו
מעט שבמעט שונה

464
00:21:40,410 --> 00:21:42,110
על קו 41 כאן.

465
00:21:42,110 --> 00:21:42,960
זה לא printf.

466
00:21:42,960 --> 00:21:46,530
זה fprintf לקובץ printf.

467
00:21:46,530 --> 00:21:47,790
אז זה הולך לכתוב לקובץ.

468
00:21:47,790 --> 00:21:48,860
איזה קובץ?

469
00:21:48,860 --> 00:21:53,630
אחד המצביע שאתה מציין
כטענה הראשונה.

470
00:21:53,630 --> 00:21:55,940
>> לאחר מכן אנו מגדירים מחרוזת תבנית.

471
00:21:55,940 --> 00:21:59,660
לאחר מכן אנו מגדירים מה אנחנו רוצים מחרוזת
התוספת באחוזים לשעות הראשונה, ו

472
00:21:59,660 --> 00:22:04,320
אז עוד משתנה או
אחוזים של שנייה.

473
00:22:04,320 --> 00:22:06,760
אז לסגור את התיק עם fclose.

474
00:22:06,760 --> 00:22:09,380
ממה שאני לשחרר את הזיכרון כמו בעבר, אם כי
אני צריך לחזור ובלהוסיף

475
00:22:09,380 --> 00:22:10,540
כמה בדיקות לnull.

476
00:22:10,540 --> 00:22:12,090
>> וזהו זה.

477
00:22:12,090 --> 00:22:16,960
fopen, fprintf, fclose נותן לי
יכולת ליצור קבצי טקסט.

478
00:22:16,960 --> 00:22:19,640
עכשיו, תראה בסט הבעיה חמש,
הכולל תמונות, אתה תהיה באמצעות

479
00:22:19,640 --> 00:22:20,990
קבצים בינאריים במקום.

480
00:22:20,990 --> 00:22:24,200
אבל באופן בסיסי, הרעיון הוא אותו הדבר,
למרות שאת הפונקציות אתה

481
00:22:24,200 --> 00:22:28,710
רואה הם קצת שונים.

482
00:22:28,710 --> 00:22:32,580
>> אז סיור הסופה, אבל אתה תקבל
מוכר מדי עם קובץ I/O--

483
00:22:32,580 --> 00:22:34,960
קלט ופלט - עם pset חמש.

484
00:22:34,960 --> 00:22:38,607
ושאלות על
יסודות ראשוניים כאן?

485
00:22:38,607 --> 00:22:39,857
כן?

486
00:22:39,857 --> 00:22:41,880

487
00:22:41,880 --> 00:22:43,710
>> מה אם אתה מנסה לשחרר את ערך ריק?

488
00:22:43,710 --> 00:22:48,880
אני מאמין, אלא אם כן קיבל בחינם
ידידותי למשתמש קצת יותר, אתה יכול

489
00:22:48,880 --> 00:22:49,890
פוטנציאל segfault.

490
00:22:49,890 --> 00:22:54,160
העברתו null היא רעה, כי אני לא
מאמינים חופשי טורח לבדוק בשבילך,

491
00:22:54,160 --> 00:22:57,330
כי זה עלול להיות יהיה בזבוז
זמן עבורו לעשות את עצמו ל

492
00:22:57,330 --> 00:22:59,022
כל אחד בעולם.

493
00:22:59,022 --> 00:23:00,590
שאלה טובה, אם כי.

494
00:23:00,590 --> 00:23:04,300
>> בסדר, אז זה סוג של מקבל
שלנו לנושא מעניין.

495
00:23:04,300 --> 00:23:07,010
הנושא של קבוצת הבעיה
חמש הוא זיהוי פלילי.

496
00:23:07,010 --> 00:23:08,420
כך לפחות חלק
הסט של הבעיה.

497
00:23:08,420 --> 00:23:12,030
המעבדה לזיהוי פלילי מתייחסת בדרך כלל
שחזור של מידע שעשוי או

498
00:23:12,030 --> 00:23:14,110
אולי לא יימחק
במכוון.

499
00:23:14,110 --> 00:23:18,680
ואז חשבתי שאני רוצה לתת לך מהיר
הטעם של מה שבאמת קורה בכל

500
00:23:18,680 --> 00:23:21,230
הפעם מתחת
מכסת מנוע של המחשב שלך.

501
00:23:21,230 --> 00:23:23,960
>> לדוגמה, אם יש לך בתוכך
מחשב נייד או מחשב השולחני

502
00:23:23,960 --> 00:23:28,040
כונן קשיח, זה או מכאני
מכשיר שמסתובב למעשה -

503
00:23:28,040 --> 00:23:31,650
יש דברים עגולים שנקראים מגשים
שנראים די אוהב את מה שאני

504
00:23:31,650 --> 00:23:34,540
פשוט היה על המסך כאן, אם כי
זה הוא ספר ישן יותר ויותר.

505
00:23:34,540 --> 00:23:37,370
זה שלושה וחצי אינץ'
כונן קשיח.

506
00:23:37,370 --> 00:23:40,070
ושלוש וחצי אינץ' מתייחס של
עם של הדבר כשאתה מתקין אותו

507
00:23:40,070 --> 00:23:40,890
במחשב.

508
00:23:40,890 --> 00:23:44,890
>> רבות שלך החבר 'ה במחשבים הניידים שלך עכשיו
יש כונני מצב מוצק, או SSDs,

509
00:23:44,890 --> 00:23:46,260
אשר אין להם חלקים נעים.

510
00:23:46,260 --> 00:23:49,170
הם יותר כמו זיכרון RAM ופחות כמו
מכשירים מכאניים אלה.

511
00:23:49,170 --> 00:23:51,450
אבל הרעיונות הם עדיין אותו,
בוודאי שהם נוגעים

512
00:23:51,450 --> 00:23:52,790
לבעיה להגדיר חמש.

513
00:23:52,790 --> 00:23:57,400
>> ואם אתה חושב עליו עכשיו כונן קשיח
מייצג להיות מעגל, אשר

514
00:23:57,400 --> 00:23:58,930
אני אצייר כמו זה כאן.

515
00:23:58,930 --> 00:24:02,290
בעת יצירת קובץ במחשב שלך,
בין אם זה SSD, או ב

516
00:24:02,290 --> 00:24:06,610
מקרה זה, כונן קשיח בבית ספר מעלה,
קובץ שכולל חתיכות מרובות.

517
00:24:06,610 --> 00:24:10,510
בואו נגיד שזה זה 0 ו -1,
חבורה שלמה של 0s ו 1s.

518
00:24:10,510 --> 00:24:11,660
אז זהו הכונן הקשיח כולו שלי.

519
00:24:11,660 --> 00:24:13,225
זו כנראה קובץ די גדול.

520
00:24:13,225 --> 00:24:18,080
והוא משתמש עד 0s ו 1s באותו
חלק מהמגש הפיזי.

521
00:24:18,080 --> 00:24:19,750
>> ובכן, מה הוא שהחלק פיזי?

522
00:24:19,750 --> 00:24:25,310
ובכן, מתברר שעל כונן קשיח,
לפחות מסוג זה, יש

523
00:24:25,310 --> 00:24:27,340
אלה חלקיקים מגנטיים הזעירים קטנים.

524
00:24:27,340 --> 00:24:32,630
ויש להם מהות וצפון
פולנים דרומה להם, כך שאם

525
00:24:32,630 --> 00:24:35,710
הפעלה של אחד מאותם חלקיקים המגנטיים
בדרך זו, אפשר לומר שזה

526
00:24:35,710 --> 00:24:36,720
ייצוג 1.

527
00:24:36,720 --> 00:24:39,340
ואם זה במהופך לדרום
צפון, אפשר לומר שזה

528
00:24:39,340 --> 00:24:40,390
מייצג 0.

529
00:24:40,390 --> 00:24:43,660
>> אז בעולם הפיזי האמיתי, זה
איך אתה יכול לייצג משהו ב

530
00:24:43,660 --> 00:24:45,670
המצב בינארי של 0 ו 1.

531
00:24:45,670 --> 00:24:46,720
אז זה כל קובץ.

532
00:24:46,720 --> 00:24:49,300
יש חבורה שלמה של מגנטי
חלקיקים שהם בדרך זו או

533
00:24:49,300 --> 00:24:51,920
בדרך זו, יוצרים דפוסים
של 0s ו 1s.

534
00:24:51,920 --> 00:24:56,760
>> אבל מתברר בעת שמירת קובץ,
קצת מידע נשמר בנפרד.

535
00:24:56,760 --> 00:25:00,000
אז זה שולחן קטן,
במדריך, אם אפשר לומר כך.

536
00:25:00,000 --> 00:25:05,810
ואני קראתי את שם הטור הזה, ו
אני אתקשר אל מיקום עמודה זו.

537
00:25:05,810 --> 00:25:08,850
>> ואני הולך לומר, נניח
זה קורות החיים שלי.

538
00:25:08,850 --> 00:25:14,050
resume.doc שלי מאוחסן ב
מיקום, נניח 123.

539
00:25:14,050 --> 00:25:15,390
אני תמיד הולך למספר הזה.

540
00:25:15,390 --> 00:25:18,810
אבל די אם נאמרתי שרק רוצים
בזכרון RAM, אתה יכול לקחת את כונן קשיח

541
00:25:18,810 --> 00:25:22,350
זה לגיגה או 200 ג'יגה
או טרה, ושאתה יכול

542
00:25:22,350 --> 00:25:23,750
מספר כל הבתים.

543
00:25:23,750 --> 00:25:26,480
באפשרותך למספר את כל הגושים של 8 סיביות.

544
00:25:26,480 --> 00:25:29,030
>> אז אנחנו אומרים שזה
123 הוא מיקום.

545
00:25:29,030 --> 00:25:32,070
אז בתוך ספרייה זו של ההפעלה שלי
מערכת זוכרת ש

546
00:25:32,070 --> 00:25:34,250
קורות חיים הוא במיקום 123.

547
00:25:34,250 --> 00:25:36,850
אבל זה נהיה מעניין כאשר
אתה מוחק קובץ.

548
00:25:36,850 --> 00:25:37,820
>> כך למשל -

549
00:25:37,820 --> 00:25:40,790
ותודה לאל, ברוב העולם יש
נתפס על זה - מה שקורה כאשר

550
00:25:40,790 --> 00:25:45,040
אתה גורר את קובץ לאשפה של Mac OS
או סל המיחזור של Windows שלך?

551
00:25:45,040 --> 00:25:48,290

552
00:25:48,290 --> 00:25:50,510
מה המטרה של עושה את זה?

553
00:25:50,510 --> 00:25:53,860
זה כמובן להיפטר מהקובץ,
אבל מה שעושה את המעשה של גרירה ו

554
00:25:53,860 --> 00:25:57,550
הוא נופל לפח האשפה שלך או שלך
סל המיחזור לעשות במחשב?

555
00:25:57,550 --> 00:25:59,230
>> שום דבר, באמת.

556
00:25:59,230 --> 00:26:00,320
זה בדיוק כמו תיקייה.

557
00:26:00,320 --> 00:26:01,800
זה תיקייה מיוחדת, כדי להיות בטוח.

558
00:26:01,800 --> 00:26:04,460
אבל האם זה באמת למחוק את הקובץ?

559
00:26:04,460 --> 00:26:06,780
>> ובכן, לא, משום שחלק מכם בוודאי
הייתה כמו, הו לעזאזל, אתה לא

560
00:26:06,780 --> 00:26:07,420
מתכוון לעשות את זה.

561
00:26:07,420 --> 00:26:09,130
אז אתה לחץ לחיצה כפולה על
אשפה או סל המיחזור.

562
00:26:09,130 --> 00:26:11,630
שחטטת ואתה כבר התאושש
הקובץ פשוט על ידי גרירתו

563
00:26:11,630 --> 00:26:12,110
לצאת משם.

564
00:26:12,110 --> 00:26:14,420
אז ברור, שזה לא בהכרח
למחוק אותו.

565
00:26:14,420 --> 00:26:15,990
>> בסדר, אתה יותר חכם מזה.

566
00:26:15,990 --> 00:26:18,860
אתה יודע שפשוט גורר אותו לתוך
אשפה או סל המיחזור לא אומר

567
00:26:18,860 --> 00:26:19,930
אתה רוקן את האשפה.

568
00:26:19,930 --> 00:26:24,110
אז אתה הולך לתפריט, ואתה אומר
אשפה ריקה או רוקן את סל המיחזור.

569
00:26:24,110 --> 00:26:25,360
אז מה קורה?

570
00:26:25,360 --> 00:26:29,070

571
00:26:29,070 --> 00:26:32,530
>> כן, אז הוא נמחק יותר מכך.

572
00:26:32,530 --> 00:26:37,660
אבל כל מה שקורה הוא זה.

573
00:26:37,660 --> 00:26:45,350
המחשב שבו שוכח
resume.doc היה.

574
00:26:45,350 --> 00:26:47,400
>> אבל מה שלא השתנה כנראה
בתמונה?

575
00:26:47,400 --> 00:26:51,390

576
00:26:51,390 --> 00:26:55,570
את הקטעים, 0s ו 1s שאני טוען הם
באתר של היבט פיזי כמה

577
00:26:55,570 --> 00:26:56,280
החומרה.

578
00:26:56,280 --> 00:26:57,110
הם עדיין שם.

579
00:26:57,110 --> 00:26:58,930
זה פשוט יש לו את המחשב
שכחנו מה הם.

580
00:26:58,930 --> 00:27:03,160
>> אז זה בעצם שחרר של הקובץ
ביטים, כך שהם יכולים לעשות בה שימוש.

581
00:27:03,160 --> 00:27:06,940
אבל עד שלא ליצור קבצים נוספים,
וקבצים נוספים, ועוד קבצים

582
00:27:06,940 --> 00:27:12,150
הסתברות, אלה 0s ו 1s,
חלקיקים מגנטיים, לקבל בה שימוש חוזר,

583
00:27:12,150 --> 00:27:16,220
צד הפוך עד או ימינה, ל
קבצים אחרים, 0s ו 1s.

584
00:27:16,220 --> 00:27:17,980
>> אז יש לך חלון זמן זה.

585
00:27:17,980 --> 00:27:19,860
וזה לא מצפוי
אורך, באמת.

586
00:27:19,860 --> 00:27:22,240
זה תלוי בגודל שלך קשה
כונן וכמה קבצים יש לך ואת

587
00:27:22,240 --> 00:27:23,490
כמה מהר אתה עושה חדש.

588
00:27:23,490 --> 00:27:27,050
אבל יש חלון זמן זה במהלך
איזה קובץ שהוא עדיין מושלם

589
00:27:27,050 --> 00:27:27,770
ההשבה.

590
00:27:27,770 --> 00:27:31,050
>> אז אם אי פעם להשתמש בתוכניות כמו McAfee
או Norton כדי לנסות ולשחזר

591
00:27:31,050 --> 00:27:35,680
הנתונים, כל שהם עושים הוא מנסים
לשחזר ספרייה שנקרא לזה

592
00:27:35,680 --> 00:27:37,340
להבין איפה הקובץ שלך היה.

593
00:27:37,340 --> 00:27:40,605
ולפעמים נורטון ויגיד,
קובץ הוא 93% השבה.

594
00:27:40,605 --> 00:27:42,020
ובכן, מה זה אומר?

595
00:27:42,020 --> 00:27:45,690
זה רק אומר שקובץ אחר
בסופו של מקרה באמצעות, למשל,

596
00:27:45,690 --> 00:27:48,920
אלה פיסות מתוך הקובץ המקורי שלך.

597
00:27:48,920 --> 00:27:51,950
>> אז מה באמת מעורב
לשחזר את המידע?

598
00:27:51,950 --> 00:27:55,720
ובכן, אם אין לך משהו כמו
הותקן מראש במחשב שלך נורטון,

599
00:27:55,720 --> 00:27:59,510
הכי טוב שאתה יכול לפעמים לעשות הוא להסתכל
בכל הכונן הקשיח מחפש

600
00:27:59,510 --> 00:28:00,510
דפוסים של ביטים.

601
00:28:00,510 --> 00:28:05,350
ואחד הנושאים של סט בעיה
חמש הוא שאתה תחפש

602
00:28:05,350 --> 00:28:09,570
מקבילה של כונן קשיח, זיהוי פלילי
תמונה של כרטיס קומפקט פלאש מ

603
00:28:09,570 --> 00:28:13,660
מצלמה דיגיטלית, מחפשת 0s
ו1s, כי בדרך כלל, עם גבוה

604
00:28:13,660 --> 00:28:16,720
הסתברות, לייצג את
תתחיל מתמונת JPEG.

605
00:28:16,720 --> 00:28:21,120
>> ואתם יכולים לשחזר את התמונות האלה על ידי
בהנחה, אם אני רואה את הדפוס הזה של

606
00:28:21,120 --> 00:28:24,380
ביטים בתמונה זיהוי פלילי, עם
סבירות גבוהה, שמסמנת

607
00:28:24,380 --> 00:28:25,650
תחילתו של JPEG.

608
00:28:25,650 --> 00:28:29,520
ואם אני רואה את אותו דפוס שוב,
שכנראה מסמן את תחילתו של

609
00:28:29,520 --> 00:28:32,440
עוד JPEG, ועוד
JPEG, ועוד JPEG.

610
00:28:32,440 --> 00:28:34,970
וזה בדרך כלל איך
שחזור נתונים יעבוד.

611
00:28:34,970 --> 00:28:37,870
מה שיפה הוא JPEGs למרות
פורמט הקובץ עצמו הוא במידה מסוימת

612
00:28:37,870 --> 00:28:44,400
המורכבת, כגון תחילתו של כל
קובץ הוא למעשה די זיהוי

613
00:28:44,400 --> 00:28:47,370
ופשוט, כמו שאתה רואה,
אם כבר לא.

614
00:28:47,370 --> 00:28:50,270
>> אז בואו נסתכל מקרוב מתחת
מכסה המנוע לגבי מה בדיוק היה

615
00:28:50,270 --> 00:28:53,360
קורה, ומה אלה 0s ו 1s
הם, כדי לתת לך קצת יותר

616
00:28:53,360 --> 00:28:55,330
הקשר לאתגר המסוים הזה.

617
00:28:55,330 --> 00:28:55,510
>> [השמעת וידאו]

618
00:28:55,510 --> 00:28:58,700
>> איפה-PC שלך מאחסן ביותר
נתוני הקבע שלה.

619
00:28:58,700 --> 00:29:03,390
כדי לעשות זאת, נתונים נוסע מזכרון RAM
יחד עם תוכנת אותות המציינות

620
00:29:03,390 --> 00:29:06,110
הכונן הקשיח כיצד לאחסן את הנתונים.

621
00:29:06,110 --> 00:29:09,410
מעגלי הכונן הקשיחים תרגום
אלה אותות למתח

622
00:29:09,410 --> 00:29:10,870
תנודות.

623
00:29:10,870 --> 00:29:14,970
אלה, בתורם, לשלוט על כונן קשיח של
חלקים נעים, כמה הבודדים

624
00:29:14,970 --> 00:29:17,910
חלקים נעים שנותרו ב
מחשב מודרני.

625
00:29:17,910 --> 00:29:22,130
>> חלק מאותות בקרת מנוע
אשר מסתובב פלטות מתכת מצופות.

626
00:29:22,130 --> 00:29:25,470
הנתונים שלך מאוחסנים בפועל
על מגשים אלה.

627
00:29:25,470 --> 00:29:28,610
אותות אחרים להעביר את הקריאה / כתיבה
ראשים לקרוא או

628
00:29:28,610 --> 00:29:30,710
לכתוב נתונים על המגשים.

629
00:29:30,710 --> 00:29:35,450
מנגנון זה מדויק, כך אנושי
שיער לא הצליח אפילו לעבור בין

630
00:29:35,450 --> 00:29:37,280
ראשים ופלטות מסתובבות.

631
00:29:37,280 --> 00:29:40,316
ובכל זאת, כל זה עובד במהירויות נהדרות.

632
00:29:40,316 --> 00:29:40,660
>> [השמעת וידאו הסוף]

633
00:29:40,660 --> 00:29:42,190
>> דוד Malan: קרב קטן
עכשיו עמוק יותר על מה

634
00:29:42,190 --> 00:29:44,360
למעשה על מגשים אלה.

635
00:29:44,360 --> 00:29:44,720
>> [השמעת וידאו]

636
00:29:44,720 --> 00:29:47,660
>> -בואו נסתכל על מה שאנחנו פשוט
ראה בהילוך איטי.

637
00:29:47,660 --> 00:29:51,710
כאשר דופק קצר של חשמל הוא
נשלח לראש קריאה / כתיבה, אם הטלות

638
00:29:51,710 --> 00:29:54,650
על אלקטרומגנטי זעירים עבור
שבריר של שנייה.

639
00:29:54,650 --> 00:29:58,970
המגנט יוצר שדה, אשר
שינויי הקוטביות של קטנטן, זעיר

640
00:29:58,970 --> 00:30:02,850
חלק מחלקיקי המתכת ה
מעיל פני השטח של כל מגש.

641
00:30:02,850 --> 00:30:05,940
>> סדרת דפוס זעיר אלה,
מחויב-up אזורים על הדיסק

642
00:30:05,940 --> 00:30:08,470
מייצג ביט אחד של
הנתונים במספר בינארי

643
00:30:08,470 --> 00:30:10,530
מערכת בשימוש על ידי מחשבים.

644
00:30:10,530 --> 00:30:13,775
עכשיו, אם הנוכחי נשלח בכיוון אחד
דרך ראש הקריאה / כתיבה, האזור

645
00:30:13,775 --> 00:30:15,970
הוא מקוטב בכיוון אחד.

646
00:30:15,970 --> 00:30:17,950
אם הנוכחי נשלח ב
כיוון הפוך,

647
00:30:17,950 --> 00:30:19,930
קיטוב הוא הפוך.

648
00:30:19,930 --> 00:30:22,370
>> איך אתה מקבל את הנתונים מהדיסק הקשיח?

649
00:30:22,370 --> 00:30:24,090
פשוט להפוך את התהליך.

650
00:30:24,090 --> 00:30:26,550
אז זה את החלקיקים בדיסק
שיקבל את הזרם ב

651
00:30:26,550 --> 00:30:27,960
קריאה / כתיבת ראש התנועה.

652
00:30:27,960 --> 00:30:30,700
להרכיב מיליוני אלה
מגזרים ממוגנטים, ו

653
00:30:30,700 --> 00:30:32,160
יש לך קובץ.

654
00:30:32,160 --> 00:30:36,060
>> עכשיו, את החלקים של קובץ אחד יכולים
להיות מפוזר בכל רחבי כונן של

655
00:30:36,060 --> 00:30:39,970
מגשים, כמו סוג של הבלגן
ניירות על השולחן שלך.

656
00:30:39,970 --> 00:30:43,500
אז קובץ תוספת מיוחד עוקב אחר
משם הכל.

657
00:30:43,500 --> 00:30:45,985
אתה לא רוצה שיהיה לך
משהו כזה?

658
00:30:45,985 --> 00:30:46,470
>> [השמעת וידאו הסוף]

659
00:30:46,470 --> 00:30:47,820
>> דוד Malan: אוקיי, כנראה שלא.

660
00:30:47,820 --> 00:30:52,070
אז כמה מכם חבר 'ה
גדל עם אלה?

661
00:30:52,070 --> 00:30:53,970
אוקיי, אז זה פחות ופחות
ידי בכל שנה.

662
00:30:53,970 --> 00:30:56,550
אבל אני שמח שאתה מכיר לפחות
איתם, כי זה שלנו ו

663
00:30:56,550 --> 00:31:00,520
הדגמת ספר, בעצב, מתים מאוד
מוות איטי של היכרות כאן.

664
00:31:00,520 --> 00:31:04,010
>> אבל זה מה שאני, לפחות, חזרה ב
בית ספר תיכון, המשמש לשימוש גיבויים.

665
00:31:04,010 --> 00:31:08,110
וזה היה מדהים, כי אתה
אפשר לאחסן 1.4 מגה בייט ב

666
00:31:08,110 --> 00:31:08,930
דיסק מיוחד זה.

667
00:31:08,930 --> 00:31:12,260
וזו הייתה גרסת הצפיפות הגבוהה,
כפי שצוין על ידי HD, שבו יש

668
00:31:12,260 --> 00:31:14,240
כלומר לפני קטעי וידאו HD של היום.

669
00:31:14,240 --> 00:31:16,400
>> צפיפות סטנדרטית הייתה 800 קילו.

670
00:31:16,400 --> 00:31:18,640
ולפני זה, היו
דיסקים של 400 קילובייט.

671
00:31:18,640 --> 00:31:23,120
ולפני זה, היו 5 ו 1/4
דיסקי אינץ, שהיו באמת, תקליטונים

672
00:31:23,120 --> 00:31:25,680
רחב יותר וגבוה יותר וקטנים
מהדברים האלה כאן.

673
00:31:25,680 --> 00:31:29,150
אבל אתה יכול ממש לראות את מה שנקרא
היבט דיסקט מהדיסקים האלה.

674
00:31:29,150 --> 00:31:32,630
>> ופונקציונלי, הם למעשה
די דומה לכוננים קשיחים של ב

675
00:31:32,630 --> 00:31:33,570
לפחות סוג זה.

676
00:31:33,570 --> 00:31:37,270
שוב, כונני SSD במחשבים חדשים
עובד קצת אחר.

677
00:31:37,270 --> 00:31:41,530
אבל אם אתה מזיז את לשונית מתכת קטנה ש,
למעשה אתה יכול לראות את עוגייה קטנה,

678
00:31:41,530 --> 00:31:42,560
או מגש.

679
00:31:42,560 --> 00:31:43,830
>> זה לא מתכת כמו זה.

680
00:31:43,830 --> 00:31:46,000
זה אחד בעצם קצת יותר זול
חומר פלסטיק.

681
00:31:46,000 --> 00:31:46,750
ואתה יכול להתנועע סוג שלו.

682
00:31:46,750 --> 00:31:50,310
ואתה כבר trully פשוט למחוק את חלק
מספר הביטים או חלקיקים מגנטיים

683
00:31:50,310 --> 00:31:51,220
מהדיסק הזה.

684
00:31:51,220 --> 00:31:52,710
>> אז תודה לאל, אין שום דבר על זה.

685
00:31:52,710 --> 00:31:55,790
אם הדבר שהוא בדרך - ולכסות
העיניים ושל השכן שלך שלך -

686
00:31:55,790 --> 00:31:58,865
אתה יכול פשוט סוג של למשוך את זה
כל את הנדן כזה.

687
00:31:58,865 --> 00:32:01,900
אבל יש מעיין קטן, כך שיהיה
מודע לזה בעיניים שלך.

688
00:32:01,900 --> 00:32:03,620
אז עכשיו יש לך באמת תקליטון.

689
00:32:03,620 --> 00:32:07,090
>> ומה שמדהים לגבי זה
הוא שככל שזה הוא

690
00:32:07,090 --> 00:32:10,830
ייצוג בקנה מידה קטנה של גדול
כונן קשיח, הדברים האלה הם סופר,

691
00:32:10,830 --> 00:32:11,590
פשוט סופר.

692
00:32:11,590 --> 00:32:15,170
אם אתה צובט את החלק התחתון שלו, עכשיו
דבר זה את המתכת, ולקלף

693
00:32:15,170 --> 00:32:20,990
שלהם לפתוח, כל מה שיש הוא שתי חתיכות
הרגיש ומה שנקרא התקליטון

694
00:32:20,990 --> 00:32:22,930
עם חתיכת המתכת בחלקו הפנימי.

695
00:32:22,930 --> 00:32:25,990
>> ושם הולכת מחצית
התוכן של הדיסק שלי.

696
00:32:25,990 --> 00:32:27,540
הנה עוד חצי מהם.

697
00:32:27,540 --> 00:32:31,375
אבל זה כל מה שמסתובב בפנים
מהמחשב שלך בפעם.

698
00:32:31,375 --> 00:32:35,220

699
00:32:35,220 --> 00:32:38,310
>> ושוב, כדי לשים את זה בפרספקטיבה נכונה,
כמה גדול הוא שרוב

700
00:32:38,310 --> 00:32:39,560
כוננים קשיח בימים אלה?

701
00:32:39,560 --> 00:32:41,960

702
00:32:41,960 --> 00:32:46,230
500 ג'יגה בייט, טרה, אולי ב
מחשב שולחני, 2 טרה, 3

703
00:32:46,230 --> 00:32:47,630
טרה, 4 טרה, נכון?

704
00:32:47,630 --> 00:32:52,480
זהו מגה אחד, פחות או יותר,
שאפילו לא יכול להתאים MP3 טיפוסי

705
00:32:52,480 --> 00:32:55,310
כבר בימים אלה, או חלק
קובץ מוסיקה דומה.

706
00:32:55,310 --> 00:32:59,500
>> אז מזכרת קטנה בשבילך היום, ו
גם כדי לעזור קונטקסטואליזציה מה

707
00:32:59,500 --> 00:33:03,570
יהיה לנו לקחת כמובן מאליו
עכשיו בבעיה להגדיר חמש.

708
00:33:03,570 --> 00:33:04,820
אז אלה הם שלך כדי לשמור.

709
00:33:04,820 --> 00:33:07,340

710
00:33:07,340 --> 00:33:13,370
אז תן לי מעבר לשם יהיה
הוצאות pset הבאה גם כן.

711
00:33:13,370 --> 00:33:18,470
אז יש לנו עכשיו להגדיר דף זה ל-- הו,
כמה הכרזות במהירות.

712
00:33:18,470 --> 00:33:21,730
>> ביום שישי הקרוב, אם ברצונך להצטרף CS50
לארוחת צהריים, ללכת למקום הרגיל,

713
00:33:21,730 --> 00:33:23,610
cs50.net/rsvp.

714
00:33:23,610 --> 00:33:25,100
ופרויקט גמר -

715
00:33:25,100 --> 00:33:28,520
אז לכל תכנית הלימודים, אנחנו כבר פורסמו
מפרט פרויקט גמר כבר.

716
00:33:28,520 --> 00:33:31,410
להבין שזה לא אומר
זה נובע בעיקר בקרוב.

717
00:33:31,410 --> 00:33:33,990
זה פורסם, באמת, רק כדי לקבל
אתם חושבים על זה.

718
00:33:33,990 --> 00:33:37,620
ואכן, סופר משמעותי
אחוז אתה תהיה התמודדות

719
00:33:37,620 --> 00:33:40,780
פרויקטים סופיים על חומר שאנו
אפילו לא הגיע בכיתה,

720
00:33:40,780 --> 00:33:42,730
אבל יהיה כבר בשבוע הבא.

721
00:33:42,730 --> 00:33:45,530
>> שים לב, עם זאת, שקורא למפרט
כמה מרכיבים שונים

722
00:33:45,530 --> 00:33:46,190
פרויקט גמר.

723
00:33:46,190 --> 00:33:49,590
הראשון, בכמה שבועות, הוא
לפני הצעה, דוא"ל די מזדמן ל

724
00:33:49,590 --> 00:33:52,760
TF שלך כדי לספר לו או מה שאתה
חושב על לפרויקט שלך, עם

725
00:33:52,760 --> 00:33:53,650
לא מחויבת.

726
00:33:53,650 --> 00:33:56,710
ההצעה תהיה ספציפית שלך
מחויבות, ואמר, הנה, זה מה

727
00:33:56,710 --> 00:33:57,770
אני רוצה לעשות לפרויקט שלי.

728
00:33:57,770 --> 00:33:58,250
מה אתה חושב?

729
00:33:58,250 --> 00:33:58,650
גדול מדי?

730
00:33:58,650 --> 00:33:59,145
קטן מדי?

731
00:33:59,145 --> 00:34:00,330
האם זה ניהול?

732
00:34:00,330 --> 00:34:02,230
ואתה רואה את המפרט לקבלת פרטים נוספים.

733
00:34:02,230 --> 00:34:05,060
>> כמה שבועות אחרי זה הוא המעמד
דו"ח, שהוא באופן דומה

734
00:34:05,060 --> 00:34:08,260
דוא"ל מזדמן לTF לומר עד כמה
הרחק מאחור אתה בסופי שלך

735
00:34:08,260 --> 00:34:12,360
יישומו של הפרויקט, ואחריו
Hackathon CS50 כדי שכולם

736
00:34:12,360 --> 00:34:17,520
הוא הוזמן, שיהיה אירוע מ
20:00 בערב אחד עד 07:00

737
00:34:17,520 --> 00:34:19,150
בבוקר למחרת.

738
00:34:19,150 --> 00:34:22,560
פיצה, כפי שאולי ציינו בשבוע
אפס, wil להיות מוגש בשעה 9:00 בערב,

739
00:34:22,560 --> 00:34:24,120
אוכל סיני בשעה 1:00 PM.

740
00:34:24,120 --> 00:34:27,929
ואם אתה עדיין ער בשעה 5:00 בבוקר,
אנחנו ניקח אותך לבית הפנקייק הבינלאומי לארוחת בוקר.

741
00:34:27,929 --> 00:34:31,310
>> אז Hackathon הוא אחד יותר
חוויות בלתי נשכחות בכיתה.

742
00:34:31,310 --> 00:34:35,290
אז היישום הוא עקב, ו
אז יריד CS50 השיא.

743
00:34:35,290 --> 00:34:38,070
פרטים נוספים על כל אלה
בשבועות הבאים.

744
00:34:38,070 --> 00:34:40,739
>> אבל בואו נחזור למשהו
בית ספר ישן -

745
00:34:40,739 --> 00:34:41,920
שוב, מערך.

746
00:34:41,920 --> 00:34:45,040
אז מערך היה נחמד, כי זה פותר
בעיות כמו שראינו פשוט

747
00:34:45,040 --> 00:34:49,290
לפני רגע עם מבני סטודנטים
מקבל קצת יצא מכלל שליטה אם

748
00:34:49,290 --> 00:34:52,405
רוצה להיות אחד תלמיד, תלמיד שניים,
תלמיד שלוש, סטודנט נקודת נקודת נקודה,

749
00:34:52,405 --> 00:34:54,400
מספר שרירותי חלק מתלמידים.

750
00:34:54,400 --> 00:34:58,850
>> אז מערכים, לפני כמה שבועות, עט ב
ופתרתי את כל הבעיות שלנו שלא

751
00:34:58,850 --> 00:35:03,340
לדעת מראש כמה דברים
מסוג כלשהו שאולי ירצו.

752
00:35:03,340 --> 00:35:07,390
וראינו שstructs יכול לעזור לנו
עוד יותר לארגן את הקוד שלנו ולשמור

753
00:35:07,390 --> 00:35:11,660
משתנים רעיוני דומים, כמו
שם ובית, ביחד, כדי ש

754
00:35:11,660 --> 00:35:15,570
ניתן להתייחס אליהם כישות אחת, בתוך
אשר יש חתיכות קטנות יותר.

755
00:35:15,570 --> 00:35:17,810
>> אבל יש כמה חסרונות מערכים.

756
00:35:17,810 --> 00:35:19,780
מה הם חלק מהחסרונות
נתקלנו

757
00:35:19,780 --> 00:35:22,320
עם מערכים עד כה?

758
00:35:22,320 --> 00:35:23,450
מה זה?

759
00:35:23,450 --> 00:35:28,130
גודל קבוע - כך שגם אם אתה עלול
תוכל להקצות זיכרון עבור

760
00:35:28,130 --> 00:35:32,310
מערך, ברגע שאתה יודע כמה תלמידים
יש לך, כמה תווים יש לך

761
00:35:32,310 --> 00:35:35,460
מהמשתמש, ברגע שיש לך שהוקצה
המערך, שיש לך סוג של צבוע

762
00:35:35,460 --> 00:35:36,740
את עצמך לפינה.

763
00:35:36,740 --> 00:35:40,600
>> כי אתה לא יכול להכניס אלמנטים חדשים
למרכז של מערך.

764
00:35:40,600 --> 00:35:43,660
אתה לא יכול להכניס יותר אלמנטים
בסופו של מערך.

765
00:35:43,660 --> 00:35:47,750
באמת, אתה צריך לפנות אל יצירת
מערך חדש לגמרי, כמו שאמרנו,

766
00:35:47,750 --> 00:35:49,320
העתקה הישנה לחדש.

767
00:35:49,320 --> 00:35:52,610
ושוב, זה כאב הראש ש
GetString עסקות עם בשבילך.

768
00:35:52,610 --> 00:35:56,170
>> אבל שוב, אתה לא יכול אפילו להכניס
משהו באמצע המערך

769
00:35:56,170 --> 00:35:58,200
אם קצב לא מלא לגמרי.

770
00:35:58,200 --> 00:36:03,010
לדוגמה, אם המערך הזה כאן בגודל
יש רק שישה חמישה דברים שבו,

771
00:36:03,010 --> 00:36:06,080
ובכן, אתה יכול רק טקטיקה
משהו על הסוף.

772
00:36:06,080 --> 00:36:08,200
אבל מה אם ברצונך להוסיף משהו
לאמצע

773
00:36:08,200 --> 00:36:11,280
מערך, למרות שאולי יש לו
חמש מתוך שישה דברים בו?

774
00:36:11,280 --> 00:36:14,250
>> ובכן, מה שאנחנו עשינו, כאשר היו לנו כל
המתנדבים האנושיים שלנו על הבמה ב

775
00:36:14,250 --> 00:36:15,110
שבועות האחרונים?

776
00:36:15,110 --> 00:36:18,710
אם אנחנו רוצים לשים מישהו כאן, או
האנשים האלה איך המהלך הזה

777
00:36:18,710 --> 00:36:22,540
דרך, או האנשים האלה איך המהלך הזה
דרך, ושהפך ליקר.

778
00:36:22,540 --> 00:36:26,950
הסטה של ​​אנשים בתוך
בסופו של מערך והוסיף ועולים

779
00:36:26,950 --> 00:36:31,240
לנו זמן, ולכן הרבה בריבוע N שלנו
ריצת פעמים כמו סוג ההכנסה, עבור

780
00:36:31,240 --> 00:36:32,550
למשל, במקרה הגרוע ביותר.

781
00:36:32,550 --> 00:36:36,520
אז מערכים הם דבר נהדרים, אבל יש לך
לדעת מראש עד כמה גדול אתה רוצה אותם.

782
00:36:36,520 --> 00:36:38,030
>> אז אוקיי, הנה פתרון.

783
00:36:38,030 --> 00:36:43,860
אם אני לא יודע מראש כמה
תלמידים אולי יש לי, ואני יודע שפעם אחת

784
00:36:43,860 --> 00:36:47,870
אני מחליט, אם כי, אני תקוע עם זה
תלמידים רבים, למה שאני לא פשוט תמיד

785
00:36:47,870 --> 00:36:51,740
להקצות כפליים חלל
כפי שאני עלול לחשוב שאני צריך?

786
00:36:51,740 --> 00:36:54,450
האם זה לא פתרון סביר?

787
00:36:54,450 --> 00:36:58,240
>> באופן מעשי, אני לא חושב שאנחנו
יזדקק ליותר מ -50 משבצות

788
00:36:58,240 --> 00:37:02,190
במערך לכיתה בגודל בינוני,
אז בואו רק לאסוף.

789
00:37:02,190 --> 00:37:07,040
אני אכין 100 חריצים במערך שלי, רק
כך שאנחנו בהחלט יכולים לקבל את

790
00:37:07,040 --> 00:37:10,330
מספר התלמידים אני מצפה
להיות בחלק הכיתה בגודל בינוני.

791
00:37:10,330 --> 00:37:14,320
אז למה לא פשוט לאסוף ולהקצות
יותר זיכרון, בדרך כלל, למערך

792
00:37:14,320 --> 00:37:16,290
ממה שאתה חושב שאתה אולי אפילו צריך?

793
00:37:16,290 --> 00:37:20,190
מה pushback הפשוט זו
לרעיון הזה?

794
00:37:20,190 --> 00:37:21,440
>> אתה סתם מבזבז זיכרון.

795
00:37:21,440 --> 00:37:25,350
פשוטו כמשמעו, כל תכנית שאתה כותב לאחר מכן
הוא אולי באמצעות כפליים זיכרון

796
00:37:25,350 --> 00:37:26,680
אתה באמת צריך.

797
00:37:26,680 --> 00:37:28,990
ופשוט לא מרגיש כמו ש
פתרון אלגנטי במיוחד.

798
00:37:28,990 --> 00:37:31,990
יתר על כן, זה פשוט מקטין את
הסתברות של בעיה.

799
00:37:31,990 --> 00:37:35,300
אם במקרה יש לי קורס פופולרי
סמסטר אחד ויש לך 101

800
00:37:35,300 --> 00:37:39,610
סטודנטים, התכנית שלך היא עדיין
בפני אותה הבעיה מן היסוד.

801
00:37:39,610 --> 00:37:44,280
>> אז למרבה המזל, יש פתרון ל
מודעה זו את כל הבעיות שלנו בצורה

802
00:37:44,280 --> 00:37:46,790
של מבני נתונים, כי הם
מורכב יותר מאלה

803
00:37:46,790 --> 00:37:47,970
שראינו עד כה.

804
00:37:47,970 --> 00:37:50,530
זה, אני טוען, הוא רשימה מקושרת.

805
00:37:50,530 --> 00:37:51,920
זוהי רשימה של מספרים -

806
00:37:51,920 --> 00:37:54,970
9, 17, 22, 26, ו -34 -

807
00:37:54,970 --> 00:38:00,120
שנקשרו יחד בדרך
ממה שנמשך כחצים.

808
00:38:00,120 --> 00:38:03,580
>> במילים אחרות, אם אני רוצה לייצג
מערך, שאני יכול לעשות

809
00:38:03,580 --> 00:38:04,910
משהו כזה.

810
00:38:04,910 --> 00:38:07,310
ואני אשים את זה על תקורה
ברגע.

811
00:38:07,310 --> 00:38:09,970
מה שיכולתי לעשות -

812
00:38:09,970 --> 00:38:12,520
הלו, הכל בסדר.

813
00:38:12,520 --> 00:38:14,470
לעמוד.

814
00:38:14,470 --> 00:38:17,360
מחשב חדש כאן, ברור -

815
00:38:17,360 --> 00:38:18,090
בסדר.

816
00:38:18,090 --> 00:38:21,730
>> אז אם יש לי את המספרים האלה במערך -

817
00:38:21,730 --> 00:38:28,880
9, 17, 22, 26, 24 -

818
00:38:28,880 --> 00:38:30,530
לא בהכרח בקנה מידה.

819
00:38:30,530 --> 00:38:33,730
בסדר, אז הנה הוא המערך שלי -

820
00:38:33,730 --> 00:38:34,980
אוי, אלוהים.

821
00:38:34,980 --> 00:38:38,700

822
00:38:38,700 --> 00:38:40,395
בסדר, אז הנה הוא המערך שלי.

823
00:38:40,395 --> 00:38:44,110

824
00:38:44,110 --> 00:38:45,050
אוי אלוהים.

825
00:38:45,050 --> 00:38:48,820
>> [שחוק]

826
00:38:48,820 --> 00:38:49,440
>> דוד Malan: להעמיד פן.

827
00:38:49,440 --> 00:38:52,330
זה יותר מדי מאמץ כדי לחזור
ולתקן את זה, ולכן יש -

828
00:38:52,330 --> 00:38:54,290
26.

829
00:38:54,290 --> 00:38:57,650
אז יש לנו מערך זה של
9, 17, 22, 26, ו -34.

830
00:38:57,650 --> 00:39:00,260
לאלו מכם יכולים לראות את
טעות מביכה אני רק עשיתי,

831
00:39:00,260 --> 00:39:00,830
זה מה שיש.

832
00:39:00,830 --> 00:39:04,490
>> אז אני טוען שזה הוא
פתרון יעיל מאוד.

833
00:39:04,490 --> 00:39:07,310
אני כבר נזקף כints רבים ככל
אני צריך - אחד, שתיים, שלוש,

834
00:39:07,310 --> 00:39:09,100
ארבעה, חמש, או שישה -

835
00:39:09,100 --> 00:39:11,660
ואני כבר אז מאוחסן המספרים
בתוך המערך הזה.

836
00:39:11,660 --> 00:39:15,220
אבל נניח, אם כן, ברצוני להוסיף
ערך כמו המספר 8?

837
00:39:15,220 --> 00:39:16,100
ובכן, לאן זה הולך?

838
00:39:16,100 --> 00:39:18,530
נניח שאני רוצה להוסיף
מספר כמו 20.

839
00:39:18,530 --> 00:39:19,790
ובכן, לאן זה הולך?

840
00:39:19,790 --> 00:39:23,160
יש אי שם באמצע,
או שיש את המספר 35 כדי ללכת

841
00:39:23,160 --> 00:39:24,010
אי שם בסוף.

842
00:39:24,010 --> 00:39:25,320
אבל נגמרתי לי מקום.

843
00:39:25,320 --> 00:39:29,120
>> ואז זה אתגר בסיסי
של מערכים זה נמצא הפתרון.

844
00:39:29,120 --> 00:39:32,280
אני טענו לפני רגע, GetString
פותר בעיה זו.

845
00:39:32,280 --> 00:39:37,380
אם ברצונך להוסיף מספר שישי
למערך זה, מה הוא אחד לפחות

846
00:39:37,380 --> 00:39:40,090
פתרון שאתה יכול להישען עליו בודאות,
בדיוק כמו שאנחנו עושים עם GetString?

847
00:39:40,090 --> 00:39:44,340

848
00:39:44,340 --> 00:39:46,030
מה זה?

849
00:39:46,030 --> 00:39:48,190
>> ובכן, לעשות את זה יותר גדול הוא
קל יותר לומר מאשר לעשות.

850
00:39:48,190 --> 00:39:52,810
אנחנו לא בהכרח יכולים לעשות את המערך
גדול יותר, אבל מה אנחנו יכולים לעשות?

851
00:39:52,810 --> 00:39:56,570
הפוך את מערך חדש שגדולים יותר, בגודל
6, או אולי גודל 10, אם אנחנו רוצים

852
00:39:56,570 --> 00:40:00,490
כדי להקדים את הדברים, ולאחר מכן להעתיק
מערך הישן לחדש, ולאחר מכן

853
00:40:00,490 --> 00:40:01,680
לשחרר את המערך הישן.

854
00:40:01,680 --> 00:40:05,770
>> אבל מה זמן הריצה
עכשיו זה תהליך?

855
00:40:05,770 --> 00:40:09,870
זה גדול O של n, בגלל ההעתקה
הוא הולך לעלות לך כמה יחידות של

856
00:40:09,870 --> 00:40:13,480
זמן, ולכן לא כל כך אידיאלי אם יש לנו
להקצות מערך חדש, אשר עומד

857
00:40:13,480 --> 00:40:15,610
לצרוך כפליים
זיכרון באופן זמני.

858
00:40:15,610 --> 00:40:16,660
עותק ישן לחדש -

859
00:40:16,660 --> 00:40:18,800
אני מתכוון, זה רק כאב ראש, אשר
הוא, שוב, למה שכתבנו

860
00:40:18,800 --> 00:40:19,920
GetString בשבילך.

861
00:40:19,920 --> 00:40:21,380
>> אז מה שהיינו עושה במקום זה?

862
00:40:21,380 --> 00:40:25,000
ובכן, מה אם מבנה הנתונים שלנו
יש פערים בזה בעצם?

863
00:40:25,000 --> 00:40:30,790
נניח שאני נרגע המטרה של בעל שלי
גושים רציפים של זיכרון, שבי 9

864
00:40:30,790 --> 00:40:34,500
נמצא ממש ליד 17, שהוא
ממש ליד 22, וכן הלאה.

865
00:40:34,500 --> 00:40:39,570
>> ונניח ש9 יכולים להיות כאן ב
יכולים להיות מעל זיכרון RAM, ו -17 כאן בזכרון RAM,

866
00:40:39,570 --> 00:40:40,990
ויכול להיות מעל 22 כאן בזכרון RAM.

867
00:40:40,990 --> 00:40:43,610
במילים אחרות, אני לא צריך אותם
אפילו גב אל הגב יותר.

868
00:40:43,610 --> 00:40:47,850
אני רק צריך להשחיל חוט במחט איכשהו
באמצעות כל אחד ממספרים אלה, או כל

869
00:40:47,850 --> 00:40:51,010
של בלוטות אלה, כפי שאנו נתקשר
מלבנים כפי שצוירתי להם, ל

870
00:40:51,010 --> 00:40:55,670
זוכר איך להגיע עד האחרון
צומת כזו מראשונה.

871
00:40:55,670 --> 00:40:59,940
>> אז מה הוא תכנות לבנות
ראינו לא מזמן שבה אני

872
00:40:59,940 --> 00:41:03,030
ניתן ליישם נושא זה, או
נמשך לכאן, עם שאני יכול

873
00:41:03,030 --> 00:41:05,430
ליישם החיצים האלה?

874
00:41:05,430 --> 00:41:06,500
מצביעים כל כך, נכון?

875
00:41:06,500 --> 00:41:09,560
אם אני לא רק להקצות
int, אבל צומת - ועל ידי

876
00:41:09,560 --> 00:41:10,810
צומת, אני רק אומר מיכל.

877
00:41:10,810 --> 00:41:12,900
וחזותי, אני מתכוון למלבן.

878
00:41:12,900 --> 00:41:16,420
אז כנראה צריכה צומת
כדי להכיל שני ערכים -

879
00:41:16,420 --> 00:41:21,490
int עצמו, ולאחר מכן, כפי שנרמז על ידי
את החצי התחתון של המלבן,

880
00:41:21,490 --> 00:41:23,010
מספיק מקום עבור int.

881
00:41:23,010 --> 00:41:26,130
>> אז פשוט חושב קדימה כאן,
כמה גדול היא הצומת הזה, זה

882
00:41:26,130 --> 00:41:27,170
המכל בשאלה?

883
00:41:27,170 --> 00:41:29,250
כמה בתים עבור Int?

884
00:41:29,250 --> 00:41:31,310
להניח 4, אם זה
כרגיל.

885
00:41:31,310 --> 00:41:33,270
ואז כמה בתים
למצביע?

886
00:41:33,270 --> 00:41:33,650
4.

887
00:41:33,650 --> 00:41:37,940
אז המכל הזה, או צומת זה, הוא
הולך להיות מבנה 8 בתים.

888
00:41:37,940 --> 00:41:41,760
אה, וזה צירוף מקרים משמח, כי
אנחנו פשוט הצגנו את הרעיון הזה של

889
00:41:41,760 --> 00:41:44,400
struct, או מבנה C.

890
00:41:44,400 --> 00:41:48,890
>> אז אני טוען שאני רוצה לקחת את צעד
לכיוון הזה מתוחכם יותר

891
00:41:48,890 --> 00:41:52,560
יישום של רשימת המספרים,
רשימה מקושרת של מספרים, שאני צריך לעשות

892
00:41:52,560 --> 00:41:56,920
קצת יותר חשיבה ומלפנים
להכריז לא רק int, אבל struct

893
00:41:56,920 --> 00:41:58,620
שאני אתקשר, כמקובל
כאן, צומת.

894
00:41:58,620 --> 00:42:01,630
אנחנו יכולים לקרוא לזה מה שאנחנו רוצים, אבל
הצומת הולכת להיות נושאיות בהרבה

895
00:42:01,630 --> 00:42:03,560
מהדברים שאנחנו מתחילים להסתכל על החברה.

896
00:42:03,560 --> 00:42:06,480
>> בתוך הצומת, כי הוא n int.

897
00:42:06,480 --> 00:42:09,350
ולאחר מכן תחביר זה, קצת
מוזר במבט הראשון -

898
00:42:09,350 --> 00:42:12,960
* struct הצומת הבאה.

899
00:42:12,960 --> 00:42:16,900
ובכן ציורי, מה זה?

900
00:42:16,900 --> 00:42:21,000
כלומר החצי התחתון של
המלבן שראינו

901
00:42:21,000 --> 00:42:22,730
רק לפני רגע.

902
00:42:22,730 --> 00:42:27,600
>> אבל למה שאני אומר struct צומת *
בניגוד לסתם * צומת?

903
00:42:27,600 --> 00:42:31,370
משום שאם מצביע המצביע
בצומת אחרת, זה פשוט

904
00:42:31,370 --> 00:42:32,760
כתובת של צומת.

905
00:42:32,760 --> 00:42:35,630
זה עולה בקנה אחד עם מה שיש לנו
דן על מצביעים עד כה.

906
00:42:35,630 --> 00:42:39,690
אבל למה, אם אני טוען שמבנה זה הוא
נקרא צומת, האם אני חייב לומר struct

907
00:42:39,690 --> 00:42:42,660
צומת כאן בפנים?

908
00:42:42,660 --> 00:42:43,190
>> בדיוק.

909
00:42:43,190 --> 00:42:46,490
זה סוג של מציאות טיפשית של ג
Typedef, כביכול, יש לו לא

910
00:42:46,490 --> 00:42:47,220
קרה עדיין.

911
00:42:47,220 --> 00:42:48,510
C הוא סופר מילולי.

912
00:42:48,510 --> 00:42:51,050
הוא קורא את הקוד שלך לראש
למטה, משמאל לימין.

913
00:42:51,050 --> 00:42:54,930
ועד שהוא פוגע פסיק שעל
שורה תחתונה, נחשו מה לא

914
00:42:54,930 --> 00:42:57,590
קיים כסוג הנתונים?

915
00:42:57,590 --> 00:42:59,060
צומת, צומת סוף הציטוט.

916
00:42:59,060 --> 00:43:03,050
>> אבל בגלל יותר המפורט
הצהרה שעשיתי בשורה הראשונה -

917
00:43:03,050 --> 00:43:05,340
צומת struct typedef -

918
00:43:05,340 --> 00:43:08,790
מכיוון שהגיעו בפעם ראשונה, לפני
סוגריים מסולסלים, זה כמו סוג של

919
00:43:08,790 --> 00:43:11,800
-לחנך מראש קלאנג זה, אתה
יודע מה, תן לי struct

920
00:43:11,800 --> 00:43:13,570
נקרא צומת struct.

921
00:43:13,570 --> 00:43:16,270
למען האמת, אני לא אוהב את הדברים שקראו
struct צומת, struct צומת כל

922
00:43:16,270 --> 00:43:17,090
לאורך כל הקוד שלי.

923
00:43:17,090 --> 00:43:20,660
אבל אני אשתמש בו רק פעם אחת, רק בפנים,
כך שאני יכול בצורה יעילה

924
00:43:20,660 --> 00:43:25,010
ליצור סוג של הפניה מעגלית, לא
מצביע לעצמי כשלעצמה, אלא

925
00:43:25,010 --> 00:43:29,400
מצביע נוסף של
סוג זהה.

926
00:43:29,400 --> 00:43:32,330
>> אז מתברר שעל מבנה הנתונים
ככה, יש כמה

927
00:43:32,330 --> 00:43:34,470
פעולות שעשויות להיות
עניין לנו.

928
00:43:34,470 --> 00:43:37,460
אנחנו אולי רוצים להכניס
לרשימה כזאת.

929
00:43:37,460 --> 00:43:39,850
אנחנו אולי רוצים למחוק
מתוך רשימה כזאת.

930
00:43:39,850 --> 00:43:43,490
אנחנו אולי רוצים לחפש ברשימה עבור
ערך, או באופן כללי יותר, Traverse.

931
00:43:43,490 --> 00:43:46,410
וחוצה היא רק דרך מפוארת של
אומר התחלה בצד השמאל ולהעביר את כל

932
00:43:46,410 --> 00:43:47,650
הדרך הנכונה.

933
00:43:47,650 --> 00:43:52,640
>> ושים לב, גם עם זה מעט יותר
מבנה נתונים מתוחכם, בוא

934
00:43:52,640 --> 00:43:56,510
לי להציע שאנחנו יכולים ללוות כמה
הרעיונות של השבועיים האחרונים ו

935
00:43:56,510 --> 00:43:58,410
ליישם פונקציה הנקראת
חיפוש כזה.

936
00:43:58,410 --> 00:44:01,360
זה הולך לחזור נכון או
שקר, מה שמעיד, כן או

937
00:44:01,360 --> 00:44:03,390
לא, n הוא ברשימה.

938
00:44:03,390 --> 00:44:05,960
הטענה השנייה שלו היא מצביע
לרשימה עצמה, ולכן

939
00:44:05,960 --> 00:44:07,920
מצביע לצומת.

940
00:44:07,920 --> 00:44:10,350
>> כל מה שאני הולך לעשות אז הוא מצהיר
משתנה זמני.

941
00:44:10,350 --> 00:44:12,730
אנחנו קוראים לזה PTR על ידי אמנה,
למצביע.

942
00:44:12,730 --> 00:44:15,220
ואני להקצות אותו שווה ל
תחילתה של הרשימה.

943
00:44:15,220 --> 00:44:16,680
>> ועכשיו שים לב ללולאה בזמן.

944
00:44:16,680 --> 00:44:20,640
כל עוד מצביע אינו שווה
לnull, אני הולך לבדוק.

945
00:44:20,640 --> 00:44:24,520
האם חץ מצביע N שווה ל
n שנחקק בשנת?

946
00:44:24,520 --> 00:44:26,410
וחכה רגע - חדש
חתיכת התחביר.

947
00:44:26,410 --> 00:44:29,324
מהו חץ פתאום?

948
00:44:29,324 --> 00:44:30,574
כן?

949
00:44:30,574 --> 00:44:34,200

950
00:44:34,200 --> 00:44:34,810
>> בדיוק.

951
00:44:34,810 --> 00:44:38,860
אז בעוד שלפני כמה דקות, השתמשנו
סימון הנקודה כדי לגשת למשהו

952
00:44:38,860 --> 00:44:43,080
בתוך struct, אם משתנה
יש לך לא struct

953
00:44:43,080 --> 00:44:47,420
עצמו, אלא מצביע למבנה,
למרבה המזל, יצירה של תחביר כי

954
00:44:47,420 --> 00:44:48,620
סוף סוף היגיון אינטואיטיבי.

955
00:44:48,620 --> 00:44:52,360
החץ אומר לעקוב מצביע,
כמו החיצים שלנו בדרך כלל אומר

956
00:44:52,360 --> 00:44:56,570
ציורי, וללכת ב
נתוני שדה בפנים.

957
00:44:56,570 --> 00:44:59,700
אז חץ הוא אותו דבר כמו נקודה, אבל
אתה משתמש בו כאשר יש לך מצביע.

958
00:44:59,700 --> 00:45:05,270
>> אז רק כדי לסכם ולאחר מכן, אם שדה n
בתוך struct בשם מצביע

959
00:45:05,270 --> 00:45:07,760
שווה שווה n, החזר אמיתי.

960
00:45:07,760 --> 00:45:11,970
אחרת, את הקו הזה כאן - מצביע
שווה מצביע הבא.

961
00:45:11,970 --> 00:45:17,540
אז מה זה עושה, שים לב, הוא אם אני
כרגע אני מצביע על struct

962
00:45:17,540 --> 00:45:21,430
המכיל 9, 9 ולא במספר
אני מחפש - נניח שאני מחפש

963
00:45:21,430 --> 00:45:22,830
עבור n שווה 50 -

964
00:45:22,830 --> 00:45:25,930
אני הולך לעדכן את המצביע הזמני שלי
לא להצביע בצומת זה

965
00:45:25,930 --> 00:45:31,190
יותר, אבל מצביע חץ, אשר
הוא הולך לשים אותי כאן.

966
00:45:31,190 --> 00:45:34,270
>> עכשיו, הבנתי היא מערבולת
הקדמה.

967
00:45:34,270 --> 00:45:37,380
ביום רביעי, אנחנו באמת נעשה את זה
עם כמה בני אדם ועם קצת יותר

968
00:45:37,380 --> 00:45:38,900
קוד בקצב איטי יותר.

969
00:45:38,900 --> 00:45:42,990
אבל תבין, אנחנו עכשיו עושים את הנתונים שלנו
מבנים מורכבים יותר, כך ש

970
00:45:42,990 --> 00:45:45,780
אלגוריתמים יכולים לקבל יעיל יותר, אשר
הולך להיות מוקדם ל

971
00:45:45,780 --> 00:45:50,500
שש pset, כאשר אנו לטעון ב, שוב, אלה
150,000 מילים, אבל צריך לעשות זאת

972
00:45:50,500 --> 00:45:55,650
ביעילות, ובאופן אידיאלי, ליצור
תכנית שפועלת עבור המשתמשים שלנו לא ב

973
00:45:55,650 --> 00:46:00,460
ליניארי, לא בn בריבוע, אבל ב
זמן קבוע, באידאל.

974
00:46:00,460 --> 00:46:02,300
>> נתראה ביום רביעי.

975
00:46:02,300 --> 00:46:07,240
>> דובר: בCS50 הבא, דוד
שוכח מקרה הבסיס שלו.

976
00:46:07,240 --> 00:46:12,770
>> דוד Malan: וזה איך שאתה שולח
הודעות טקסט עם ג מה -

977
00:46:12,770 --> 00:46:14,020
>> [הודעה טקסט שונות
הודעת SOUNDS]

978
00:46:14,020 --> 00:46:19,734