1
00:00:00,000 --> 00:00:09,780
>> [השמעת מוסיקה]

2
00:00:09,780 --> 00:00:11,150
>> ZAMYLA צ'אן: בואו להתמודד להתאושש.

3
00:00:11,150 --> 00:00:14,030
שחזור הוא כנראה PSET האהוב עליי,
ובעיקר משום שאני חושב שזה

4
00:00:14,030 --> 00:00:15,650
ממש, ממש מגניב.

5
00:00:15,650 --> 00:00:19,040
בעיקרון, אתה נתון זיכרון
כרטסת שבי

6
00:00:19,040 --> 00:00:20,900
תמונות נמחקו.

7
00:00:20,900 --> 00:00:23,650
אבל מה אתה הולך
לעשות הוא לשחזר את כולם.

8
00:00:23,650 --> 00:00:24,250
>> על אישור.

9
00:00:24,250 --> 00:00:28,230
אז זה באמת מרגש, אבל אולי
קצת מפחיד, כי אתה

10
00:00:28,230 --> 00:00:32,430
ניתנה קובץ C ריק ו
אתה צריך למלא אותו פנימה

11
00:00:32,430 --> 00:00:36,250
אוקיי, אז בואו לשבור את זה
לחלקים לניהול.

12
00:00:36,250 --> 00:00:38,160
אתה רוצה לפתוח את
קובץ לכרטיס זיכרון.

13
00:00:38,160 --> 00:00:39,900
זה נראה די פשוט.

14
00:00:39,900 --> 00:00:43,030
לאחר מכן, למצוא את תחילת
של תמונה מסוג JPG.

15
00:00:43,030 --> 00:00:46,740
כל הקבצים בזיכרון הזה
כרטיס הולך להיות jpgs.

16
00:00:46,740 --> 00:00:50,840
ואז, ברגע שאתה מוצא את ההתחלה,
אתה הולך לפתוח JPG חדש, כי

17
00:00:50,840 --> 00:00:57,610
הוא, כמו, ליצור JPG, ולכתוב 512
בתים בכל פעם עד JPG חדש הוא

18
00:00:57,610 --> 00:01:02,930
נמצא, וסיום התכנית, ברגע
לך לזהות סוף הקובץ.

19
00:01:02,930 --> 00:01:06,400
>> צעדים אז הראשונים הוא ראשון שפתחו
את הקובץ לכרטיס זיכרון.

20
00:01:06,400 --> 00:01:09,850
אבל אתה יודע את זה כבר, ויש
פונקצית קלט / פלט קובץ שהולכת

21
00:01:09,850 --> 00:01:12,030
להיות שימושי מאוד.

22
00:01:12,030 --> 00:01:12,820
על אישור.

23
00:01:12,820 --> 00:01:14,760
אז מה הם jpgs?

24
00:01:14,760 --> 00:01:16,330
כי אנחנו צריכים את תחילתו.

25
00:01:16,330 --> 00:01:21,310
ובכן, jpgs, בדיוק כמו מפות סיביות,
הם רק רצפים של בתים.

26
00:01:21,310 --> 00:01:30,660
למרבה המזל, כל JPG מתחיל עם או
0xFF, 0xd8, 0xFF, 0xe0, רצף אחד

27
00:01:30,660 --> 00:01:33,610
של בתים, או אחר
רצף של בתים.

28
00:01:33,610 --> 00:01:37,250
>> אז ארבעת בתים אלה מצביעים
תחילתו של JPG.

29
00:01:37,250 --> 00:01:40,780
לא אחרים מאשר שני שילובים אלה
של ארבעה בתים.

30
00:01:40,780 --> 00:01:44,840
ומזלנו, עובדה נוספת שאנו
יכול לנצל הוא שכל

31
00:01:44,840 --> 00:01:48,550
JPG מאוחסן Side-by-צד
בכרטיס הזיכרון.

32
00:01:48,550 --> 00:01:52,210
אני ייצגתי את המבנה
כרטיס זיכרון באופן סכמטי על זה

33
00:01:52,210 --> 00:01:53,310
להחליק כאן.

34
00:01:53,310 --> 00:01:59,270
כאן, בכל כיכר, בכל מלבן,
מייצג 512 בתים, וזה מתחיל

35
00:01:59,270 --> 00:02:01,750
עם אפור שבאנחנו לא
באמת יש לי JPG.

