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

2
00:00:05,330 --> 00:00:07,870
>> COLUNA: Até o momento, é provável
que a maioria dos seus programas

3
00:00:07,870 --> 00:00:10,170
ter sido um pouco efémera.

4
00:00:10,170 --> 00:00:13,310
Você executar um programa como Mario ou ávido.

5
00:00:13,310 --> 00:00:17,350
Ele faz algo, talvez solicitará
o usuário para algumas informações,

6
00:00:17,350 --> 00:00:20,400
imprimir alguma saída para a tela,
mas, em seguida, quando o programa acabou,

7
00:00:20,400 --> 00:00:23,252
não há realmente nenhuma evidência lá
ele nunca foi executado em primeiro lugar.

8
00:00:23,252 --> 00:00:25,960
Quero dizer, claro, que você pode ter deixado
ele abrir na janela do terminal,

9
00:00:25,960 --> 00:00:29,770
mas se você limpar sua tela, não há
realmente nenhuma evidência de que ele existia.

10
00:00:29,770 --> 00:00:33,720
Nós não temos um meio de armazenamento
informações persistente, informações

11
00:00:33,720 --> 00:00:36,890
que existe após o nosso
programa parou de funcionar,

12
00:00:36,890 --> 00:00:39,241
ou que não tem, até este ponto.

13
00:00:39,241 --> 00:00:41,490
Felizmente, porém, faz c
fornecer-nos com a capacidade

14
00:00:41,490 --> 00:00:44,220
fazer isso através da implementação
algo chamado

15
00:00:44,220 --> 00:00:48,330
um arquivo, uma estrutura que, basicamente,
representa um arquivo que você dobraria

16
00:00:48,330 --> 00:00:53,826
clique em seu computador, se você estiver
usado para um ambiente de usuário gráfica.

17
00:00:53,826 --> 00:00:55,700
De um modo geral quando se trabalha
com c, estamos, na verdade,

18
00:00:55,700 --> 00:00:59,965
vai estar trabalhando com
ponteiros para files-- arquivo stars--

19
00:00:59,965 --> 00:01:02,090
com exceção de um pouco
quando falamos de um casal

20
00:01:02,090 --> 00:01:04,560
de que as funções
trabalhar com ponteiros de arquivo.

21
00:01:04,560 --> 00:01:08,990
Você não precisa ter realmente cavou
muito profundo entendimento ponteiros

22
00:01:08,990 --> 00:01:09,730
si mesmos.

23
00:01:09,730 --> 00:01:12,870
Há um pouco de hippies
onde iremos falar sobre eles,

24
00:01:12,870 --> 00:01:18,090
mas geralmente o arquivo e ponteiros
ponteiros, enquanto inter-relacionados,

25
00:01:18,090 --> 00:01:20,290
não são exatamente a mesma coisa.

26
00:01:20,290 --> 00:01:22,440
>> Agora o que eu quero dizer quando
Eu digo dados persistentes?

27
00:01:22,440 --> 00:01:23,650
O que são dados persistentes?

28
00:01:23,650 --> 00:01:25,232
Por que nos preocupamos com isso?

29
00:01:25,232 --> 00:01:27,190
Digamos que, por exemplo, que
você está executando um programa

30
00:01:27,190 --> 00:01:29,850
ou que você tenha reescrito um
programa que é um jogo,

31
00:01:29,850 --> 00:01:32,960
e você quer manter o controle
de todos os movimentos do usuário

32
00:01:32,960 --> 00:01:36,620
de modo que talvez, se algo der errado,
você pode rever o arquivo após o jogo.

33
00:01:36,620 --> 00:01:39,970
Isso é o que queremos dizer quando
falar sobre dados persistentes.

34
00:01:39,970 --> 00:01:43,930
>> No decurso da execução de seu
programa, um arquivo é criado.

35
00:01:43,930 --> 00:01:45,680
E quando o seu programa
parou de funcionar,

36
00:01:45,680 --> 00:01:48,689
esse arquivo ainda existe no seu sistema.

37
00:01:48,689 --> 00:01:50,230
E nós podemos olhar para ele e examiná-lo.

38
00:01:50,230 --> 00:01:53,670
E assim que o programa seria definida como
criaram alguns dados persistentes,

39
00:01:53,670 --> 00:01:57,390
existem dados após o programa
terminar a execução.

40
00:01:57,390 --> 00:02:02,320
>> Agora todas estas funções que funcionam
com a criação de arquivos e manipulação

41
00:02:02,320 --> 00:02:04,940
los de diversas maneiras
viver em io.h padrão,

42
00:02:04,940 --> 00:02:08,210
que é um ficheiro de cabeçalho que
você provavelmente sido libra

43
00:02:08,210 --> 00:02:10,910
incluindo na parte superior da consideravelmente
muito todos os seus programas

44
00:02:10,910 --> 00:02:14,130
porque contém um dos
a maioria das funções úteis para nós,

45
00:02:14,130 --> 00:02:16,130
printf, que também permite
vive em io.h. padrão

