1
00:00:00,000 --> 00:00:05,330

2
00:00:05,330 --> 00:00:07,870
>> הדובר: עד כה, סביר להניח
כי רוב התוכניות שלך

3
00:00:07,870 --> 00:00:10,170
היה קצת קיקיוני.

4
00:00:10,170 --> 00:00:13,310
אתה מפעיל תכנית כמו מריו או חמדן.

5
00:00:13,310 --> 00:00:17,350
זה עושה משהו, זה אולי יבקש
המשתמש למידע,

6
00:00:17,350 --> 00:00:20,400
להדפיס כמה פלט המסך,
אבל אז, כאשר התכנית שלך נגמר,

7
00:00:20,400 --> 00:00:23,252
באמת אין ראיות שיש
אי פעם זה היה לרוץ במקום הראשון.

8
00:00:23,252 --> 00:00:25,960
אני מתכוון, בטוח, ייתכן שהשארת
זה ייפתח בחלון המסוף,

9
00:00:25,960 --> 00:00:29,770
אבל אם אתה לנקות את המסך שלך, יש
באמת אין ראיות לכך שהיה קיימים.

10
00:00:29,770 --> 00:00:33,720
אין לנו אמצעי אחסון
מידע מתמשך, מידע

11
00:00:33,720 --> 00:00:36,890
שקיים לאחר
תכנית הפסיקה לרוץ,

12
00:00:36,890 --> 00:00:39,241
או שיש לנו לא עד לנקודה זו.

13
00:00:39,241 --> 00:00:41,490
למרבה המזל אף, ג עושה
לספק לנו את היכולת

14
00:00:41,490 --> 00:00:44,220
כדי לעשות זאת על ידי יישום
משהו שנקרא

15
00:00:44,220 --> 00:00:48,330
קובץ, מבנה שבעצם
מייצג קובץ שבו היית להכפיל

16
00:00:48,330 --> 00:00:53,826
לחץ על המחשב שלך, אם אתה
משמש לסביבת משתמש גרפית.

17
00:00:53,826 --> 00:00:55,700
בדרך כלל כאשר עובדים
עם ג, אנחנו בעצם

18
00:00:55,700 --> 00:00:59,965
הולך לעבוד עם
מצביעים לfiles-- קובץ stars--

19
00:00:59,965 --> 00:01:02,090
פרט לקצת
כאשר אנו מדברים על בני זוג

20
00:01:02,090 --> 00:01:04,560
של הפונקציות ש
עובד עם מצביעי קובץ.

21
00:01:04,560 --> 00:01:08,990
אתה לא צריך להיות ממש חפר
עמוק מדי לתוך מצביעי הבנה

22
00:01:08,990 --> 00:01:09,730
את עצמם.

23
00:01:09,730 --> 00:01:12,870
יש קצת קטנטן קטן
שבו אנחנו מדברים עליהם,

24
00:01:12,870 --> 00:01:18,090
אבל בדרך כלל להגיש מצביעים ו
מצביעים, ואילו קשורים,

25
00:01:18,090 --> 00:01:20,290
הם לא בדיוק אותו דבר.

26
00:01:20,290 --> 00:01:22,440
>> עכשיו מה אני מתכוון כש
אני אומר נתונים מתמשכים?

27
00:01:22,440 --> 00:01:23,650
מה הוא הנתונים מתמשכים?

28
00:01:23,650 --> 00:01:25,232
למה אכפת לנו את זה?

29
00:01:25,232 --> 00:01:27,190
אומר, למשל, ש
אתה מפעיל תכנית

30
00:01:27,190 --> 00:01:29,850
או ששוכתבת
תכנית שמשחק,

31
00:01:29,850 --> 00:01:32,960
ואתה רוצה לשמור על מסלול
כל המהלכים של המשתמש

32
00:01:32,960 --> 00:01:36,620
כך שאולי אם משהו משתבש,
אתה יכול לבדוק את הקובץ בסיום המשחק.

33
00:01:36,620 --> 00:01:39,970
זה מה שאנחנו מתכוונים כשאנחנו
מדבר על נתונים מתמשכים.

34
00:01:39,970 --> 00:01:43,930
>> במהלך הריצה שלך
תכנית, קובץ נוצר.

35
00:01:43,930 --> 00:01:45,680
וכאשר התכנית שלך
הפסיק לרוץ,

36
00:01:45,680 --> 00:01:48,689
קובץ שעדיין קיים במערכת שלך.

37
00:01:48,689 --> 00:01:50,230
ואנחנו יכולים להסתכל על זה ולבחון אותה.

38
00:01:50,230 --> 00:01:53,670
וכך התכנית שהייתה נקבעה ל
יצר כמה נתונים מתמשכים,

39
00:01:53,670 --> 00:01:57,390
הנתונים קיימים לאחר התכנית
סיים ריצה.

40
00:01:57,390 --> 00:02:02,320
>> עכשיו כל פונקציות אלה שעובדים
עם יצירת קבצים ומניפולציה

41
00:02:02,320 --> 00:02:04,940
שלהם בדרכים שונות
לחיות בio.h הסטנדרטי,

42
00:02:04,940 --> 00:02:08,210
שהוא קובץ כותרת ש
סביר להניח שאתה כבר ליש"ט

43
00:02:08,210 --> 00:02:10,910
כולל בחלק העליון של די
הרבה כל התוכניות שלך

44
00:02:10,910 --> 00:02:14,130
מכיוון שהוא מכיל אחד
רוב הפונקציות שימושיות עבורנו,