36
00:02:01,750 --> 00:02:05,700
>> אבל אז אנחנו סוף סוף פגעו
בלוק עם כוכב.

37
00:02:05,700 --> 00:02:10,940
זה אומר שארבעה הבתים הראשונים מתוך
של אלה 512 הם אחד משני אלה

38
00:02:10,940 --> 00:02:13,230
החל רצפים של JPG.

39
00:02:13,230 --> 00:02:17,340
ואנחנו הולכים משם, ואז ברגע
JPG אחד מסתיים, הבא מתחיל.

40
00:02:17,340 --> 00:02:20,990
אנחנו לא אי פעם יש יותר
שטח אפור שביניהם.

41
00:02:20,990 --> 00:02:25,550
>> אבל איך אנחנו באמת קוראים את זה, ו
לקרוא את 512 בתים, כך שנוכל לעשות

42
00:02:25,550 --> 00:02:27,500
ההשוואה במקום הראשון?

43
00:02:27,500 --> 00:02:33,470
ובכן, בואו נחזור לfread, אשר
לוקח בstruct שיכיל

44
00:02:33,470 --> 00:02:34,470
הבתים שאתה קורא.

45
00:02:34,470 --> 00:02:36,570
אז אתה הולך לשים
אלה שביש -

46
00:02:36,570 --> 00:02:42,192
הגודל, המספר, ולאחר מכן inpointer
שאתה קורא מ.

47
00:02:42,192 --> 00:02:49,900
עכשיו, אנחנו רוצים לקרוא 512 בכל פעם, ו
אנחנו רוצים לשמור אותם במאגר,

48
00:02:49,900 --> 00:02:50,700
אני הולך לקרוא לזה.

49
00:02:50,700 --> 00:02:54,100
>> בעיקרון, אנחנו הולכים להחזיק
על 512 בתים אלה ולעשות

50
00:02:54,100 --> 00:02:55,500
דברים איתו, נכון?

51
00:02:55,500 --> 00:02:58,260
אנחנו הולכים גם להשוואה הראשונה
ארבעה בתים, או שאנחנו הולכים

52
00:02:58,260 --> 00:02:59,830
קראת אותו ב, בסדר?

53
00:02:59,830 --> 00:03:05,050
אז את מצביע נתונים אז יהיה
תשמש כחיץ שלך, ו

54
00:03:05,050 --> 00:03:07,745
inpointer, ובכן, זה רק הולך
להיות כרטיס הזיכרון שלך.

55
00:03:07,745 --> 00:03:09,500
>> חזור לסכמטית כרטיס זיכרון שלנו.

56
00:03:09,500 --> 00:03:14,690
אנחנו הולכים לקרוא 512 בתים בכל פעם,
אחסון כל בלוק 512 בתים

57
00:03:14,690 --> 00:03:19,190
לחיץ, גבי מחזיק אלה
חיץ, 512 בתים אלה, עד שנדע

58
00:03:19,190 --> 00:03:22,000
בדיוק מה לעשות בהם.

59
00:03:22,000 --> 00:03:25,960
אז ההתחלה היא לא משהו, אז
אנו קוראים למאגר, להשוות אותו, ו

60
00:03:25,960 --> 00:03:28,160
אנחנו לא צריכים לעשות שום דבר עם זה.

61
00:03:28,160 --> 00:03:32,030
ואז, סוף סוף פגעו כוכב
לחסום, כלומר יש לנו

62
00:03:32,030 --> 00:03:33,630
מצאתי JPG הראשון שלנו.

63
00:03:33,630 --> 00:03:36,560
אז חיץ החברה מחזיק
ביטים מJPG ש.

64
00:03:36,560 --> 00:03:40,220
>> בפעם הבאה ש512 בתים, בגלל שהם
לא לחסום כוכב, גם

65
00:03:40,220 --> 00:03:41,740
חלק מJPG ש.

66
00:03:41,740 --> 00:03:47,630
וjpgs הם רציף משם
ב, עד שפגענו בJPG הבא.

67
00:03:47,630 --> 00:03:51,880
ולאחר מכן החיץ אז מחזיק
512 בתים לJPG ש, ו

68
00:03:51,880 --> 00:03:53,580
כן הלאה, וכן הלאה.

69
00:03:53,580 --> 00:03:54,250
על אישור.