46
00:02:16,130 --> 00:02:20,400
Então você não precisa bater incluem
quaisquer arquivos adicionais provavelmente

47
00:02:20,400 --> 00:02:23,540
a fim de trabalhar com ponteiros de arquivo.

48
00:02:23,540 --> 00:02:29,980
>> Agora, cada função de ponteiro de arquivo único,
ou cada arquivo I / O, de entrada e saída

49
00:02:29,980 --> 00:02:33,310
função, aceita como um
de seus parâmetros ou insumos

50
00:02:33,310 --> 00:02:35,822
pointer-- um arquivo salvo
por exemplo, fopen, que

51
00:02:35,822 --> 00:02:38,280
é o que você usa para obter o arquivo
ponteiro em primeiro lugar.

52
00:02:38,280 --> 00:02:41,010
Mas depois que você abriu a
arquivo e você começa ponteiros de arquivo,

53
00:02:41,010 --> 00:02:43,510
você pode, em seguida, passá-los como
argumentos para as várias funções

54
00:02:43,510 --> 00:02:46,720
vamos falar sobre
Hoje em dia, bem como muitos outros

55
00:02:46,720 --> 00:02:48,520
de modo que você pode trabalhar com arquivos.

56
00:02:48,520 --> 00:02:50,980
>> Portanto, há seis bonita
os básicos comuns

57
00:02:50,980 --> 00:02:52,870
que vamos falar hoje.

58
00:02:52,870 --> 00:02:57,160
fopen e seu companheiro
função fclose, fgetc

59
00:02:57,160 --> 00:03:02,670
e sua função fputc companheiro,
e fread e sua função companheiro,

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

61
00:03:03,820 --> 00:03:05,180
Então vamos direto ao assunto.

62
00:03:05,180 --> 00:03:07,050
>> fopen-- o que ele faz?

63
00:03:07,050 --> 00:03:10,050
Bem, ele abre um arquivo e ele
dá-lhe um ponteiro de arquivo a ele,

64
00:03:10,050 --> 00:03:14,000
de modo que você pode usar esse
arquivo ponteiro como um argumento

65
00:03:14,000 --> 00:03:16,730
para qualquer uma das outras funções de E / S de arquivo.

66
00:03:16,730 --> 00:03:19,100
A coisa mais importante
para se lembrar com fopen

67
00:03:19,100 --> 00:03:24,222
é que, depois de ter aberto o
arquivo ou fez uma ligação como a que aqui,

68
00:03:24,222 --> 00:03:26,930
você precisa verificar para certificar-se
que o ponteiro que você tem de volta

69
00:03:26,930 --> 00:03:28,320
não é igual a nulo.

70
00:03:28,320 --> 00:03:31,320
Se você ainda não assistiu o vídeo em
ponteiros, isso pode não fazer sentido.

71
00:03:31,320 --> 00:03:35,639
Mas se você tentar e dereference
um recall ponteiro nulo,

72
00:03:35,639 --> 00:03:38,180
seu programa provavelmente sofrerão
uma segmentação [inaudível].

73
00:03:38,180 --> 00:03:40,540
Nós queremos ter certeza de que nós
tem um ponteiro de volta legítimo.

74
00:03:40,540 --> 00:03:43,665
A grande maioria do tempo nós vamos
ter obtido um ponteiro legítimo de volta

75
00:03:43,665 --> 00:03:45,280
e não será um problema.

76
00:03:45,280 --> 00:03:46,760
>> Então, como vamos fazer uma chamada para fopen?

77
00:03:46,760 --> 00:03:48,051
Parece muito bonito como este.

78
00:03:48,051 --> 00:03:52,690
Estrela arquivo ptr-- ptr sendo um genérico
nome para o arquivo pointer-- fopen

79
00:03:52,690 --> 00:03:57,300
e nós passamos em duas coisas, um nome de arquivo
e uma operação que queremos empreender.

80
00:03:57,300 --> 00:04:01,690
Assim, poderíamos ter uma chamada que se parece com
isto-- estrela arquivo ptr 1 é igual a fopen

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

82
00:04:04,040 --> 00:04:07,020
E a operação que eu escolhi é r.

83
00:04:07,020 --> 00:04:08,639
>> Então, o que você acha r é aqui?

84
00:04:08,639 --> 00:04:11,180
Quais são os tipos de coisas que
pode ser capaz de fazer para arquivos?

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

86
00:04:13,760 --> 00:04:17,500
Assim, R é a operação que nós
escolher quando queremos ler um arquivo.

87
00:04:17,500 --> 00:04:20,260
Por isso, seria, basicamente, quando
fazemos uma chamada como este

88
00:04:20,260 --> 00:04:25,440
estar recebendo nós um ponteiro de arquivo
de tal forma que nós poderia então ler informações

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

90
00:04:27,770 --> 00:04:34,190
>> Da mesma forma, poderíamos abrir o arquivo 2.txt
para escrever e para que possamos passar ptr2,

91
00:04:34,190 --> 00:04:38,210
o ponteiro do arquivo que eu criei aqui,
como um argumento para qualquer função que

