ARQUIVOS

Abrindo e Fechando um Arquivo

• fopen
• exit
• fclose

No sistema de entrada e saída ANSI é definido o tipo "ponteiro de arquivo". Esta

definição está no arquivo cabeçalho stdio.h ou stdlib.h dependendo do seu compilador.
Podemos declarar um ponteiro de arquivo da seguinte maneira:
FILE *p;
p será então um ponteiro para um arquivo. É usando este tipo de ponteiro que vamos
poder manipular arquivos no C.

fopen
Esta é a função de abertura de arquivos. Seu protótipo é:
FILE *fopen (char *nome_do_arquivo,char *modo);

O nome_do_arquivo determina qual arquivo deverá ser aberto. Este nome deve ser
válido no sistema operacional que estiver sendo utilizado. O modo de abertura diz à
função fopen() que tipo de uso você vai fazer do arquivo. A tabela abaixo mostra os
valores de modo válidos:

Modo Significado
"r" Abre um arquivo para leitura
"w" Cria um arquivo para escrita
"a" Acrescenta dados no fim do arquivo ("append")
"rb" Abre um arquivo binário para leitura
"wb" Cria um arquivo binário para escrita
"ab" Acrescenta dados binários no fim do arquivo
"r+" Abre um arquivo para leitura e escrita
"w+" Cria um arquivo para leitura e escrita
"a+" Acrescenta dados ou cria uma arquivo para leitura e escrita
"r+b" Abre um arquivo binário para leitura e escrita
"w+b" Cria um arquivo binário para leitura e escrita
"a+b" Acrescenta dados ou cria uma arquivo binário para leitura e escrita
"rt" Abre um arquivo texto para leitura
"wt" Cria um arquivo texto para escrita
"at" Acrescenta dados no fim do arquivo texto
"r+t" Abre um arquivo texto para leitura e escrita
"w+t" Cria um arquivo texto para leitura e escrita
"a+t" Acrescenta dados ou cria uma arquivo texto para leitura e escrita
Poderíamos então, para abrir um arquivo binário, escrever:
FILE *fp;
fp=fopen ("exemplo.bin","wb");
if (!fp)
printf ("Erro na abertura do arquivo.");

A condição !fp testa se o arquivo foi aberto com sucesso porque no caso de um erro a
função fopen() retorna um ponteiro nullo (NULL).

exit
Aqui abrimos um parênteses para explicar a função exit() cujo protótipo é:
void exit (int codigo_de_retorno);

Esta função aborta a execução do programa. Pode ser chamada de qualquer ponto no
programa e faz com que o programa termine e retorne, para o sistema operacional, o
código_de_retorno. A convenção mais usada é que um programa retorne zero no caso
de um término normal e retorne um número não nulo no caso de ter ocorrido um
problema. A função exit() se torna importante em casos como alocação dinâmica e
abertura de arquivos pois pode ser essencial que uma determinada memória seja alocada
ou que um arquivo seja aberto. Poderíamos reescrever o exemplo da seção anterior
usando agora o exit() para garantir que o programa executará se o arquivo não for
aberto:
#include <stdio.h
main (void)
{
FILE *fp;
...
fp=fopen ("exemplo.bin","wb");
if (!fp)
{
printf ("Erro na abertura do arquivo. Fim de programa.");
exit (1);
}
...
return 0;
}

fclose
Quando abrimos um arquivo devemos fechá-lo. Para tanto devemos usar a função
fclose():
int fclose (FILE *fp);
É importante que se perceba que se deve tomar o maior cuidado para não "perder" o
ponteiro do arquivo. "Perder" neste caso seria atribuir um valor de um outro ponteiro
qualquer ao ponteiro de arquivo (perdendo assim o valor original). É utilizando este
ponteiro que vamos poder trabalhar com o arquivo. Se perdermos o ponteiro de um
determinado arquivo não poderemos nem fechá-lo. O ponteiro fp passado à função
fclose() determina o arquivo a ser fechado. A função retorna zero no caso de sucesso.
Lendo e Escrevendo Caracteres em Arquivos
• putc
• getc
• feof