70
00:03:54,250 --> 00:03:58,980
>> אז ברגע שאתה מכה ראשון שסומן בכוכב
בלוק, JPG הראשון, איך אתה

71
00:03:58,980 --> 00:04:01,910
בעצם, טוב, לפתוח אותו?

72
00:04:01,910 --> 00:04:04,990
בואו להפוך JPG חדש.

73
00:04:04,990 --> 00:04:08,846
שמות הקבצים לJPG הולכים
להיות בפורמט, מספר, מספר,

74
00:04:08,846 --> 00:04:13,830
number.jpg, בכך שהם שמו ב
הסדר שבו הם נמצאים,

75
00:04:13,830 --> 00:04:14,780
החל מ 0.

76
00:04:14,780 --> 00:04:19,890
>> אז JPG הראשון שאתה
למצוא יהיה 000.jpg.

77
00:04:19,890 --> 00:04:26,560
אז, כנראה רעיון טוב כדי לעקוב אחר
של כמה jpgs שמצאת עד כה.

78
00:04:26,560 --> 00:04:27,610
אז זה את שם הקובץ.

79
00:04:27,610 --> 00:04:29,660
אבל איך אתה בעצם לעשות את זה?

80
00:04:29,660 --> 00:04:34,310
ובכן, אנחנו הולכים להשתמש
פונקציה שנקראת sprintf.

81
00:04:34,310 --> 00:04:38,260
קצת דומה לprintf, שבו
אתה יכול להשתמש במצייני מיקום עבור מחרוזות,

82
00:04:38,260 --> 00:04:42,420
למעט במקרה זה, sprintf תדפיס
הקובץ יצא אל תוך הזרם

83
00:04:42,420 --> 00:04:45,550
ספרייה, לא לתוך הטרמינל.

84
00:04:45,550 --> 00:04:46,120
>> על אישור.

85
00:04:46,120 --> 00:04:49,950
אז הנה אנו רואים שיש לנו כותרת,
מערך תווים שיאחסן את

86
00:04:49,950 --> 00:04:55,120
מחרוזת תוצאה, ואנחנו עוברים ב
כותרת של המחרוזת בפועל עם

87
00:04:55,120 --> 00:04:58,720
מציין מיקום, בדיוק כמו שאנחנו כבר
למד לעשות עם printf.

88
00:04:58,720 --> 00:05:05,530
אבל הקוד הזה שיש לי כאן
ייתן 2.jpg, לא 002.jpg.

89
00:05:05,530 --> 00:05:09,920
אז אני אשאיר לכם לגלות איך
לשנות את המיקום על מנת להפוך את

90
00:05:09,920 --> 00:05:11,920
שם נכון.

91
00:05:11,920 --> 00:05:12,610
>> על אישור.

92
00:05:12,610 --> 00:05:17,390
אז ברגע שיש לך sprintf'd אז אתה יכול
לפתוח את הקובץ, כי זה קיים ב

93
00:05:17,390 --> 00:05:22,690
במדריך שלך, עם fopen, באמצעות
כותרת, ולאחר מכן כל מה מצב רצוי

94
00:05:22,690 --> 00:05:25,140
כדי לפתוח קובץ שבו

95
00:05:25,140 --> 00:05:30,260
אז עכשיו שאנחנו כבר פתחנו קובץ JPG חדש,
עכשיו אנחנו יכולים לכתוב 512 בתים ב

96
00:05:30,260 --> 00:05:33,320
פעם, עד JPG חדש הוא נמצא.

97
00:05:33,320 --> 00:05:36,640
אז בואו לקחת מבט נוסף
בתחביר של fwrite.

98
00:05:36,640 --> 00:05:40,060
>> אני יודע שאני מראה את השקופית הזאת
הרבה, אבל אני רק רוצה לוודא כי

99
00:05:40,060 --> 00:05:43,530
אתם לא מתבלבלים מדי, כי
אני יודע שזה מאוד קל

100
00:05:43,530 --> 00:05:47,000
לערבב הראשון ואחרון
ויכוח, בפרט.

101
00:05:47,000 --> 00:05:54,390
אך יש לזכור כי אתה כותב מ
החיץ שלך לתוך תמונות קובץ החוצה.

102
00:05:54,390 --> 00:05:59,250
>> עכשיו שאתה יודע איך לכתוב 512
ביטים לתוך קובץ JPG שלך, כי אתה כבר