92
00:04:38,210 --> 00:04:40,080
grava informações em um arquivo.

93
00:04:40,080 --> 00:04:43,767
E semelhante à escrita, há
também a opção de acrescentar, a.

94
00:04:43,767 --> 00:04:45,600
A diferença entre
escrevendo e anexando

95
00:04:45,600 --> 00:04:50,920
sendo que quando você gravar em um arquivo,
se você fizer uma chamada para fopen para a escrita

96
00:04:50,920 --> 00:04:54,761
e esse arquivo já existe, é
vai substituir o arquivo inteiro.

97
00:04:54,761 --> 00:04:56,510
Vai começar
no início,

98
00:04:56,510 --> 00:04:58,820
apagar todas as informações
que já está lá.

99
00:04:58,820 --> 00:05:02,210
>> Considerando que, se você abri-lo para acrescentar,
ele vai para o final do arquivo

100
00:05:02,210 --> 00:05:04,340
se já existe texto em
ou informações nele contidas,

101
00:05:04,340 --> 00:05:06,040
e vai então começar
escrita de lá.

102
00:05:06,040 --> 00:05:08,570
Então você não vai perder qualquer um dos
informações que você fez antes.

103
00:05:08,570 --> 00:05:12,110
Se você quer escrever ou anexar
tipo de depende da situação.

104
00:05:12,110 --> 00:05:16,840
Mas você provavelmente vai saber o que o
operação certa é quando chega a hora.

105
00:05:16,840 --> 00:05:18,020
Então, isso é fopen.

106
00:05:18,020 --> 00:05:18,930
>> E sobre fclose?

107
00:05:18,930 --> 00:05:21,600
Bem, muito simplesmente, fclose
apenas aceita o ponteiro do arquivo.

108
00:05:21,600 --> 00:05:24,000
E como você poderia esperar,
ele fecha o arquivo.

109
00:05:24,000 --> 00:05:29,270
E uma vez que você fechou um arquivo, não podemos
realizar mais qualquer arquivo de funções de E / S,

110
00:05:29,270 --> 00:05:31,420
lendo ou escrevendo, naquele arquivo.

111
00:05:31,420 --> 00:05:36,444
Temos de voltar a abrir a
apresentar outra vez, a fim

112
00:05:36,444 --> 00:05:38,610
continuar a trabalhar com
-lo usando as funções de I / O.

113
00:05:38,610 --> 00:05:41,520
Então meios fclose estamos a fazer
trabalhar com este arquivo.

114
00:05:41,520 --> 00:05:44,690
E todos nós precisamos é passar em
o nome de um ficheiro de ponteiro.

115
00:05:44,690 --> 00:05:50,010
Então, em um par desliza atrás,
fopened arquivo de texto 1 ponto para a leitura

116
00:05:50,010 --> 00:05:52,854
e nós atribuído que
arquivo ponteiro para ptr1.

117
00:05:52,854 --> 00:05:55,020
Agora nós decidimos que somos
leitura feita a partir desse arquivo.

118
00:05:55,020 --> 00:05:56,561
Nós não precisam fazer mais nada com ele.

119
00:05:56,561 --> 00:05:58,890
Podemos ptr1 apenas fclose.

120
00:05:58,890 --> 00:06:01,950
E da mesma forma, poderíamos
usar fclose os outros.

121
00:06:01,950 --> 00:06:02,450
Tudo certo.

122
00:06:02,450 --> 00:06:03,700
De modo que está abrindo e fechando.

123
00:06:03,700 --> 00:06:05,780
Esses são os dois básico
operações de partida.

124
00:06:05,780 --> 00:06:08,050
>> Agora queremos realmente
fazer algumas coisas interessantes,

125
00:06:08,050 --> 00:06:11,940
e a primeira função que vamos
ver que vai fazer isso é fgetc--

126
00:06:11,940 --> 00:06:14,110
arquivar obter um personagem.

127
00:06:14,110 --> 00:06:17,350
Isso é o que geralmente fgetc
se traduziria em.

128
00:06:17,350 --> 00:06:20,190
Seu objetivo na vida é
leia o próximo caractere,

129
00:06:20,190 --> 00:06:22,079
ou se esta é a sua muito
primeira chamada para fgetc

130
00:06:22,079 --> 00:06:23,870
para um determinado arquivo,
o primeiro caractere.

131
00:06:23,870 --> 00:06:26,210
Mas, então, depois disso,
você começa a próxima,

132
00:06:26,210 --> 00:06:31,500
o muito próximo caractere desse arquivo,
e as armazena em uma variável de caractere.

133
00:06:31,500 --> 00:06:34,490
Como nós fizemos aqui,
caractere ch igual fgetc,

134
00:06:34,490 --> 00:06:36,389
passar o nome de um ficheiro de ponteiro.

135
00:06:36,389 --> 00:06:38,180
Novamente, é muito
importante aqui para lembrar

136
00:06:38,180 --> 00:06:41,430
que, a fim de ter
esta operação foi bem sucedida,