putc
Toda vez que estamos trabalhando com arquivos, há uma espécie de posição atual no
arquivo. Esta posição, gerenciada pelo compilador, é a posição de onde será lido ou
escrito o próximo caracter. Normalmente, num acesso sequencial a um arquivo, não
temos que mexer nesta posição pois quando lemos um caractere a posição no arquivo é
automaticamente atualizada. Num acesso randômico teremos que mexer nesta posição
(ver fseek()). Protótipo:
int putc (int ch,FILE *fp);
Escreve um caracter no arquivo.

getc
Retorna um caracter lido do arquivo. Protótipo:
int getc (FILE *fp);

feof
EOF ("End of file") indica o fim de um arquivo. Às vezes, é necessário verificar se um
arquivo chegou ao fim. Para isto podemos usar a função feof(). Ela retorna não-zero se
o arquivo chegou ao EOF, caso contrário retorna zero. Seu protótipo é:
int feof (FILE *fp);
A seguir é apresentado um programa onde várias operações com arquivos são
realizadas. Primeiro o arquivo é aberto para a escrita, e imprime-se algo nele. Em
seguida, o arquivo é fechado e novamente aberto para a leitura. Verifique o exemplo.
#include <stdio.h
#include <stdlib.h
#include <string.h

void main()
{
FILE *p;
char c, str[30], frase[80] = "Este e um arquivo chamado: ";
int i;
/* Le um nome para o arquivo a ser aberto: */
printf("\n\n Entre com um nome para o arquivo:\n");
gets(str);

if (!(p = fopen(str,"w"))) /* Caso ocorra algum erro na abertura do

arquivo..*/
{ /* o programa aborta automaticamente */
printf("Erro! Impossivel abrir o arquivo!\n");
exit(1);
}
/* Se nao houve erro, imprime no arquivo, fecha ...*/
strcat(frase, str);
for (i=0; frase[i]==´\0´; i++)
 putc(frase[i],p);
fclose(p);

/* abre novamente para a leitura e fecha. */

p = fopen(str,"r");
while (!feof(p))
{
c = getc(p);
printf("%c",c);
}
fclose(p);
}

Fluxos Padrão
• fprintf
• fscanf

Os fluxos padrão em arquivos permitem ao programador ler e escrever em arquivos da

maneira padrão com a qual o programador já lia e escrevia na tela.
fprintf
A função fprintf() funciona como a função printf(). A diferença é que a saída de
fprintf() é um arquivo e não a tela do computador. Protótipo:

int fprintf (FILE *fp,char *str,...);

Como já poderíamos esperar, a única diferença do protótipo de fprintf() para o de

printf() é a especificação do arquivo destino através do ponteiro de arquivo.
fscanf
A função fscanf() funciona como a função scanf(). A diferença é que fscanf() lê de um
arquivo e não da tela do computador. Protótipo:

int fscanf (FILE *fp,char *str,...);

Como já poderíamos esperar, a única diferença do protótipo de fscanf() para o de

scanf() é a especificação do arquivo destino através do ponteiro de arquivo.
Talvez a forma mais simples de escrever o programa do capítulo 9.6 seja usando fprintf
() e fscanf(). Fica assim:
#include <stdio.h>
#include <stdlib.h>
void main()
{
FILE *p;
char str[80],c;

/* Le um nome para o arquivo a ser aberto: */

printf("\n\n Entre com um nome para o arquivo:\n");
gets(str);

if (!(p = fopen(str,"w"))) /* Caso ocorra algum erro na abertura do

arquivo..*/
{ /* o programa aborta automaticamente */
printf("Erro! Impossivel abrir o arquivo!\n");
 exit(1);
}
/* Se nao houve erro, imprime no arquivo, fecha ...*/
fprintf(p,"Este e um arquivo chamado:\n%s\n", str);
fclose(p);

/* abre novamente para a leitura e fecha. */

p = fopen(str,"r");
while (!feof(p))
{
fscanf(p,"%c",&c);
printf("%c",c);
}
fclose(p);
}