103
00:05:59,250 --> 00:06:03,230
נוצר, ובכן, אנחנו רוצים לעצור את זה
תהליך ברגע שכבר הגיעו לסוף

104
00:06:03,230 --> 00:06:06,720
הכרטיס שלנו, כי לא יהיה
עוד תמונות שאפשר למצוא.

105
00:06:06,720 --> 00:06:10,760
אז בואו נחזור לfread
עוד פעם אחת, אני מבטיח.

106
00:06:10,760 --> 00:06:15,600
fread מחזירה פריטים כמה מגודל,
גודל, היה מוכן בהצלחה.

107
00:06:15,600 --> 00:06:19,440
באופן אידיאלי, זה הולך להיות כל מה
אתה עובר למספר, נכון?

108
00:06:19,440 --> 00:06:24,140
בגלל שאתה מנסה לקרוא את המספר
אלמנטים של גודל, גודל.

109
00:06:24,140 --> 00:06:29,380
אבל אם fread היא לא מסוגלת לקרוא כי
מספר האלמנטים, אז זה יחזור

110
00:06:29,380 --> 00:06:32,530
מה מספר זה לקרוא בהצלחה.

111
00:06:32,530 --> 00:06:36,310
>> עכשיו, דבר אחד חשוב שיש לשים לב
כי אם אתה משתמש בקובץ אחר I / O

112
00:06:36,310 --> 00:06:43,860
פונקציה כמו fgetc, זה יהיה גם לחזור
כמה פריטים זה לקרוא בהצלחה.

113
00:06:43,860 --> 00:06:48,000
מה שימושי על פונקציה זו היא
כי אם אתה משתמש בפונקציות פנימיים של

114
00:06:48,000 --> 00:06:53,190
מצב, זה יהיה לבצע את עצמו בזמן
קביעת מצב זה, שבו הוא

115
00:06:53,190 --> 00:06:54,340
רק באמת שימושי.

116
00:06:54,340 --> 00:07:00,440
אז אם יש לך את זה בתנאים, למשל,
אם חיץ fread, כלב sizeof, 2,

117
00:07:00,440 --> 00:07:04,870
מצביע, שווה שווה 1, כי
אומר שהייתי רוצה לקרוא

118
00:07:04,870 --> 00:07:06,540
2 כלבים באותו הזמן.

119
00:07:06,540 --> 00:07:13,490
אבל אם fread מחזירה 1 במקום 2 כמו
צפוי, זה אומר שיש 2

120
00:07:13,490 --> 00:07:16,480
כלבים שנשארו בתיק שלי, אלא 1.

121
00:07:16,480 --> 00:07:22,450
אבל אם היא מחזירה 2, אז עדיין יש לי
2 כלבים אלה בתוך החיץ שלי.

122
00:07:22,450 --> 00:07:26,280
>> אז עכשיו שנותן לך תחושה של איך
לבדוק לסוף הקובץ, אבל

123
00:07:26,280 --> 00:07:28,940
בואו נעבור עכשיו לוגיקה.

124
00:07:28,940 --> 00:07:32,460
איך אנחנו באמת חתיכה כל
האלמנטים האלה יחד?

125
00:07:32,460 --> 00:07:36,880
ברגע שנתחיל JPG הראשון שלנו, שכן
אנו יודעים כי jpgs מאוחסנים

126
00:07:36,880 --> 00:07:40,910
בסמיכות, יהיה לנו לכתוב עד
אנחנו מגיעים לסוף קובץ הכרטיס.

127
00:07:40,910 --> 00:07:43,950
אבל אנחנו לא רוצים לכתוב
שום דבר עד אז.

128
00:07:43,950 --> 00:07:48,710
אז זה לא חשוב, לא רק שאנחנו ב
תחילת JPG חדש, אבל אם

129
00:07:48,710 --> 00:07:50,655
אנחנו כבר מצאנו JPG או לא.

130
00:07:50,655 --> 00:07:55,390
>> אם זה ההתחלה של JPG חדש, יצטרכו
רוצה לסגור את קובץ JPG הנוכחי שלנו, אם

131
00:07:55,390 --> 00:07:59,110
יש לנו אחד פתוחה, ופתוח
אחד חדש לכתוב ל.

132
00:07:59,110 --> 00:08:03,340
אם זה לא ההתחלה של JPG החדש,
אם כי, אנחנו נשמור את אותו קובץ JPG