137
00:06:41,430 --> 00:06:45,690
o próprio ponteiro de arquivo devo ter
foi aberto para leitura.

138
00:06:45,690 --> 00:06:50,589
Não podemos ler um personagem de um arquivo
ponteiro que abrimos para a escrita.

139
00:06:50,589 --> 00:06:52,630
Então essa é uma das
limitações de fopen, certo?

140
00:06:52,630 --> 00:06:55,470
Temos para restringir
nós apenas para realizar

141
00:06:55,470 --> 00:06:57,710
uma operação com um ponteiro de arquivo.

142
00:06:57,710 --> 00:07:00,220
Se quiséssemos ler e
escrever a partir do mesmo arquivo,

143
00:07:00,220 --> 00:07:03,840
teríamos aberto dois separados
ponteiros de arquivos para o mesmo file--

144
00:07:03,840 --> 00:07:05,670
uma para leitura, uma para a escrita.

145
00:07:05,670 --> 00:07:08,400
>> Então, novamente, a única razão
Eu trago que até agora é

146
00:07:08,400 --> 00:07:11,920
porque se nós estamos indo para fazer uma chamada
para fgetc, que deve ter um ponteiro de arquivo

147
00:07:11,920 --> 00:07:14,172
foi aberto para leitura.

148
00:07:14,172 --> 00:07:15,880
E, em seguida, muito simplesmente,
tudo o que precisamos fazer

149
00:07:15,880 --> 00:07:17,546
é passar o nome do ponteiro do arquivo.

150
00:07:17,546 --> 00:07:21,060
Então ch carvão equivale a ptr1 fgetc.

151
00:07:21,060 --> 00:07:23,200
>> Isso vai levar-nos
a próxima character--

152
00:07:23,200 --> 00:07:25,575
ou ainda, se este for o primeiro
vez que já se fez esta chamada,

153
00:07:25,575 --> 00:07:29,750
o primeiro character-- de qualquer
arquivo é apontada por ptr1.

154
00:07:29,750 --> 00:07:32,210
Lembre-se que isso era um arquivo de texto de ponto.

155
00:07:32,210 --> 00:07:36,490
Ele vai ter o primeiro caractere dessa
e vamos armazená-lo no ch variável.

156
00:07:36,490 --> 00:07:37,941
Bastante simples.

157
00:07:37,941 --> 00:07:40,190
Então, temos apenas olhou para três
funções e já nós

158
00:07:40,190 --> 00:07:43,070
pode fazer algo muito arrumado.

159
00:07:43,070 --> 00:07:46,320
>> Então, se tomarmos essa capacidade
de obtenção de um personagem

160
00:07:46,320 --> 00:07:48,943
e nós laço ele-- portanto,
continuar a receber personagens

161
00:07:48,943 --> 00:07:51,390
a partir de um arquivo de mais e
mais e agora nós over--

162
00:07:51,390 --> 00:07:54,500
pode ler cada
personagem de um arquivo.

163
00:07:54,500 --> 00:07:58,670
E se nós imprimir cada personagem
imediatamente depois de lê-lo,

164
00:07:58,670 --> 00:08:01,960
temos agora lidos de um arquivo e
seu conteúdo impresso para a tela.

165
00:08:01,960 --> 00:08:05,610
Temos efetivamente concatenado
esse arquivo na tela.

166
00:08:05,610 --> 00:08:09,670
E é isso que o
Comando cat Linux faz.

167
00:08:09,670 --> 00:08:13,250
>> Se você digitar gato no nome do arquivo, ele
imprimirá todo o conteúdo

168
00:08:13,250 --> 00:08:15,160
do arquivo na janela do seu terminal.

169
00:08:15,160 --> 00:08:19,010
E assim este pequeno laço aqui,
apenas três linhas de código,

170
00:08:19,010 --> 00:08:23,270
mas ele duplica efetivamente
o gato de comando do Linux.

171
00:08:23,270 --> 00:08:25,210
Portanto, esta sintaxe pode
Parece um pouco estranho,

172
00:08:25,210 --> 00:08:26,670
mas aqui está o que está acontecendo aqui.

173
00:08:26,670 --> 00:08:31,460
Enquanto ch igual fgetc, ptr não é
igual a EOF-- é um bocado todo,

174
00:08:31,460 --> 00:08:34,669
mas vamos dividi-la apenas
por isso é claro sobre a sintaxe.

175
00:08:34,669 --> 00:08:37,169
Eu consolidou-lo
por uma questão de espaço,

176
00:08:37,169 --> 00:08:39,049
embora seja um pouco
sintaticamente complicado.

177
00:08:39,049 --> 00:08:41,194
>> Portanto, esta parte no direito verde
agora, o que ele está fazendo?

178
00:08:41,194 --> 00:08:42,860
Bem, isso é apenas o nosso apelo fgetc, certo?

179
00:08:42,860 --> 00:08:44,530
Temos visto isso antes.

180
00:08:44,530 --> 00:08:49,500
É obtenção de um
personagem a partir do arquivo.