45
00:02:14,130 --> 00:02:16,130
printf, שגם מאפשר לי
גר בio.h. הסטנדרטי

46
00:02:16,130 --> 00:02:20,400
אז אתה לא צריך להלום כולל
כל קבצים נוספים כנראה

47
00:02:20,400 --> 00:02:23,540
על מנת לעבוד עם מצביעי קובץ.

48
00:02:23,540 --> 00:02:29,980
>> עכשיו כל פונקצית מצביע קובץ,
או כל אני קובץ יחיד / O, פלט קלט

49
00:02:29,980 --> 00:02:33,310
פונקציה, מקבלת כאחד
הפרמטרים או התשומות שלה

50
00:02:33,310 --> 00:02:35,822
pointer-- קובץ חוץ
לאחד, fopen, ש

51
00:02:35,822 --> 00:02:38,280
זה מה שאתה משתמש כדי לקבל את הקובץ
מצביע במקום הראשון.

52
00:02:38,280 --> 00:02:41,010
אבל אחרי שפתחת
קובץ ואתה מקבל מצביעי קובץ,

53
00:02:41,010 --> 00:02:43,510
אז אתה יכול להעביר אותם כ
טיעונים לפונקציות השונות

54
00:02:43,510 --> 00:02:46,720
אנחנו הולכים לדבר על
היום, כמו גם רבים אחרים

55
00:02:46,720 --> 00:02:48,520
כך שאתה יכול לעבוד עם קבצים.

56
00:02:48,520 --> 00:02:50,980
>> אז יש שש די
אלה בסיסיים משותפים

57
00:02:50,980 --> 00:02:52,870
שאנחנו הולכים לדבר על היום.

58
00:02:52,870 --> 00:02:57,160
fopen והלוויה שלה
fclose פונקציה, fgetc

59
00:02:57,160 --> 00:03:02,670
וfputc פונקצית לוויה שלה,
וfread ותפקוד הלוויה שלה,

60
00:03:02,670 --> 00:03:03,820
fwrite.

61
00:03:03,820 --> 00:03:05,180
אז בואו לקבל זכות לתוך זה.

62
00:03:05,180 --> 00:03:07,050
>> fopen-- מה הוא עושה?

63
00:03:07,050 --> 00:03:10,050
ובכן, זה פותח קובץ וזה
נותן לך מצביע קובץ לזה,

64
00:03:10,050 --> 00:03:14,000
כך שאתה יכול להשתמש ש
להגיש מצביע כטיעון

65
00:03:14,000 --> 00:03:16,730
לכל הקובץ האחר פונקציות קלט / פלט.

66
00:03:16,730 --> 00:03:19,100
הדבר הכי חשוב
לזכור עם fopen

67
00:03:19,100 --> 00:03:24,222
הוא שאחרי שפתחת
קובץ או עשה שיחה כמו אחד כאן,

68
00:03:24,222 --> 00:03:26,930
אתה צריך לבדוק כדי לוודא ש
שהמצביע שקבל אותך בחזרה

69
00:03:26,930 --> 00:03:28,320
אינו שווה ל null.

70
00:03:28,320 --> 00:03:31,320
אם לא צפה בסרטון על
מצביעים, זה אולי לא הגיוני.

71
00:03:31,320 --> 00:03:35,639
אבל אם אתה מנסה וdereference
זוכר מצביע null,

72
00:03:35,639 --> 00:03:38,180
התכנית שלך תהיה כנראה סובלת
פילוח [לא ברור].

73
00:03:38,180 --> 00:03:40,540
אנחנו רוצים לוודא שאנחנו
קיבלתי בחזרה מצביע לגיטימי.

74
00:03:40,540 --> 00:03:43,665
הרוב המכריע של זמננו יהיה
מקבל מצביע לגיטימי בחזרה

75
00:03:43,665 --> 00:03:45,280
וזה לא יהיה בעיה.

76
00:03:45,280 --> 00:03:46,760
>> אז איך אנחנו עושים שיחה לfopen?

77
00:03:46,760 --> 00:03:48,051
זה נראה פחות או יותר כמו זה.

78
00:03:48,051 --> 00:03:52,690
קובץ כוכב ptr-- PTR להיות גנרי
שם לקובץ pointer-- fopen

79
00:03:52,690 --> 00:03:57,300
ואנחנו עוברים בשני דברים, שם קובץ
ופעולה שאנו רוצים לבצע.

80
00:03:57,300 --> 00:04:01,690
אז אולי יש לנו שיחה שנראית כמו
זה-- PTR כוכב קובץ 1 שווה fopen

81
00:04:01,690 --> 00:04:04,040
file1.txt.

82
00:04:04,040 --> 00:04:07,020
והפעולה שבחרתי הוא r.

83
00:04:07,020 --> 00:04:08,639
>> אז מה אתה חושב r הוא כאן?

84
00:04:08,639 --> 00:04:11,180
מה הם הסוגים של דברים שאנחנו
ייתכן שתוכל לעשות לקבצים?

85
00:04:11,180 --> 00:04:13,760

86
00:04:13,760 --> 00:04:17,500
אז R היא הפעולה ש
לבחור מתי שאנחנו רוצים לקרוא קובץ.

87
00:04:17,500 --> 00:04:20,260
אז הייתי בעצם כש
אנחנו עושים שיחה כזאת

88
00:04:20,260 --> 00:04:25,440
מקבל את עצמנו מצביע קובץ
כזה שאנחנו יכולים ואז לקרוא מידע

89
00:04:25,440 --> 00:04:27,770
מfile1.txt.

