1
00:00:00,000 --> 00:00:00,494

2
00:00:00,494 --> 00:00:13,350
>> [השמעת מוסיקה]

3
00:00:13,350 --> 00:00:14,080
>> ROB אודן: היי.

4
00:00:14,080 --> 00:00:17,550
אני רוב, ואקווה ש
פתרון זה מסייע לשים אותך

5
00:00:17,550 --> 00:00:19,600
בדרך אל החלמה.

6
00:00:19,600 --> 00:00:22,700
אז בואו נתחיל.

7
00:00:22,700 --> 00:00:25,660
>> אנו רואים כי מייד שאנחנו
רק כדי לוודא שאנחנו

8
00:00:25,660 --> 00:00:27,170
באמצעות לשחזר בצורה נכונה.

9
00:00:27,170 --> 00:00:31,490
אז השימוש פשוט צריך להיות משהו
כמו לוכסן נקודה להתאושש.

10
00:00:31,490 --> 00:00:35,500
>> עכשיו אנחנו הולכים לפתוח צפויים
כרטיס מנקדים קובץ גלם.

11
00:00:35,500 --> 00:00:39,740
אנו רואים כאן שאנו משתמשים
שם קובץ תחתון גלם קבוע,

12
00:00:39,740 --> 00:00:44,200
שעד כאן יש לנו חשיש
מוגדר ככרטיס מנקדים גלם.

13
00:00:44,200 --> 00:00:45,030
על אישור.

14
00:00:45,030 --> 00:00:48,210
>> אז אנחנו צריכים לוודא שזה
נפתח בהצלחה, כי אם זה

15
00:00:48,210 --> 00:00:51,150
לא, אז אנחנו צריכים להזהיר את המשתמש.

16
00:00:51,150 --> 00:00:56,770
אבל בהנחה שזה לא, אנחנו עכשיו
הולך להכריז על מאגר בגודל JPEG

17
00:00:56,770 --> 00:00:58,170
שם קובץ אורך.

18
00:00:58,170 --> 00:01:02,060
אז זה הולך להיות החיץ ש
אנחנו הולכים sprintf ל.

19
00:01:02,060 --> 00:01:04,360
>> אז מה הוא JPEG שם קובץ אורך?

20
00:01:04,360 --> 00:01:08,490
עד כאן, אנחנו רואים שזה
חשיש מוגדר כשמונה.

21
00:01:08,490 --> 00:01:10,670
אז למה שמונה?

22
00:01:10,670 --> 00:01:15,150
גם קובץ נתון יהיה שם
משהו כמו אפס אפס אפס.

23
00:01:15,150 --> 00:01:19,460
JPG ואז אנחנו צריכים קו נטוי אפס.

24
00:01:19,460 --> 00:01:22,720
אז אנחנו צריכים חיץ שיכול
לאחסן שמונה תווים.

25
00:01:22,720 --> 00:01:25,190
עכשיו אנחנו הולכים להיות נגד זה
הולך לעקוב אחר

26
00:01:25,190 --> 00:01:27,780
תמונות JPEG מספר שמצאנו.

27
00:01:27,780 --> 00:01:31,590
>> ולבסוף, אנחנו הולכים יש לי
קובץ JPEG שהוא בתחילה null

28
00:01:31,590 --> 00:01:35,920
שהולך להיות כרגע
קובץ פתוח שאנחנו כותבים.

29
00:01:35,920 --> 00:01:37,540
עכשיו אנחנו הולכים ליש לי
חיץ נוסף.

30
00:01:37,540 --> 00:01:41,350
זה לא אותו הדבר כמו sprintf
חיץ שבו החיץ הזה הוא אחד

31
00:01:41,350 --> 00:01:45,020
שאנחנו קוראים בנתונים
מהכרטיס מנקדים גלם.

32
00:01:45,020 --> 00:01:48,900
>> אז החיץ הולך להיות של
תווים שאינם חתומים, שבו אתה יכול

33
00:01:48,900 --> 00:01:53,560
בעצם רק מתייחס אלינו בתים, וזה
הולך להיות של גודל בלוק בגודל

34
00:01:53,560 --> 00:01:57,950
שבו, כפי שאנו אומרים לכם,
גודל בלוק הוא 512.

35
00:01:57,950 --> 00:02:03,070
אז תמונות JPEG שאתה יכול לטפל בכל דבר
כמו בלוקים של 512 בתים.