Outros Comandos de Acesso a Arquivos

• ferror
• rewind
• getw
• putw
• fgets
• fputs
• fread
• fwrite
• fseek
• remove

ferror
Protótipo:
int ferror (FILE *fp);
A função ferror() se torna muito útil quando queremos verificar se cada acesso a um
arquivo teve sucesso. Cada vez que uma função de arquivo é executada, a própria
função registra numa variável especial se houve sucesso na operação ou não. Com
ferror() podemos ter acesso ao conteúdo desta variável: ela retorna não zero se houve
algum erro na última função de acesso ao arquivo.

rewind
A função rewind() de protótipo
void rewind (FILE *fp);
retorna a posição corrente do arquivo para o início.

getw
getw() lê no arquivo um inteiro. Seu protótipo é:
int getw (FILE *fp);

putw
putw() escreve um inteiro num arquivo. Protótipo:
int putw (int i,FILE *fp);
fgets
Para se ler uma string num arquivo podemos usar fgets() cujo protótipo é:
char *fgets (char *str,int tamanho,FILE *fp);
A string str lida deve ter seu tamanho determinado pelo programador.

fputs
Protótipo:
char *fputs (char *str,FILE *fp);
Escreve uma string num arquivo.

fread
Podemos escrever e ler blocos de dados. Para tanto temos as funções fread() e fwrite().
O protótipo de fread() é:
unsigned fread (void *buffer,int numero_de_bytes,int count,FILE
*fp);
O buffer é a região de memória na qual serão armazenados os dados lidos. O número de
bytes é o tamanho da unidade a ser lida. O contador indica quantas unidades devem ser
lidas. Isto significa que o número total de bytes lidos é:
numero_de_bytes*count
A função retorna o número de unidades efetivamente lidas. Este número pode ser menor
que o valor requisitado quando o fim do arquivo for encontrado.

fwrite
A função fwrite() funciona como a sua companheira fread(). Seu protótipo é:
unsigned fwrite(void *buffer,int numero_de_bytes,int count,FILE
*fp);
fseek
Para se fazer procuras e acessos randômicos usa-se a função fseek(). Esta move o cursor
no arquivo de um valor especificado, a partir de um ponto especificado. Seu protótipo é:
int fseek (FILE *fp,long numbytes,int origem);
O parâmetro de origem determina a partir de onde é que os bytes de movimentação
serão contados. Os valores possíveis são definidos por macros no arquivo cabeçalho e
são:

Nome Valor Significado

SEEK_SET 0 Início do arquivo
SEEK_CUR 1 Ponto corrente no arquivo
SEEK_END 2 Fim do arquivo

Tendo-se definido a partir de onde irá se contar numbytes determina quantos bytes de
deslocamento será dado na posição atual.

remove
Protótipo:
 int remove (char *nome_do_arquivo);
Desmancha um arquivo especificado.
O exercício anterior poderia ser reescrito usando-se, por exemplo, fgets() e fputs(), ou
fwrite() e fread(). A seguir apresentamos uma segunda versão que se usa das funções
fgets() e fputs(), e que acrescenta algumas inovações.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void main()
{
FILE *p;
char str[30], frase[80] = "Este e um arquivo chamado: ", resposta[80];
int i;
/* Le um nome para o arquivo a ser aberto: */
printf("\n\n Entre com um nome para o arquivo:\n");
gets(str);

if (!(p = fopen(str,"w"))) /* Caso ocorra algum erro na abertura do arquivo..*/

{ /* o programa aborta automaticamente */
printf("Erro! Impossivel abrir o arquivo!\n");
exit(1);
}
/* Se nao houve erro, imprime no arquivo, fecha ...*/
fputs(frase, p);
fputs(str,p);
/* E se o seu disco estiver muito cheio.. */
if (ferror(p)) printf("\nNem tudo sao flores...\n");
fclose(p);

strcat(frase, str);
/* abre novamente para a leitura e fecha. */
p = fopen(str,"r");
fgets(resposta, strlen(frase)+1, p);
printf("\n\n%s\n", resposta);
fclose(p);
remove(str);
}