90
00:04:27,770 --> 00:04:34,190
>> כמו כן, אנו יכולים לפתוח 2.txt קובץ
לכתיבה ולכן אנחנו יכולים לעבור ptr2,

91
00:04:34,190 --> 00:04:38,210
מצביע הקובץ שנוצרתי כאן,
כטיעון לכל פונקציה ש

92
00:04:38,210 --> 00:04:40,080
כותב מידע לקובץ.

93
00:04:40,080 --> 00:04:43,767
ודומה לכתיבה, יש
גם את האפשרות לצרף,.

94
00:04:43,767 --> 00:04:45,600
ההבדל בין
כתיבה וצירוף

95
00:04:45,600 --> 00:04:50,920
להיות שכשאתה כותב לקובץ,
אם אתה מבצע שיחה לfopen לכתיבה

96
00:04:50,920 --> 00:04:54,761
וקובץ שכבר קיים, זה
הולך לדרוס את הקובץ כולו.

97
00:04:54,761 --> 00:04:56,510
זה הולך להתחיל
בהתחלה,

98
00:04:56,510 --> 00:04:58,820
מחיקת כל המידע
זה כבר שם.

99
00:04:58,820 --> 00:05:02,210
>> לעומת זאת, אם אתה פותח אותו לשרשור,
זה ילך לסוף הקובץ

100
00:05:02,210 --> 00:05:04,340
אם יש כבר טקסט ב
זה או מידע בו,

101
00:05:04,340 --> 00:05:06,040
ואז זה יתחיל
כתיבה משם.

102
00:05:06,040 --> 00:05:08,570
אז אתה לא תאבד את כל
מידע שעשית לפני.

103
00:05:08,570 --> 00:05:12,110
אם ברצונך לכתוב או לצרף
סוג של תלוי במצב.

104
00:05:12,110 --> 00:05:16,840
אבל אתה בטח יודע מה
פעולה נכונה היא כאשר מגיע הזמן.

105
00:05:16,840 --> 00:05:18,020
אז זה fopen.

106
00:05:18,020 --> 00:05:18,930
>> מה לגבי fclose?

107
00:05:18,930 --> 00:05:21,600
ובכן, די פשוט, fclose
רק מקבל את מצביע הקובץ.

108
00:05:21,600 --> 00:05:24,000
וכפי שאפשר לצפות,
זה סוגר את התיק ש.

109
00:05:24,000 --> 00:05:29,270
וברגע שאנחנו כבר סגרנו קובץ, אנחנו לא יכולים
לבצע כל עוד קובץ פונקציות קלט / פלט,

110
00:05:29,270 --> 00:05:31,420
קריאה או כתיבה, בקובץ זה.

111
00:05:31,420 --> 00:05:36,444
אנחנו צריכים לפתוח מחדש
להגיש בפעם אחרת על מנת

112
00:05:36,444 --> 00:05:38,610
להמשיך לעבוד עם
שלו באמצעות פונקציות קלט / פלט.

113
00:05:38,610 --> 00:05:41,520
אמצעי אז fclose שנסיים
עבודה עם קובץ זה.

114
00:05:41,520 --> 00:05:44,690
וכל מה שאנחנו צריכים לעבור בהם
שמו של מצביע קובץ.

115
00:05:44,690 --> 00:05:50,010
אז בכמה שקופיות לפני, אנחנו
על מודעה נקודה 1 קובץ fopened לקריאה

116
00:05:50,010 --> 00:05:52,854
ואנחנו שהוקצו ש
להגיש מצביע לptr1.

117
00:05:52,854 --> 00:05:55,020
עכשיו החלטנו שאנחנו
סיימתי לקרוא מקובץ ש.

118
00:05:55,020 --> 00:05:56,561
אנחנו לא צריכים לעשות יותר עם זה.

119
00:05:56,561 --> 00:05:58,890
אנחנו יכולים רק ptr1 fclose.

120
00:05:58,890 --> 00:06:01,950
ובאופן דומה, יכולים אנו
fclose האחרות אלה.

121
00:06:01,950 --> 00:06:02,450
בסדר.

122
00:06:02,450 --> 00:06:03,700
אז זה פתיחה וסגירה.

123
00:06:03,700 --> 00:06:05,780
אלה הם שני בסיסיים
מתחיל את פעילות.

124
00:06:05,780 --> 00:06:08,050
>> עכשיו אנחנו רוצים בעצם
לעשות כמה דברים מעניינים,

125
00:06:08,050 --> 00:06:11,940
והפונקציה הראשונה שנוסיף ל
רואה שיעשה את זה הוא fgetc--

126
00:06:11,940 --> 00:06:14,110
להגיש את אופי.

127
00:06:14,110 --> 00:06:17,350
זה מה שבדרך כלל fgetc
היה לתרגם.

128
00:06:17,350 --> 00:06:20,190
שלה מטרה בחיים היא
לקרוא את התו הבא,

129
00:06:20,190 --> 00:06:22,079
או אם זה מאוד
שיחה ראשונה לfgetc

130
00:06:22,079 --> 00:06:23,870
לקובץ מסוים,
התו הראשון.

131
00:06:23,870 --> 00:06:26,210
אבל אז אחרי ש,
אתה מקבל ליד אחד,

132
00:06:26,210 --> 00:06:31,500
האופי מאוד הבא של קובץ ש,
ומאחסן אותו במשתנה אופי.

133
00:06:31,500 --> 00:06:34,490
כפי שעשינו כאן,
פרק char שווה fgetc,

134
00:06:34,490 --> 00:06:36,389
לעבור בשם מצביע קובץ.