36
00:02:03,070 --> 00:02:05,890
>> עכשיו אנחנו הולכים ללולאה
על הקובץ כולו.

37
00:02:05,890 --> 00:02:12,980
אנחנו הולכים f לקרוא למאגר שלנו
פעמים גודל בלוק בית אחד מ

38
00:02:12,980 --> 00:02:14,710
הכרטיס מנקדים קובץ גלם.

39
00:02:14,710 --> 00:02:16,630
עכשיו מה f לקרוא לחזור?

40
00:02:16,630 --> 00:02:20,050
זה מחזיר את מספר הפריטים
כי היא קראה בהצלחה.

41
00:02:20,050 --> 00:02:27,310
אז אם זה הצליח לקרוא 512 בתים, ולאחר מכן
אנחנו רוצים לראות אם זה היה

42
00:02:27,310 --> 00:02:29,700
JPEG או לכתוב אותו לקובץ JPEG.

43
00:02:29,700 --> 00:02:34,450
ואם זה לא חזר 512 בתים,
אז גם את הקובץ הסתיים ב

44
00:02:34,450 --> 00:02:37,870
אשר למקרה שנצטרך לפרוץ את y
לולאה, או שיש איזו שגיאה

45
00:02:37,870 --> 00:02:40,300
ומקרה שביהיו גם לפרוץ את
y הלולאה, אבל אנחנו רוצים לדווח

46
00:02:40,300 --> 00:02:41,990
משהו שהשתבש.

47
00:02:41,990 --> 00:02:42,290
>> על אישור.

48
00:02:42,290 --> 00:02:47,630
אז בהנחה שאנו קוראים בהצלחה
ב512 בתים, אנחנו רוצים לבדוק ראשון

49
00:02:47,630 --> 00:02:53,070
כדי להפוך את שהבתים האלה שאנחנו
פשוט לקרוא במתחיל JPEG.

50
00:02:53,070 --> 00:02:56,430
אז אם היא כותרת JPEG של החיץ שלנו.

51
00:02:56,430 --> 00:02:58,460
עכשיו מה הוא עושה כותרת JPEG?

52
00:02:58,460 --> 00:03:00,120
בואו נסתכל.

53
00:03:00,120 --> 00:03:05,270
>> עד כאן, אנו רואים כי פונקציה זו היא
חוזר שור, ושור ש--

54
00:03:05,270 --> 00:03:08,820
גם כאן, אנחנו בודקים כדי לראות אם
כותרת אפס שווה מתמדת ו

55
00:03:08,820 --> 00:03:11,880
כותרת אחד שווה מתמדת ו
כותרת שתיים שווה מתמדת,

56
00:03:11,880 --> 00:03:15,640
כותרת שלוש שווה את זה או את זה
קבוע שבו כולם קבועים אלה הם

57
00:03:15,640 --> 00:03:20,340
רק חשיש שהוגדר כאן והם
בדיוק מה שאמרנו לכם במפרט

58
00:03:20,340 --> 00:03:22,700
שJPEG מתחיל עם.

59
00:03:22,700 --> 00:03:27,300
ולכן פונקציה זו היא רק הולכת
החזר אמיתי אם חיץ זה מייצג

60
00:03:27,300 --> 00:03:31,750
תחילת JPEG חדש
ושקר אחר.

61
00:03:31,750 --> 00:03:32,520
>> על אישור.

62
00:03:32,520 --> 00:03:38,490
אז אם זה עושה מייצג JPEG חדש,
אז אנחנו קודם כל רוצים לבדוק אם

63
00:03:38,490 --> 00:03:42,030
קובץ JPEG הוא לא שווה ל null,
ובמקרה כזה אנחנו סוגרים אותו.

64
00:03:42,030 --> 00:03:44,940
וכל כך למה אנחנו צריכים לבדוק
כדי לראות אם זה לא null?

65
00:03:44,940 --> 00:03:48,980
ובכן JPEG הראשון שאנחנו
למצוא לא כבר יש לנו

66
00:03:48,980 --> 00:03:50,440
קובץ JPEG פתוח.

67
00:03:50,440 --> 00:03:55,580
וכך, אם אנחנו מנסים לסגור את זה, אז
אנחנו לא עושים משהו ממש נכון.

