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

2
00:00:05,330 --> 00:00:07,870
>> SPEAKER: Досега, най-вероятно
че повечето от вашите програми

3
00:00:07,870 --> 00:00:10,170
са били малко по-ефимерно.

4
00:00:10,170 --> 00:00:13,310
Вие пуснете програма като Mario или алчни.

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
ФОРМАТ, че също така ви позволява
живее в стандартната 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
>> Сега всеки един функция файлов указател,
или всеки един файл I / 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
неуспешно.

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
която и да е от друга файла I / O функции.

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
не е равно на нула.

70
00:03:28,320 --> 00:03:31,320
Ако не сте гледали видеото
указатели, това не може да има смисъл.

71
00:03:31,320 --> 00:03:35,639
Но ако се опитате и сочен
нулев изземване показалеца,

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
File звезда ptr-- PTR е родово
име за файла pointer-- fopen

79
00:03:52,690 --> 00:03:57,300
и ние преминаваме в две неща, име на файла
и операция искаме да предприеме.

80
00:03:57,300 --> 00:04:01,690
Така че можем да имаме покана, която прилича
this-- файл звезда КОП 1 се равнява на fopen

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

82
00:04:04,040 --> 00:04:07,020
И операцията съм избрал е г.

83
00:04:07,020 --> 00:04:08,639
>> Така че това, което мислите, че г е тук?

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
И след като сме затворени файл, не можем да
изпълнява всяка по-файл I / O функции,

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
да продължи да работи с
го използвате функциите на I / O.

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
Така че на няколко пързалки преди, ние
fopened файл 1 точка текст за четене

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
Ние можем само fclose ptr1.

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
Тъй като ние сме направили тук,
Чар гл равнява 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
Така Чар гл равнява fgetc ptr1.

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
но той на практика дублира
на Linux команда котката.

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, КОП не е
равно на 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
и вече можем да дублира
терминален команда Linux.

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 капитал A ptr2, всички
че това ще се направи, е, че е

206
00:10:08,000 --> 00:10:12,040
ще напиша писмото
в A в файл 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
Така че ние ще напише
капитали A да подаде 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
за да може да се възпроизведе на котката
Linux команда, този, който отпечатва

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
призовавам да ФОРМАТ с обаждане до fputc.

220
00:10:50,720 --> 00:10:54,090
>> И сега ние сме дублира ср,
много основни команди Linux

221
00:10:54,090 --> 00:10:59,100
че ние говорихме за дълъг път
Преди в Linux команди видео.

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
Така че това е ср, командата копие Linux.

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
итерации чрез файла
един символ в даден момент.

242
00:11:55,770 --> 00:12:00,230
Няма ли да е по-хубав, за да получите
100 по време или 500 по време?

243
00:12:00,230 --> 00:12:03,250
>> Е, fread и неговата спътница функция
неуспешно, които ние ще говорим за

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 се ние четете размер на инт

258
00:12:51,970 --> 00:12:54,180
10 пъти байта информация.

259
00:12:54,180 --> 00:12:59,040
Размер на инт същество four-- това е
размера на цяло число в С.

260
00:12:59,040 --> 00:13:02,790
>> Така че това, което правим е, че ние четене
40 байта стойност на информация

261
00:13:02,790 --> 00:13:05,850
От преписката, посочи от КОП.

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
>> Спомнете си от видеото на насоки, които
Името на масив, като ARR,

270
00:13:35,470 --> 00:13:38,370
наистина е само указател
неговия първи елемент.

271
00:13:38,370 --> 00:13:43,680
Така че, когато се минава през ARR там, ние
са, в действителност, преминаваща в указател.

272
00:13:43,680 --> 00:13:46,120
>> По същия начин можем да направим this--
ние не задължително

273
00:13:46,120 --> 00:13:51,200
Трябва да спасим нашата буфер в стека.

274
00:13:51,200 --> 00:13:54,990
Ние също може динамично да разпредели
буфер, подобен на този, с помощта на изчистване.

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
това един знак, че
ние сме събиране от КОП.

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
където I запълни с ARR
нещо смислено.

311
00:15:49,990 --> 00:15:51,880
Аз го напълни с 10 различни числа.

312
00:15:51,880 --> 00:15:54,920
И вместо това, което аз съм
прави се пише от ARR

313
00:15:54,920 --> 00:15:58,600
и събиране на информацията от ARR.

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
>> Има много други
страхотно файлови I / O функции

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, които в общи линии позволява
можете да използвате ФОРМАТ да пиша във файла.

334
00:17:02,940 --> 00:17:05,619
Така че точно като можете да направите
променлива смяна използвайки

335
00:17:05,619 --> 00:17:09,900
Запазено място процента I и
процента г, и така нататък, с ФОРМАТ

336
00:17:09,900 --> 00:17:14,690
можете подобно може да вземе
ФОРМАТ низ и печатни нещо

337
00:17:14,690 --> 00:17:16,800
като тази във файл.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- ако имате DVD плейър
е аналогията Аз обикновено използвам here--

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,
байт 1000, и така нататък?

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
Все още има много по-файл I / O
функции в стандартната 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