135
00:06:36,389 --> 00:06:38,180
שוב, זה מאוד
חשוב לזכור כאן

136
00:06:38,180 --> 00:06:41,430
כי כדי שיהיה לי
פעולה זו תצליח,

137
00:06:41,430 --> 00:06:45,690
המצביע עצמו הקובץ בטוח
נפתח לקריאה.

138
00:06:45,690 --> 00:06:50,589
אנחנו לא יכולים לקרוא אופי מקובץ
מצביע שפתחנו לכתיבה.

139
00:06:50,589 --> 00:06:52,630
אז זה אחד מ
מגבלות של fopen, נכון?

140
00:06:52,630 --> 00:06:55,470
אנחנו צריכים להגביל
את עצמנו לביצוע רק

141
00:06:55,470 --> 00:06:57,710
פעולה אחת עם מצביע קובץ אחד.

142
00:06:57,710 --> 00:07:00,220
אם אנחנו רוצים לקרוא ו
לכתוב מאותו הקובץ,

143
00:07:00,220 --> 00:07:03,840
היינו צריך לפתוח שתי נפרד
מצביעי קובץ באותו file--

144
00:07:03,840 --> 00:07:05,670
אחד לקריאה, אחד לכתיבה.

145
00:07:05,670 --> 00:07:08,400
>> אז שוב, הסיבה היחידה
אני מביא את זה עכשיו הוא

146
00:07:08,400 --> 00:07:11,920
כי אם אנחנו הולכים לבצע שיחה
לfgetc, שזה בטח מצביע קובץ

147
00:07:11,920 --> 00:07:14,172
נפתח לקריאה.

148
00:07:14,172 --> 00:07:15,880
ואז די פשוט,
כל מה שאנחנו צריכים לעשות

149
00:07:15,880 --> 00:07:17,546
הוא להעביר בשמו של מצביע הקובץ.

150
00:07:17,546 --> 00:07:21,060
אז פרק char שווה ptr1 fgetc.

151
00:07:21,060 --> 00:07:23,200
>> זה הולך לגרום לנו
character-- הבא

152
00:07:23,200 --> 00:07:25,575
או שוב, אם זה ראשון
זמן שעשינו את השיחה הזאת,

153
00:07:25,575 --> 00:07:29,750
character-- הראשון של מה ש
הקובץ הצביע על ידי ptr1.

154
00:07:29,750 --> 00:07:32,210
נזכיר כי זה היה טקסט נקודת קובץ 1.

155
00:07:32,210 --> 00:07:36,490
זה יהיה לקבל את התו הראשון של ש
ואנחנו לאחסן אותו בפרק משתנה.

156
00:07:36,490 --> 00:07:37,941
די פשוט.

157
00:07:37,941 --> 00:07:40,190
אז בדקנו רק בשלוש
פונקציות וכבר אנחנו

158
00:07:40,190 --> 00:07:43,070
יכול לעשות משהו די מסודר.

159
00:07:43,070 --> 00:07:46,320
>> אז אם אנחנו לוקחים את היכולת הזו
מקבל אופי

160
00:07:46,320 --> 00:07:48,943
ואנחנו לולאה it-- כדי ש
תמשיך לקבל תווים

161
00:07:48,943 --> 00:07:51,390
מקובץ שוב ו
שוב ועכשיו אנחנו over--

162
00:07:51,390 --> 00:07:54,500
יכול לקרוא כל אחד
דמותו של קובץ.

163
00:07:54,500 --> 00:07:58,670
ואם אנחנו להדפיס כל דמות
מייד לאחר שקראנו אותו,

164
00:07:58,670 --> 00:08:01,960
כעת אנו קוראים מקובץ ו
מודפס התוכן שלה אל המסך.

165
00:08:01,960 --> 00:08:05,610
אנחנו כבר בשרשור ביעילות
קובץ שעל המסך.

166
00:08:05,610 --> 00:08:09,670
וזה מה ש
פקודת חתול Linux עושה.

167
00:08:09,670 --> 00:08:13,250
>> אם תקליד חתול בשם הקובץ, זה
יהיה להדפיס את כל התוכן

168
00:08:13,250 --> 00:08:15,160
של הקובץ בחלון המסוף שלך.

169
00:08:15,160 --> 00:08:19,010
וכך הלולאה הקטנה הזה כאן,
רק שלוש שורות של קוד,

170
00:08:19,010 --> 00:08:23,270
אבל בו ביעילות כפילויות
פקודת חתול לינוקס.

171
00:08:23,270 --> 00:08:25,210
אז אולי זה תחביר
נראה קצת מוזר,

172
00:08:25,210 --> 00:08:26,670
אבל הנה מה שקורה כאן.

173
00:08:26,670 --> 00:08:31,460
בעוד פרק שווה fgetc, PTR הוא לא
שווה לEOF-- זה כל פה מלא,

174
00:08:31,460 --> 00:08:34,669
אבל בואו לשבור אותו רק
אז זה ברור על התחביר.

175
00:08:34,669 --> 00:08:37,169
אני כבר מאוחד זה
למען החלל,

176
00:08:37,169 --> 00:08:39,049
למרות שזה קצת
מבחינה תחבירית מסובך.

177
00:08:39,049 --> 00:08:41,194
>> אז את החלק הזה בימין ירוק
עכשיו, מה הוא עושה?

178
00:08:41,194 --> 00:08:42,860
ובכן, זה רק שיחת fgetc, נכון?

179
00:08:42,860 --> 00:08:44,530
ראינו את זה לפני.

180
00:08:44,530 --> 00:08:49,500
זה קבלת אחת
דמות מהקובץ.