68
00:03:55,580 --> 00:03:59,090
>> אבל בכל JPEG שלאחר מכן כי
אנחנו פותחים, אנחנו רוצים לסגור

69
00:03:59,090 --> 00:04:00,710
הקובץ הקודם.

70
00:04:00,710 --> 00:04:04,630
אז עכשיו אנחנו הולכים להשתמש sprintf כפי שאנו
אמר בעבר שבו אנו משתמשים

71
00:04:04,630 --> 00:04:06,280
שם קובץ החיץ JPEG.

72
00:04:06,280 --> 00:04:09,870
ואנחנו הולכים להשתמש בקובץ JPEG
תבנית שם כתבנית שלנו.

73
00:04:09,870 --> 00:04:12,030
ומה זה?

74
00:04:12,030 --> 00:04:18,450
עד כאן, אנחנו רואים שזה אחוז אפס
3D.JPEG בי אפס שלושה רק

75
00:04:18,450 --> 00:04:22,089
אומר שאנחנו משתמשים בשלושה מספרים שלמים
לכך מרופד באפסים.

76
00:04:22,089 --> 00:04:27,470
אז ככה נקבל אפס אפס
one.JPEG ואפס 10.JPEG וכן הלאה.

77
00:04:27,470 --> 00:04:29,060
>> אנחנו הולכים להשתמש sprintf.

78
00:04:29,060 --> 00:04:33,760
והמספר השלם שאנחנו מכניסים
לתוך המחרוזת היא בפורמט JPEG הקהה

79
00:04:33,760 --> 00:04:36,380
התאושש, שהוא במקור אפס.

80
00:04:36,380 --> 00:04:39,950
אז את הקובץ הראשון נפתח הולך
להיות אפס אפס אפס הנקודה JPEG.

81
00:04:39,950 --> 00:04:43,330
ואז אנחנו להגדיל כל זה כל כך
הקובץ הבא אנו פותחים יהיה אפס אפס

82
00:04:43,330 --> 00:04:46,830
נקודת JPEG אחת ואנו להגדיל אותו
שוב כך זה יהיה אפס אפס שתי נקודות

83
00:04:46,830 --> 00:04:49,100
JPEG וכן הלאה.

84
00:04:49,100 --> 00:04:49,850
>> בסדר.

85
00:04:49,850 --> 00:04:53,210
אז עכשיו את החלק הפנימי של קובץ JPEG
שם, יש לנו את שמו של

86
00:04:53,210 --> 00:04:54,990
קובץ שאנחנו רוצים.

87
00:04:54,990 --> 00:04:58,640
אנו f יכולים לפתוח את הקובץ לכתיבה.

88
00:04:58,640 --> 00:04:59,170
על אישור.

89
00:04:59,170 --> 00:05:02,820
ושוב, אנחנו צריכים לבדוק לעשות
בטוח שהקובץ בהצלחה

90
00:05:02,820 --> 00:05:08,460
פתח שכן אם זה לא, אז
הייתה איזו שגיאה.

91
00:05:08,460 --> 00:05:13,100
>> אז עכשיו אנחנו כבר קיבלנו בעבר
זה חלק JPEG.

92
00:05:13,100 --> 00:05:16,390
והנה, אנחנו רואים שאנחנו הולכים
לכתוב לJPEG.

93
00:05:16,390 --> 00:05:20,980
אבל יש לנו ראשון סימון זו שאומר
אם קובץ JPEG לא null שווה.

94
00:05:20,980 --> 00:05:22,490
למה אנחנו צריכים את זה?

95
00:05:22,490 --> 00:05:28,020
גם קובץ JPEG שווה null כאשר אנו
כרגע יש JPEG פתוח.

96
00:05:28,020 --> 00:05:31,870
>> מה אם מתחיל גלם נקודת כרטיס
בחבורה של בתים ש

97
00:05:31,870 --> 00:05:33,510
אינו מייצג את JPEG?

98
00:05:33,510 --> 00:05:36,240
ואז אנחנו הולכים לרוצים
לדלג מעל בתים אלו.

99
00:05:36,240 --> 00:05:39,600
כאילו אין לנו לבדוק את זה, אז אנחנו
הולך לכתוב שללא נפתח

100
00:05:39,600 --> 00:05:45,540
להגיש 512 הבתים הראשונים של
כרטיס וזה לא טוב.