181
00:08:49,500 --> 00:08:53,220
Em seguida, comparar esse
caráter contra EOF.

182
00:08:53,220 --> 00:08:57,470
EOF é um valor especial que é
definido em io.h padrão, que

183
00:08:57,470 --> 00:08:59,390
é o fim do personagem de arquivo.

184
00:08:59,390 --> 00:09:03,450
Então, basicamente o que vai acontecer
é este ciclo vai ler um personagem,

185
00:09:03,450 --> 00:09:07,445
comparar a EOF, o
fim do personagem de arquivo.

186
00:09:07,445 --> 00:09:10,070
Se eles não corresponderem, por isso, não tem
chegou ao fim do ficheiro,

187
00:09:10,070 --> 00:09:11,490
vamos imprimir esse personagem para fora.

188
00:09:11,490 --> 00:09:13,740
Então vamos voltar para o
início do ciclo novamente.

189
00:09:13,740 --> 00:09:18,310
Nós vamos chegar um personagem, verifique
contra EOF, imprimi-lo, e assim por diante

190
00:09:18,310 --> 00:09:21,094
e assim por diante e assim por diante,
loop através dessa forma

191
00:09:21,094 --> 00:09:22,760
até que chegamos ao final do arquivo.

192
00:09:22,760 --> 00:09:24,593
E, em seguida, por esse ponto,
vamos ter impresso

193
00:09:24,593 --> 00:09:26,210
para fora todo o conteúdo do ficheiro.

194
00:09:26,210 --> 00:09:29,450
Então, novamente, nós só vi
fopen, fclose, e fgetc

195
00:09:29,450 --> 00:09:34,950
e já podemos duplicar
um comando de terminal do Linux.

196
00:09:34,950 --> 00:09:38,850
>> Como eu disse no início,
tivemos fgetc e fputc,

197
00:09:38,850 --> 00:09:41,860
e fputc foi o companheiro
função de fgetc.

198
00:09:41,860 --> 00:09:44,880
E assim, como você pode imaginar,
é o equivalente escrito.

199
00:09:44,880 --> 00:09:49,440
Ela nos permite escrever uma
único caractere em um arquivo.

200
00:09:49,440 --> 00:09:53,290
>> Mais uma vez, sendo a ressalva, apenas
como se fosse com fgetc, o arquivo

201
00:09:53,290 --> 00:09:56,660
que estamos escrevendo para deve ter sido
aberto para gravação ou para acrescentar.

202
00:09:56,660 --> 00:10:00,820
Se tentarmos e usar fputc em um arquivo
que temos aberto para leitura,

203
00:10:00,820 --> 00:10:02,760
vamos sofrer
um pouco de um erro.

204
00:10:02,760 --> 00:10:04,440
Mas a chamada é bem simples.

205
00:10:04,440 --> 00:10:08,000
A capital de fputc ptr2, todos
que vai fazer é que é

206
00:10:08,000 --> 00:10:12,040
vai escrever a letra
em A em arquivo de 2 ponto

207
00:10:12,040 --> 00:10:14,760
o texto, que foi o nome do
arquivo que nós aberto e atribuído

208
00:10:14,760 --> 00:10:17,280
o ponteiro para ptr2.

209
00:10:17,280 --> 00:10:20,430
Então, nós estamos indo para escrever um
maiúsculo para arquivo 2 texto de ponto.

210
00:10:20,430 --> 00:10:24,592
E nós vamos escrever uma exclamação
apontar para o arquivo 3 dot

211
00:10:24,592 --> 00:10:27,330
texto, que foi apontado por ptr3.

212
00:10:27,330 --> 00:10:29,730
Então, novamente, bastante simples aqui.

213
00:10:29,730 --> 00:10:32,727
>> Mas agora podemos fazer outra coisa.

214
00:10:32,727 --> 00:10:34,560
Temos este exemplo
estávamos apenas passando por cima

215
00:10:34,560 --> 00:10:38,950
sobre a possibilidade de replicar o gato
De comando do Linux, o que imprime

216
00:10:38,950 --> 00:10:40,500
para a tela.

217
00:10:40,500 --> 00:10:43,510
Bem, agora que temos a capacidade
para ler caracteres de arquivos

218
00:10:43,510 --> 00:10:46,590
e escrever caracteres para arquivos,
por que não podemos simplesmente substituir esse

219
00:10:46,590 --> 00:10:50,720
chamar para printf com uma chamada para fputc.

220
00:10:50,720 --> 00:10:54,090
>> E agora temos duplicado cp,
um comando muito básico Linux

221
00:10:54,090 --> 00:10:59,100
que falamos caminho longo
atrás no Linux comandos vídeo.

222
00:10:59,100 --> 00:11:01,070
Temos efectivamente
duplicados que aqui.

223
00:11:01,070 --> 00:11:04,790
Estamos lendo um personagem e então nós estamos
escrevendo esse personagem para outro arquivo.

224
00:11:04,790 --> 00:11:07,660
Leitura de um arquivo, escrita
para outro, mais e mais