181
00:08:49,500 --> 00:08:53,220
אז להשוות את זה
אופי נגד EOF.

182
00:08:53,220 --> 00:08:57,470
EOF הוא ערך מיוחד זה
שהוגדר בio.h הסטנדרטי, ש

183
00:08:57,470 --> 00:08:59,390
סופו של דמות קובץ.

184
00:08:59,390 --> 00:09:03,450
אז בעצם מה שהולך לקרות
הוא לולאה זה לקרוא תווים,

185
00:09:03,450 --> 00:09:07,445
להשוות אותו לEOF,
סוף אופי קובץ.

186
00:09:07,445 --> 00:09:10,070
אם הם אינם תואמים, כך שיש לנו לא
הגיע לסוף הקובץ,

187
00:09:10,070 --> 00:09:11,490
אנחנו להדפיס את הדמות ש.

188
00:09:11,490 --> 00:09:13,740
אז נחזור ל
החל מהלולאה שוב.

189
00:09:13,740 --> 00:09:18,310
אנחנו נקבל אופי, לבדוק
נגד EOF, להדפיס אותו, וכן הלאה

190
00:09:18,310 --> 00:09:21,094
וכן הלאה וכן הלאה,
לולאה דרך שבדרך

191
00:09:21,094 --> 00:09:22,760
עד שהגענו לסוף הקובץ.

192
00:09:22,760 --> 00:09:24,593
ולאחר מכן על ידי נקודה ש,
תהיה לנו מודפסים

193
00:09:24,593 --> 00:09:26,210
את כל התוכן של הקובץ.

194
00:09:26,210 --> 00:09:29,450
אז שוב, שראינו רק
fopen, fclose, וfgetc

195
00:09:29,450 --> 00:09:34,950
וכבר אנחנו יכולים לשכפל
פקודת מסוף לינוקס.

196
00:09:34,950 --> 00:09:38,850
>> כפי שאמרתי בהתחלה,
היו לנו fgetc וfputc,

197
00:09:38,850 --> 00:09:41,860
וfputc היה הלוויה
פונקציה של fgetc.

198
00:09:41,860 --> 00:09:44,880
וכך, כפי שאתה יכול לדמיין,
זה שווה ערך הכתיבה.

199
00:09:44,880 --> 00:09:49,440
זה מאפשר לנו לכתוב
תו בודד לקובץ.

200
00:09:49,440 --> 00:09:53,290
>> שוב, האזהרה להיות, רק
כמו שזה היה עם fgetc, הקובץ

201
00:09:53,290 --> 00:09:56,660
שאנחנו כותבים לזה בטח היה
נפתח לכתיבה או לצירוף.

202
00:09:56,660 --> 00:10:00,820
אם תנסו ולהשתמש fputc על קובץ
שאנחנו כבר פתוחים לקריאה,

203
00:10:00,820 --> 00:10:02,760
אנחנו הולכים לסבול
קצת טעות.

204
00:10:02,760 --> 00:10:04,440
אבל השיחה היא די פשוט.

205
00:10:04,440 --> 00:10:08,000
הון fputc ptr2, כל
זה הולך לעשות הוא זה

206
00:10:08,000 --> 00:10:12,040
הולך לכתוב המכתב
ללתוך קובץ 2 נקודה

207
00:10:12,040 --> 00:10:14,760
טקסט, שהיה שמו של
קובץ שפתחנו והוקצינו

208
00:10:14,760 --> 00:10:17,280
המצביע לptr2.

209
00:10:17,280 --> 00:10:20,430
אז אנחנו הולכים לכתוב
הון לקובץ טקסט נקודה 2.

210
00:10:20,430 --> 00:10:24,592
ואנחנו לכתוב קריאה
להצביע להגיש 3 נקודות

211
00:10:24,592 --> 00:10:27,330
טקסט, שהצביע על ידי ptr3.

212
00:10:27,330 --> 00:10:29,730
אז שוב, די פשוט כאן.

213
00:10:29,730 --> 00:10:32,727
>> אבל עכשיו אנחנו יכולים לעשות דבר אחר.

214
00:10:32,727 --> 00:10:34,560
יש לנו דוגמא זו
אנחנו פשוט הולכים על

215
00:10:34,560 --> 00:10:38,950
על היכולת לשכפל את החתול
פקודת לינוקס, אחד שמדפיס

216
00:10:38,950 --> 00:10:40,500
למסך.

217
00:10:40,500 --> 00:10:43,510
ובכן, עכשיו שיש לנו את היכולת
לקרוא תווים מהקבצים

218
00:10:43,510 --> 00:10:46,590
ולכתוב תווים לקבצים,
למה אנחנו לא רק להחליף ש

219
00:10:46,590 --> 00:10:50,720
קורא לprintf בקריאה לfputc.

220
00:10:50,720 --> 00:10:54,090
>> ועכשיו אנחנו כבר משוכפלים cp,
הפקודה לינוקס מאוד בסיסית

221
00:10:54,090 --> 00:10:59,100
שדיברנו על דרך ארוכה
לפני בפקודות לינוקס וידאו.

222
00:10:59,100 --> 00:11:01,070
יש לנו בצורה יעילה
משוכפל שממש כאן.

223
00:11:01,070 --> 00:11:04,790
אנחנו קוראים אופי ולאחר מכן אנחנו
כתיבת דמות שלקובץ אחר.

224
00:11:04,790 --> 00:11:07,660
קריאה מקובץ אחד, כתיבה
למשנהו, שוב ושוב