133
00:08:03,340 --> 00:08:05,910
לפתוח ולכתוב לזה.

134
00:08:05,910 --> 00:08:10,100
אנחנו נכתוב החיץ שלנו לתוך לפי
קובץ JPG יש לנו פתוח, ובלבד ש

135
00:08:10,100 --> 00:08:12,120
יש לנו אחד פתוח, כמובן.

136
00:08:12,120 --> 00:08:16,190
אם לא מצאנו JPG הראשון שלנו
עדיין, אנחנו לא כותבים כלום.

137
00:08:16,190 --> 00:08:20,290
והתהליך הזה ממשיך עד שאתה
להגיע לסוף של קובץ הכרטיס.

138
00:08:20,290 --> 00:08:23,410
>> ולבסוף, אתה רוצה לעשות
בטוח שאתה fclose כל

139
00:08:23,410 --> 00:08:25,800
קבצים שיש לך fopened.

140
00:08:25,800 --> 00:08:28,360
ברגע שאתה מרגיש בנוח עם
מושגים, להעיף מבט על כמה

141
00:08:28,360 --> 00:08:30,840
pseudocode, שצרפתי כאן.

142
00:08:30,840 --> 00:08:34,830
ראשית, אתה רוצה לפתוח את קובץ הכרטיס,
ולאחר מכן לחזור על התהליך הבא

143
00:08:34,830 --> 00:08:37,144
עד שהגעת
הסוף של הכרטיס.

144
00:08:37,144 --> 00:08:40,880
אתה רוצה לקרוא 512 בתים
לחיץ.

145
00:08:40,880 --> 00:08:43,934
באמצעות מאגר זה, אתה רוצה לבדוק
בין אם אתה בתחילת

146
00:08:43,934 --> 00:08:45,300
JPG או לא חדשים.

147
00:08:45,300 --> 00:08:48,400
והתשובה לשאלה זו תהיה
משפיע על ניהול הקבצים שלך -

148
00:08:48,400 --> 00:08:51,940
אילו קבצים אתה פותח, אשר
אלה שאתה סוגר.

149
00:08:51,940 --> 00:08:55,220
>> ואז, יש לך כבר מצא JPG?

150
00:08:55,220 --> 00:08:57,740
איך יש לך כבר שמירה
אחר ש?

151
00:08:57,740 --> 00:09:01,735
לאחר מכן, בהתאם לכך, אתה גם יהיה
לכתוב לתוך JPG הנוכחי שאתה

152
00:09:01,735 --> 00:09:07,090
יש לי פתוח, או לא לכתוב את זה בכלל,
בגלל שאתה לא מצאת JPG עדיין.

153
00:09:07,090 --> 00:09:10,870
לבסוף, לאחר שהגעת לסוף
את הקובץ, תרצה כדי לסגור את כל

154
00:09:10,870 --> 00:09:12,590
נותר קבצים שיש לך פתוח.

155
00:09:12,590 --> 00:09:14,590
אנחנו רוצים להיות מסודרים כאן.

156
00:09:14,590 --> 00:09:18,790
>> ועם זה, יש לך התאושש כל
קבצים החסרים מזיכרון כי

157
00:09:18,790 --> 00:09:21,620
כרטיס, שהוא הישג די מדהים.

158
00:09:21,620 --> 00:09:23,430
אז לטפוח לעצמך על שכם.

159
00:09:23,430 --> 00:09:27,560
אבל, יש אלמנט אחד ל
PSET, המהווה את התחרות.

160
00:09:27,560 --> 00:09:30,920
אתה תמצא שכל התמונות
כי אתה כבר התאושש למעשה

161
00:09:30,920 --> 00:09:32,820
תמונות של צוות של CS50.

162
00:09:32,820 --> 00:09:38,500
אז אם אתה בקמפוס או במקום
קרוב, אז אתה יכול לצלם תמונות עם

163
00:09:38,500 --> 00:09:42,600
צוות, והחלק שיש לו את
רוב התמונות עם חברי צוות

164
00:09:42,600 --> 00:09:46,940
מהקבצים שנמצאו יהיה
תקבל הפרס מדהים.

165
00:09:46,940 --> 00:09:50,650
עם זה, אז אתה כבר סיימת
לשחזר PSET.

166
00:09:50,650 --> 00:09:53,600
השם שלי הוא Zamyla, וזה CS50.

167
00:09:53,600 --> 00:10:01,835