225
00:11:07,660 --> 00:11:11,350
e outra vez até chegarmos EOF.

226
00:11:11,350 --> 00:11:14,250
Temos até o fim do
arquivar estamos tentando copiar.

227
00:11:14,250 --> 00:11:18,500
E por que nós vamos ter escrito tudo
dos personagens que precisamos para o arquivo

228
00:11:18,500 --> 00:11:19,500
que nós estamos escrevendo.

229
00:11:19,500 --> 00:11:24,270
Portanto, este é cp, o comando de cópia do Linux.

230
00:11:24,270 --> 00:11:26,550
>> No início de
Neste vídeo, eu tinha a ressalva

231
00:11:26,550 --> 00:11:29,840
que gostaríamos de falar um
pouco sobre ponteiros.

232
00:11:29,840 --> 00:11:32,480
Aqui está especificamente onde estamos
vai falar sobre ponteiros

233
00:11:32,480 --> 00:11:34,800
além de apresentar ponteiros.

234
00:11:34,800 --> 00:11:37,870
Portanto, esta função parece meio assustador.

235
00:11:37,870 --> 00:11:39,120
Ele tem vários parâmetros.

236
00:11:39,120 --> 00:11:40,430
Há muita coisa acontecendo aqui.

237
00:11:40,430 --> 00:11:42,760
Há um monte de diferente
cores e textos.

238
00:11:42,760 --> 00:11:47,100
Mas, realmente, é apenas o
versão genérica do fgetc

239
00:11:47,100 --> 00:11:50,110
que nos permite obter qualquer
quantidade de informação.

240
00:11:50,110 --> 00:11:53,560
Ele pode ser um pouco ineficiente se estamos
caracteres ficando uma de cada vez,

241
00:11:53,560 --> 00:11:55,770
iteração através do arquivo
um carácter de cada vez.

242
00:11:55,770 --> 00:12:00,230
Não seria mais agradável para ficar
100 de cada vez 500 ou ao mesmo tempo?

243
00:12:00,230 --> 00:12:03,250
>> Bem, fread e sua função companheiro
fwrite, que nós vamos falar sobre

244
00:12:03,250 --> 00:12:05,490
em um segundo, permitir-nos para fazer exatamente isso.

245
00:12:05,490 --> 00:12:08,480
Podemos ler uma quantidade arbitrária
de informações de um arquivo

246
00:12:08,480 --> 00:12:10,290
e armazená-lo em algum lugar temporariamente.

247
00:12:10,290 --> 00:12:12,980
Em vez de ser capaz de apenas
ajustá-lo em uma única variável,

248
00:12:12,980 --> 00:12:15,790
que poderá ser necessário para armazená-lo em uma matriz.

249
00:12:15,790 --> 00:12:19,980
E assim, passamos em quatro
argumentos para fread-- um ponteiro

250
00:12:19,980 --> 00:12:23,940
até o local onde estamos
indo para armazenar informações,

251
00:12:23,940 --> 00:12:29,180
quão grande cada unidade de informação
será, quantas unidades de informação

252
00:12:29,180 --> 00:12:35,192
queremos adquirir, e de
qual arquivo queremos obtê-los.

253
00:12:35,192 --> 00:12:37,150
Provavelmente melhor ilustrado
com um exemplo aqui.

254
00:12:37,150 --> 00:12:41,640
Então, vamos dizer que nós declaramos
um conjunto de 10 números inteiros.

255
00:12:41,640 --> 00:12:45,080
Acabamos declarado no
empilhar arbitrariamente int arr 10.

256
00:12:45,080 --> 00:12:46,970
Então, isso é bastante simples.

257
00:12:46,970 --> 00:12:51,970
Agora, o que nós estamos fazendo, porém, é o
frecall é que estamos tamanho do int lendo

258
00:12:51,970 --> 00:12:54,180
vezes 10 bytes de informação.

259
00:12:54,180 --> 00:12:59,040
Tamanho do int estar four-- que é
o tamanho de um número inteiro no c.

260
00:12:59,040 --> 00:13:02,790
>> Então, o que nós estamos fazendo é que estamos lendo
40 bytes no valor de informações

261
00:13:02,790 --> 00:13:05,850
a partir do arquivo apontado por ptr.

262
00:13:05,850 --> 00:13:08,600
E nós estamos armazenando os
40 bytes em algum lugar

263
00:13:08,600 --> 00:13:12,080
onde nós reservamos
40 bytes no valor da memória.

264
00:13:12,080 --> 00:13:15,970
Felizmente, nós já fizemos isso por
declarando arr, essa matriz à direita.

265
00:13:15,970 --> 00:13:19,770
Que é capaz de manter
10 unidades de quatro bytes.

266
00:13:19,770 --> 00:13:22,860
Assim, no total, ele pode armazenar 40
bytes pena de informação.

267
00:13:22,860 --> 00:13:26,540
E agora estamos lendo 40 bytes
de informações do arquivo,

268
00:13:26,540 --> 00:13:30,330
e nós estamos armazenando-o em arr.