225
00:11:07,660 --> 00:11:11,350
ושוב, עד שנגיע EOF.

226
00:11:11,350 --> 00:11:14,250
יש לנו בסופו של
קובץ שאנחנו מנסים להעתיק מ.

227
00:11:14,250 --> 00:11:18,500
ועל ידי שאנחנו כתבנו את כל
הדמויות שאנחנו צריכים את הקובץ

228
00:11:18,500 --> 00:11:19,500
שאנחנו כותבים.

229
00:11:19,500 --> 00:11:24,270
אז זה cp, עותק הפקודה לינוקס.

230
00:11:24,270 --> 00:11:26,550
>> בתחילת מאוד
בסרטון זה, היה לי האזהרה

231
00:11:26,550 --> 00:11:29,840
שהיינו מדבר
קצת על מצביעים.

232
00:11:29,840 --> 00:11:32,480
הנה במיוחד שבו אנו נמצאים
הולך לדבר על מצביעים

233
00:11:32,480 --> 00:11:34,800
בנוסף להגיש מצביעים.

234
00:11:34,800 --> 00:11:37,870
אז פונקציה זו נראית די מפחידה.

235
00:11:37,870 --> 00:11:39,120
יש לו כמה פרמטרים.

236
00:11:39,120 --> 00:11:40,430
יש הרבה קורה כאן.

237
00:11:40,430 --> 00:11:42,760
יש הרבה שונה
צבעים וטקסטים.

238
00:11:42,760 --> 00:11:47,100
אבל באמת, זה פשוט
גרסה הגנרית של fgetc

239
00:11:47,100 --> 00:11:50,110
המאפשר לנו לקבל כל
כמות המידע.

240
00:11:50,110 --> 00:11:53,560
זה יכול להיות קצת לא יעיל אם אנחנו
מקבל תו אחד בכל פעם,

241
00:11:53,560 --> 00:11:55,770
iterating דרך הקובץ
תו אחד בכל פעם.

242
00:11:55,770 --> 00:12:00,230
האם לא יהיה זה נחמד לקבל
100 בכל פעם או 500 בכל פעם?

243
00:12:00,230 --> 00:12:03,250
>> ובכן, fread ותפקוד הלוויה שלה
fwrite, שנדברנו על

244
00:12:03,250 --> 00:12:05,490
בשני, תאפשר לנו לעשות בדיוק את זה.

245
00:12:05,490 --> 00:12:08,480
אנו יכולים לקרוא סכום שרירותי
מידע מקובץ

246
00:12:08,480 --> 00:12:10,290
ואנו מאחסנים אותו במקום באופן זמני.

247
00:12:10,290 --> 00:12:12,980
במקום להיות מסוגלים רק
להתאים אותו במשתנה יחידה,

248
00:12:12,980 --> 00:12:15,790
אולי צריך לאחסן אותו במערך.

249
00:12:15,790 --> 00:12:19,980
וכך, אנחנו עוברים בארבעה
טיעונים לfread-- מצביע

250
00:12:19,980 --> 00:12:23,940
למיקום שבו אנחנו
הולך לאחסון מידע,

251
00:12:23,940 --> 00:12:29,180
כמה גדול כל יחידה של מידע
יהיה, כמה יחידות של מידע

252
00:12:29,180 --> 00:12:35,192
אנחנו רוצים לרכוש, ומ
שקובץ שאנחנו רוצים לקבל אותם.

253
00:12:35,192 --> 00:12:37,150
כנראה הכי טוב מאויר
עם דוגמא כאן.

254
00:12:37,150 --> 00:12:41,640
אז נניח שאנו מצהירים
מערך של 10 מספרים שלמים.

255
00:12:41,640 --> 00:12:45,080
שמנו רק הכריז על
מחסנית באופן שרירותי int arr 10.

256
00:12:45,080 --> 00:12:46,970
אז זה די פשוט.

257
00:12:46,970 --> 00:12:51,970
עכשיו מה שאנחנו עושים אף הוא
frecall הוא שאנחנו קוראים גודל של int

258
00:12:51,970 --> 00:12:54,180
פעמים 10 בייטים של מידע.

259
00:12:54,180 --> 00:12:59,040
גודל של ההוויה int four-- זה
בגודל של מספר שלם בג.

260
00:12:59,040 --> 00:13:02,790
>> אז מה שאנחנו עושים הוא שאנחנו קוראים
40 בתים בשווי של מידע

261
00:13:02,790 --> 00:13:05,850
מהקובץ הצביע על ידי PTR.

262
00:13:05,850 --> 00:13:08,600
ואנחנו אחסון אלה
40 בתים איפשהו

263
00:13:08,600 --> 00:13:12,080
שבו יש לנו להפריש
40 בתים בשווי של זיכרון.

264
00:13:12,080 --> 00:13:15,970
למרבה המזל, כבר עשה את זה על ידי
הכרזת ARR, מערך שממש שם.

265
00:13:15,970 --> 00:13:19,770
כי הוא מסוגל אחזקה
10 יחידות ארבעה-בייט.

266
00:13:19,770 --> 00:13:22,860
אז בסך הכל, זה יכול להחזיק 40
בתים בשווי של מידע.

267
00:13:22,860 --> 00:13:26,540
ואנחנו קוראים עכשיו 40 בתים
מידע מהקובץ,

268
00:13:26,540 --> 00:13:30,330
ואנחנו אחסונו בעיבוד.

269
00:13:30,330 --> 00:13:35,470
>> נזכיר מהווידאו על עצות ש
שמו של מערך, כגון עיבוד,

