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
>> Теперь каждый функция указатель файла,
или каждый файл ввода-вывода, ввода-вывода /

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

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
Файл звезда ptr-- PTR быть общим
Фамилия, имя, файл pointer-- FOPEN

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

80
00:03:57,300 --> 00:04:01,690
Таким образом, мы, возможно, вызов, который выглядит как
this-- файл звезда PTR 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
Так г является операция, что мы
выбирать, когда мы хотим, чтобы прочитать файл.

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
Так на пару скользит назад, мы
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, 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
и мы уже можем дублировать
терминал командной 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 заглавная А 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
Итак, мы собираемся, чтобы написать
заглавная А подать 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
чтобы позвонить в PRINTF с призывом 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 и его функция спутник
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 обр 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-- это
размер целого числа в C.

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
К счастью, мы уже сделали, что,
заявив, обр, что массив прямо там.

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
>> Аналогично мы можем сделать 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
это один символ, что
мы взыскании с 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
где я заполнить обр с
что-то значимое.

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-плеер
аналогия я обычно использую 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
Там еще много более файловый ввод / вывод
функции в стандартной 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