101
00:05:45,540 --> 00:05:46,030
על אישור.

102
00:05:46,030 --> 00:05:51,330
>> אז בהנחה שיש לנו קובץ פתוח, ולאחר מכן
אנחנו הולכים לכתוב לקובץ זה

103
00:05:51,330 --> 00:05:53,290
512 בתים שיש לנו במאגר שלנו.

104
00:05:53,290 --> 00:05:57,390
ואנחנו בודקים שוב לעשות
בטוח ש512 הבתים בהצלחה

105
00:05:57,390 --> 00:06:01,140
נכתב, כי אם הם לא היו
נכתב בהצלחה, אז משהו

106
00:06:01,140 --> 00:06:02,080
השתבש.

107
00:06:02,080 --> 00:06:06,540
אנחנו נסגור את הקבצים שלנו, להדפיס כי
משהו השתבש, ולחזור.

108
00:06:06,540 --> 00:06:10,940
הכל בהנחה שהולך בצורה נכונה, ולאחר מכן
אנחנו נשמור לולאת סגירה

109
00:06:10,940 --> 00:06:15,060
קובץ ישן, פתיחת הקובץ החדש, כתיבה
הנתונים לקובץ החדש, וכך

110
00:06:15,060 --> 00:06:20,990
על עד שלבסוף, f זה לקרוא
מחזיר אפס שפירושו

111
00:06:20,990 --> 00:06:23,280
שהקובץ נעשה.

112
00:06:23,280 --> 00:06:28,490
>> אז עכשיו שקריאת הכרטיס נגמרה, אנחנו
רואה שאנחנו הולכים לסגור את f

113
00:06:28,490 --> 00:06:33,250
הקובץ האחרון שהיינו לנו פתוח, אבל
אנחנו בודקים אם קובץ JPEG

114
00:06:33,250 --> 00:06:34,900
עושה null לא שווה.

115
00:06:34,900 --> 00:06:39,520
ובכן קרוב ו הגיוני כי כמו
אנחנו פותחים קבצים, אנחנו סוגרים

116
00:06:39,520 --> 00:06:43,870
הקובץ הקודם, אבל האחרון
קובץ שפתחנו לא מקבל סגור.

117
00:06:43,870 --> 00:06:45,580
אז זה מה שזה עושה.

118
00:06:45,580 --> 00:06:47,720
>> אבל למה אנחנו צריכים לבדוק null?

119
00:06:47,720 --> 00:06:53,130
אז מה אם גלם נקודת כרטיס לא
יש לי JPEG בודד בתוכו?

120
00:06:53,130 --> 00:06:56,640
במקרה זה, היינו צריך
מעולם לא פתח את קובץ.

121
00:06:56,640 --> 00:07:00,230
ואם אנחנו אף פעם לא לפתוח קובץ, אנחנו צריכים
לא אנסה לסגור את הקובץ.

122
00:07:00,230 --> 00:07:03,000
אז זה מה שסימון זו עושה.

123
00:07:03,000 --> 00:07:07,880
>> עכשיו הוא כאן, כמו שאמרתי קודם, שאנחנו יכולים
פרץ כי y לולאה גם אם

124
00:07:07,880 --> 00:07:13,520
הכרטיס הסתיים או אם יש
איזו שגיאה בקריאה מהכרטיס.

125
00:07:13,520 --> 00:07:16,680
אז זו בדיקה כדי לראות אם יש
שגיאה בקריאה מהכרטיס, ב

126
00:07:16,680 --> 00:07:19,400
ומקרה זה, אנו אומרים שיש
היה שגיאה בקריאה.

127
00:07:19,400 --> 00:07:22,130
אנחנו לא רוצים שהמשתמש חושב
הכל הלך בהצלחה.

128
00:07:22,130 --> 00:07:24,750
ונחזור אחד לטעויות.

129
00:07:24,750 --> 00:07:29,580
>> לבסוף, אנחנו f סוגרים את קובץ הגלם שלנו,
הכרטיס שלנו מנקדים גלם, כדי לציין כי

130
00:07:29,580 --> 00:07:34,070
הכל הלך טוב ותמורה
אפס וזהו זה.

131
00:07:34,070 --> 00:07:36,130
>> השם שלי הוא רוב וזה היה לשחזר.

132
00:07:36,130 --> 00:07:42,102
>> [השמעת מוסיקה]