270
00:13:35,470 --> 00:13:38,370
הוא באמת רק מצביע
לאלמנט הראשון שלה.

271
00:13:38,370 --> 00:13:43,680
לכן, כאשר אנחנו עוברים בעיבוד שיש, אנחנו
הם, למעשה, עוברים במצביע.

272
00:13:43,680 --> 00:13:46,120
>> בדומה לכך אנו יכולים לעשות זה--
אנחנו עושים לא בהכרח

273
00:13:46,120 --> 00:13:51,200
צריך לשמור על חיצנו הערימה.

274
00:13:51,200 --> 00:13:54,990
כמו כן, אנו יכולים להקצות באופן דינמי
חיץ כזה, באמצעות malloc.

275
00:13:54,990 --> 00:13:57,340
זכור, כאשר אנחנו
דינמי להקצות זיכרון,

276
00:13:57,340 --> 00:14:00,550
אנחנו שומרים את זה ב
ערימה, לא הערימה.

277
00:14:00,550 --> 00:14:02,110
אבל זה עדיין חיץ.

278
00:14:02,110 --> 00:14:06,810
>> זה עדיין, במקרה זה, הוא
מחזיק 640 בייטים של מידע

279
00:14:06,810 --> 00:14:09,230
בגלל כפול תופס שמונה בתים.

280
00:14:09,230 --> 00:14:11,570
ואנחנו מבקשים עבור 80 מהם.

281
00:14:11,570 --> 00:14:13,770
אנחנו רוצים שנהיה לי חלל
להחזיק 80 זוגות.

282
00:14:13,770 --> 00:14:17,210
אז 80 פעמים 8 היא מידע 640 בתים.

283
00:14:17,210 --> 00:14:21,880
ושיחה שלfread היא
איסוף 640 בייטים של מידע

284
00:14:21,880 --> 00:14:27,770
מהקובץ הצביע על ידי
PTR ואחסונו עכשיו בarr2.

285
00:14:27,770 --> 00:14:32,770
>> עכשיו אנחנו גם יכולים לטפל fread
בדיוק כמו קריאה לfgetc.

286
00:14:32,770 --> 00:14:37,140
במקרה זה, אנחנו רק מנסים
לקבל תו אחד מהקבצים.

287
00:14:37,140 --> 00:14:40,070
ואנחנו לא צריכים
מערך להחזיק אופי.

288
00:14:40,070 --> 00:14:43,170
אנחנו רק יכולים לאחסן אותו ב
משתנה אופי.

289
00:14:43,170 --> 00:14:46,390
>> המלכוד, אם כי, הוא ש
כאשר רק שיש לנו משתנה,

290
00:14:46,390 --> 00:14:50,290
אנחנו צריכים לעבור ב
כתובת של משתנה ש

291
00:14:50,290 --> 00:14:52,550
כי זוכר ש
טיעון הראשון לfread

292
00:14:52,550 --> 00:14:59,210
הוא מצביע למיקום ולזיכרון
שבו אנחנו רוצים לאחסן את המידע.

293
00:14:59,210 --> 00:15:01,550
שוב, את שמו של
המערך הוא מצביע.

294
00:15:01,550 --> 00:15:04,200
אז אנחנו לא צריכים לעשות מערך אמפרסנד.

295
00:15:04,200 --> 00:15:07,270
אבל ג, ג האופי
כאן, הוא לא מערך.

296
00:15:07,270 --> 00:15:08,390
זה רק משתנה.

297
00:15:08,390 --> 00:15:11,840
ולכן אנחנו צריכים לעבור
אמפרסנד ג כדי לציין

298
00:15:11,840 --> 00:15:15,350
שזה הכתובת שבה אנחנו רוצים
לאחסן בייט אחד של מידע,

299
00:15:15,350 --> 00:15:20,479
דמות אחת זה ש
אנחנו אוספים מPTR.

300
00:15:20,479 --> 00:15:22,270
Fwrite-- אני אלך דרך
זה קצת יותר

301
00:15:22,270 --> 00:15:25,440
quickly-- הוא פחות או יותר
מקבילה של fread מדויקת

302
00:15:25,440 --> 00:15:27,720
מלבד זה לכתיבה
במקום קריאה, רק

303
00:15:27,720 --> 00:15:31,610
כמו other-- שהיינו לנו פתוח
וקרוב, תקבל אופי,

304
00:15:31,610 --> 00:15:32,530
לכתוב אופי.

305
00:15:32,530 --> 00:15:35,040
עכשיו זה מקבל שרירותי
כמות המידע,

306
00:15:35,040 --> 00:15:37,170
סכום שרירותי תקין של מידע.

307
00:15:37,170 --> 00:15:39,790
אז בדיוק כמו לפני, אנחנו יכולים
יש מערך של 10 מספרים שלמים

308
00:15:39,790 --> 00:15:43,210
שבו כבר יש לנו
מידע מאוחסן, אולי.

309
00:15:43,210 --> 00:15:46,580
>> זה היה כנראה כמה שורות קוד
כי צריך ללכת בין שני אלה

310
00:15:46,580 --> 00:15:49,990
שבו אני ממלא ARR עם
משהו משמעותי.

311
00:15:49,990 --> 00:15:51,880
אני ממלא אותו עם 10 מספרים שלמים שונים.

312
00:15:51,880 --> 00:15:54,920
ובמקום זאת, מה שאני
עושה כותב מעיבוד

313
00:15:54,920 --> 00:15:58,600
ואיסוף המידע מעיבוד.

314
00:15:58,600 --> 00:16:02,390
ואני לוקח את המידע ש
ומכניס אותו לתוך הקובץ.