269
00:13:30,330 --> 00:13:35,470
>> Lembre-se do vídeo em que os ponteiros
o nome de uma matriz, tal como arr,

270
00:13:35,470 --> 00:13:38,370
é realmente apenas um ponteiro
para o seu primeiro elemento.

271
00:13:38,370 --> 00:13:43,680
Então, quando nós passamos em arr lá, nós
são, na verdade, passando um apontador.

272
00:13:43,680 --> 00:13:46,120
>> Da mesma forma que podemos fazer isto--
Nós não necessariamente

273
00:13:46,120 --> 00:13:51,200
precisamos de salvar nossa tampão na pilha.

274
00:13:51,200 --> 00:13:54,990
Nós também poderíamos alocar dinamicamente
Um buffer como este, usando malloc.

275
00:13:54,990 --> 00:13:57,340
Lembre-se, quando
alocar dinamicamente a memória,

276
00:13:57,340 --> 00:14:00,550
estamos salvando-o no
heap, não a pilha.

277
00:14:00,550 --> 00:14:02,110
Mas ainda é um buffer.

278
00:14:02,110 --> 00:14:06,810
>> Ainda, neste caso, é
segurando 640 bytes de informação

279
00:14:06,810 --> 00:14:09,230
porque um casal ocupa oito bytes.

280
00:14:09,230 --> 00:14:11,570
E nós estamos pedindo 80 deles.

281
00:14:11,570 --> 00:14:13,770
Queremos ter espaço
para prender 80 quartos duplos.

282
00:14:13,770 --> 00:14:17,210
Então 80 vezes 8 é de 640 bytes de informação.

283
00:14:17,210 --> 00:14:21,880
E isso é chamada para fread
coleta de 640 bytes de informação

284
00:14:21,880 --> 00:14:27,770
a partir do arquivo apontado por
ptr e armazená-lo agora em arr2.

285
00:14:27,770 --> 00:14:32,770
>> Agora também podemos tratar fread
assim como uma chamada para fgetc.

286
00:14:32,770 --> 00:14:37,140
Neste caso, nós estamos apenas tentando
obter um personagem a partir do arquivo.

287
00:14:37,140 --> 00:14:40,070
E nós não precisamos de um
array para conter um personagem.

288
00:14:40,070 --> 00:14:43,170
Podemos simplesmente armazená-lo em
uma variável de caractere.

289
00:14:43,170 --> 00:14:46,390
>> O problema, porém, é que
quando só temos uma variável,

290
00:14:46,390 --> 00:14:50,290
precisamos passar na
endereço dessa variável

291
00:14:50,290 --> 00:14:52,550
pois lembre-se que o
primeiro argumento para fread

292
00:14:52,550 --> 00:14:59,210
é um ponteiro para a localização e memória
onde queremos armazenar as informações.

293
00:14:59,210 --> 00:15:01,550
Mais uma vez, o nome de um
array é um ponteiro.

294
00:15:01,550 --> 00:15:04,200
Então, nós não precisamos fazer matriz e comercial.

295
00:15:04,200 --> 00:15:07,270
Mas c, o personagem c
aqui, não é uma matriz.

296
00:15:07,270 --> 00:15:08,390
É apenas uma variável.

297
00:15:08,390 --> 00:15:11,840
E por isso precisamos passar um
c comercial para indicar

298
00:15:11,840 --> 00:15:15,350
que esse é o endereço de onde queremos
para armazenar este um byte de informação,

299
00:15:15,350 --> 00:15:20,479
este personagem que
estamos coletando de ptr.

300
00:15:20,479 --> 00:15:22,270
Fwrite-- eu vou passar por
este um pouco mais

301
00:15:22,270 --> 00:15:25,440
quickly-- é praticamente o
equivalente exato de fread

302
00:15:25,440 --> 00:15:27,720
exceto que é para a escrita
em vez de ler, apenas

303
00:15:27,720 --> 00:15:31,610
como o outro-- tivemos aberto
e próximo, obter um personagem,

304
00:15:31,610 --> 00:15:32,530
escrever um personagem.

305
00:15:32,530 --> 00:15:35,040
Agora é obter arbitrária
quantidade de informação,

306
00:15:35,040 --> 00:15:37,170
quantidade arbitrária direito de informação.

307
00:15:37,170 --> 00:15:39,790
Assim como antes, nós podemos
ter um array de 10 inteiros

308
00:15:39,790 --> 00:15:43,210
onde já temos
informação armazenada, talvez.

309
00:15:43,210 --> 00:15:46,580
>> Foi, provavelmente, algumas linhas de código
que deve ir entre estes dois

310
00:15:46,580 --> 00:15:49,990
onde eu preencher com arr
algo significativo.

311
00:15:49,990 --> 00:15:51,880
Eu preenchê-lo com 10 inteiros diferentes.

312
00:15:51,880 --> 00:15:54,920
E em vez disso, o que eu sou
fazendo está escrevendo a partir de arr

313
00:15:54,920 --> 00:15:58,600
e coletando as informações do arr.