315
00:16:02,390 --> 00:16:05,410
>> אז במקום שזה יהיה מ
הקובץ למאגר,

316
00:16:05,410 --> 00:16:08,790
עכשיו אנחנו הולכים מ
החיץ לקובץ.

317
00:16:08,790 --> 00:16:10,580
אז זה בדיוק ההפך.

318
00:16:10,580 --> 00:16:16,680
אז שוב, בדיוק כמו לפני, אנחנו יכולים
גם נתח ערימה של זיכרון

319
00:16:16,680 --> 00:16:19,600
שיש לנו באופן דינמי
הוקצה ולקרוא שמ

320
00:16:19,600 --> 00:16:21,570
ולכתוב את זה לקובץ.

321
00:16:21,570 --> 00:16:24,900
>> ויש לנו גם משתנה אחד
מסוגל להחזיק בית אחד

322
00:16:24,900 --> 00:16:27,200
של מידע, כגון אופי.

323
00:16:27,200 --> 00:16:29,830
אבל שוב, אנחנו צריכים לעבור ב
הכתובת של משתנה ש

324
00:16:29,830 --> 00:16:31,840
כאשר אנו רוצים לקרוא ממנה.

325
00:16:31,840 --> 00:16:35,280
אז אנחנו יכולים לכתוב את המידע
אנו מוצאים בכתובת ש

326
00:16:35,280 --> 00:16:39,050
למצביע הקובץ, PTR.

327
00:16:39,050 --> 00:16:41,630
>> יש הרבה אחרים
פונקציות קלט / פלט קובץ גדול

328
00:16:41,630 --> 00:16:44,650
שעושים דברים שונים מלבד
אלה שדיברנו על היום.

329
00:16:44,650 --> 00:16:46,450
כמה מאלה
אתה עלול למצוא את שימושי

330
00:16:46,450 --> 00:16:50,840
הם fgets וfputs,
שהם שווי הערך

331
00:16:50,840 --> 00:16:56,190
של fgetc וfputc אלא גם לקריאה
מחרוזת אחת מקובץ.

332
00:16:56,190 --> 00:16:59,020
במקום תו בודד,
זה יהיה לקרוא כל מחרוזת.

333
00:16:59,020 --> 00:17:02,940
fprintf, אשר בעצם מאפשרת
לך להשתמש printf לכתוב לקובץ.

334
00:17:02,940 --> 00:17:05,619
אז בדיוק כמו שאתה יכול לעשות
החלפה משתנה באמצעות

335
00:17:05,619 --> 00:17:09,900
ואני אחוזים מצייני מיקום
ד אחוזים, וכן הלאה, עם printf

336
00:17:09,900 --> 00:17:14,690
אתה יכול לקחת באופן דומה
מחרוזת printf והדפסת משהו

337
00:17:14,690 --> 00:17:16,800
כמו שלקובץ.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- אם יש לך נגן DVD
היא האנלוגיה אני בדרך כלל להשתמש כאן--

339
00:17:20,720 --> 00:17:23,109
הוא כמו סוג של השימוש שלך
אחורה וקדימה במהירות

340
00:17:23,109 --> 00:17:25,819
כפתורים כדי לנוע הסרט.

341
00:17:25,819 --> 00:17:28,369
כמו כן, אתה יכול להסתובב הקובץ.

342
00:17:28,369 --> 00:17:30,250
אחד הדברים בתוך
שמבנה הקובץ

343
00:17:30,250 --> 00:17:34,270
ג שיוצר עבורך הוא אינדיקטור
היכן אתה נמצא בקובץ.

344
00:17:34,270 --> 00:17:36,420
האם אתה במאוד
מתחיל, בבתי אפס?

345
00:17:36,420 --> 00:17:39,290
האם אתה בייט 100,
בתים 1,000, וכן הלאה?

346
00:17:39,290 --> 00:17:44,340
אתה יכול להשתמש בfseek לנוע באופן שרירותי
מחוון שקדימה או אחורה.

347
00:17:44,340 --> 00:17:46,744
>> וftell, שוב
בדומה לנגן DVD,

348
00:17:46,744 --> 00:17:49,660
הוא כמו שעון קטן שאומר לי
לך כמה דקות ושניות ש

349
00:17:49,660 --> 00:17:52,480
הם לסרט מסוים.

350
00:17:52,480 --> 00:17:56,990
באופן דומה, ftell אומר לך איך
בתים רבים אתה לתוך הקובץ.

351
00:17:56,990 --> 00:18:00,210
feof היא גרסה שונה
גילוי אם יש לך

352
00:18:00,210 --> 00:18:01,700
הגיע לסוף הקובץ.

353
00:18:01,700 --> 00:18:03,600
וferror הוא פונקציה
שאתה יכול להשתמש

354
00:18:03,600 --> 00:18:06,959
כדי לזהות אם משהו יש
הלך עבודה לא בסדר עם קובץ.

355
00:18:06,959 --> 00:18:08,750
שוב, זה רק
מגרד את פני השטח.

356
00:18:08,750 --> 00:18:12,730
יש עדיין הרבה יותר קובץ קלט / פלט
פונקציות בio.h. הסטנדרטי

357
00:18:12,730 --> 00:18:16,620
אבל זה כנראה יקבל אותך
התחיל לעבוד עם מצביעי קובץ.

358
00:18:16,620 --> 00:18:17,640
אני דאג לויד.

359
00:18:17,640 --> 00:18:19,750
זה cs50.

360
00:18:19,750 --> 00:18:21,669