314
00:15:58,600 --> 00:16:02,390
E eu estou tomando essa informação
e colocá-lo para o arquivo.

315
00:16:02,390 --> 00:16:05,410
>> Então, em vez de ser a partir de
o arquivo para o buffer,

316
00:16:05,410 --> 00:16:08,790
agora estamos indo de
o buffer para o arquivo.

317
00:16:08,790 --> 00:16:10,580
Então, é exatamente o contrário.

318
00:16:10,580 --> 00:16:16,680
Então, novamente, como antes, nós podemos
também têm um pedaço montão de memória

319
00:16:16,680 --> 00:16:19,600
que nós temos dinamicamente
alocados e lidos a partir desse

320
00:16:19,600 --> 00:16:21,570
e escrever que para o arquivo.

321
00:16:21,570 --> 00:16:24,900
>> E também temos uma única variável
capaz de manter um byte

322
00:16:24,900 --> 00:16:27,200
de informações, como um personagem.

323
00:16:27,200 --> 00:16:29,830
Mas, novamente, precisamos passar em
o endereço dessa variável

324
00:16:29,830 --> 00:16:31,840
quando queremos ler a partir dele.

325
00:16:31,840 --> 00:16:35,280
Assim, podemos escrever a informação
encontramos nesse endereço

326
00:16:35,280 --> 00:16:39,050
para o ponteiro de arquivo, ptr.

327
00:16:39,050 --> 00:16:41,630
>> Há muitas outras
grande arquivo I / O funções

328
00:16:41,630 --> 00:16:44,650
que fazer várias coisas além de
os que nós já conversamos sobre hoje.

329
00:16:44,650 --> 00:16:46,450
Um par de os
você pode achar útil

330
00:16:46,450 --> 00:16:50,840
são fgets e fputs,
que são o equivalente

331
00:16:50,840 --> 00:16:56,190
de fgetc e fputc mas para a leitura
uma única cadeia de caracteres de um arquivo.

332
00:16:56,190 --> 00:16:59,020
Em vez de um único personagem,
ele irá ler uma string inteira.

333
00:16:59,020 --> 00:17:02,940
fprintf, que basicamente permite
você usar printf para escrever no arquivo.

334
00:17:02,940 --> 00:17:05,619
Então, assim como você pode fazer o
a substituição de variáveis ​​usando

335
00:17:05,619 --> 00:17:09,900
a espaços reservados por cento i e
por cento d, e assim por diante, com printf

336
00:17:09,900 --> 00:17:14,690
você pode tomar de forma semelhante a
seqüência de printf e imprimir algo

337
00:17:14,690 --> 00:17:16,800
como que para um arquivo.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- se você tiver um leitor de DVD
é a analogia que eu costumo usar aqui--

339
00:17:20,720 --> 00:17:23,109
é uma espécie de como usar o seu
rebobinar e avançar rapidamente

340
00:17:23,109 --> 00:17:25,819
botões para movimentar o filme.

341
00:17:25,819 --> 00:17:28,369
Da mesma forma, você pode mover o arquivo.

342
00:17:28,369 --> 00:17:30,250
Uma das coisas dentro
que a estrutura de arquivo

343
00:17:30,250 --> 00:17:34,270
c que cria para você é um indicador
de onde você está no arquivo.

344
00:17:34,270 --> 00:17:36,420
Você está no muito
começando, no byte de zero?

345
00:17:36,420 --> 00:17:39,290
Você está em byte 100,
1000 bytes, e assim por diante?

346
00:17:39,290 --> 00:17:44,340
Pode utilizar fseek para mover arbitrariamente
esse indicador para a frente ou para trás.

347
00:17:44,340 --> 00:17:46,744
>> E ftell, novamente
semelhante a um leitor de DVD,

348
00:17:46,744 --> 00:17:49,660
é como um pequeno relógio que diz
quantos minutos e segundos você

349
00:17:49,660 --> 00:17:52,480
estão em um filme particular.

350
00:17:52,480 --> 00:17:56,990
Da mesma forma, ftell diz-lhe como
muitos bytes você está no arquivo.

351
00:17:56,990 --> 00:18:00,210
feof é uma versão diferente
de detectar se você tem

352
00:18:00,210 --> 00:18:01,700
chegou ao fim do ficheiro.

353
00:18:01,700 --> 00:18:03,600
E é uma função ferror
que você pode usar

354
00:18:03,600 --> 00:18:06,959
para detectar se alguma coisa tem
ido trabalho errado com um arquivo.

355
00:18:06,959 --> 00:18:08,750
Novamente, isso é apenas
arranhando a superfície.

356
00:18:08,750 --> 00:18:12,730
Ainda há muito mais arquivo I / O
funções do padrão io.h.

357
00:18:12,730 --> 00:18:16,620
Mas isso provavelmente vai te
começou a trabalhar com ponteiros de arquivo.

358
00:18:16,620 --> 00:18:17,640
Eu sou Doug Lloyd.

359
00:18:17,640 --> 00:18:19,750
Este é CS50.

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