Arquivo ALGORITMO DE PROGRAMAÇÃO

Prévia do material em texto

Arquivos
Arquivo
●Sequência de informações binárias
armazenadas num dispositivo de
armazenamento permanente
●Em geral os bits são agrupados em grupos
de 8 (1 byte)
●Apesar da organização física sequencial dos
bytes no arquivo, podemos em cima desta
organização básica implementar outros tipos
de estruturação para uma arquivo
Trabalhando com arquivos
Manipular um arquivo consiste em realizar 3 
atividades básicas:
●Criar / abrir o arquivo
●Ler / escrever no arquivo
●fechar o arquivo
Criando / abrindo um arquivo
● Para criar ou abrir um arquivo já existente no disco, precisamos, 
primeiro, criar uma variável e associá-la ao arquivo no disco.
● Esta variável é também chamada de manipulador de arquivo ou 
identificador de fluxo.
● Para criar um manipulador de arquivo, usamos o tipo FILE definido 
na biblioteca stdio.h.
Ex:
FILE *arq;
FILE *arquivoEntrada, *arquivoSaida;
Criando / abrindo um arquivo
● Para associar a variável ao arquivo em disco e criar/abrir o arquivo, 
usamos o comando fopen.
FILE *fopen (char *nome_do_arquivo, char *modo_de_acesso);
Onde:
● nome_do_arquivo → string com o caminho do 
arquivo que se deseja abrir/criar. Pode ser 
usado o caminho completo 
(“c:/dir1/dir2/nomeArquivo.ext“) ou o caminho 
relativo (“nomeArquivo.ext” ou 
../outroDiretorio/nomeArquivo.ext”)
● modo_de_acesso → string que determina se o 
arquivo será criado ou só aberto e quais 
operações poderão ser executadas no arquivo 
(só leitura, só gravação etc)
Criando / abrindo um arquivo
● modo_de_acesso → string que determina se o 
arquivo será criado ou só aberto e quais 
operações poderão ser executadas no arquivo 
(só leitura, só gravação etc)
Modo
Significado
r Abre o arquivo somente para leitura. O arquivo deve existir. (O r vem do inglês 
read, ler)
r+ Abre o arquivo para leitura e escrita. O arquivo deve existir.
w Abre o arquivo somente para escrita no início do arquivo. Apagará o conteúdo do 
arquivo se ele já existir, criará um arquivo novo se não existir. (O w vem do inglês 
write, escrever)
w+ Abre o arquivo para escrita e leitura, apagando o conteúdo pré-existente.
a Abre o arquivo para escrita no final do arquivo. Não apaga o conteúdo pré-
existente. (O a vem do inglês append, adicionar, apender)
a+ Abre o arquivo para escrita no final do arquivo e leitura.
Criando / abrindo um arquivo
Ex:
FILE *arq;
FILE *arquivoEntrada, *arquivoSaida;
arq = fopen(“texto.txt”, “w”);
arquivoEntrada = fopen(“../dados/dados.dat”, “r”);
arquivoSaida = fopen(“../dados/dadosSaida.dat”, “r”);
Fechando um arquivo
● Para fechar um arquivo usamos o comando fclose.
int fclose (FILE *manipulador_de_arquivo);
Ex:
fclose(arq);
fclose(arquivoEntrada);
fclose(arquivoSaida);
Escrevendo num arquivo
Uma vez aberto o arquivo num modo que permita gravação, 
podemos usar um dos comandos abaixo para realizar esta 
operação:
Comandos Explicação Sintaxe
fputc Imprime apenas um caractere. void fputc (int caractere, FILE *fluxo);
fputs Imprime uma string diretamente, 
sem nenhuma formatação.
void fputs (char *string, FILE *fluxo);
fprintf Imprime uma string formatada. void fprintf (FILE *fluxo, char *formatação, 
...);
fwrite Grava dados binários para um 
arquivo.
int fwrite (void *dados, int 
tamanho_do_elemento, int 
num_elementos, FILE *fluxo);
Escrevendo num arquivo - exemplo
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
main(){
char caracter;
FILE *arq;
arq=fopen("teste.txt","w+");
caracter=getche();
while(caracter!=27){
if(caracter ==13){
printf("\n");
fputc(10, arq);
}
fputc(caracter, arq);
caracter=getche();
}
fclose(arq);
}
●Neste programa todos os caracteres digitados pelo usuário são gravados no arquivo 
“teste.txt”.
●O programa termina quando o usuário digita ”esc” que tem valor 27 segundo a tabela 
ASCII.
●A organização deste arquivo é sequencial, com um caracter (byte) gravado logo após 
o anterior.
Lendo de um arquivo
Uma vez aberto o arquivo num modo que permita a leitura, 
podemos usar um dos comandos abaixo para realizar esta 
operação:
Comandos Explicação Sintaxe
fgetc Recebe apenas um caractere. int fgetc (FILE *fluxo);
fgets Lê uma string (geralmente uma linha 
inteira).
void fgets (char *string, int tamanho, 
FILE *fluxo);
fscanf Recebe uma string formatada. void fscanf (FILE *fluxo, char 
*formatação, ...);
fread Lê dados binários de um arquivo. int fread (void *dados, int 
tamanho_do_elemento, int 
num_elementos, FILE *fluxo);
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
main(){
char caracter;
FILE *arq;
arq=fopen("teste.txt","r");
caracter=fgetc(arq);
while(!feof(arq)){
printf("%c", caracter);
_sleep(100);
caracter=fgetc(arq);
}
fclose(arq);
system("pause");
}
Lendo de um arquivo - exemplo
●No programa ao lado todo o arquivo será lido e mostrado na tela, caracter a 
caracter.
●A leitura termina quando o fim de arquivo é encontrado.
●Para testar se o fim de arquivo já foi encontrado, usamos a função feof que retorna 
verdadeiro quando o fim de arquivo é encontrado e falso caso contrário.
Uso de registro para organizar um 
arquivo
●Podemos organizar um arquivo como uma
sequência de registros (structs).
●Neste caso, uma variável do tipo struct deve ser
usada para gravar ou ler os dados do arquivo.
Ex:
struct tpessoa{
char nome[20];
int idade, mesAniversario;
}reg;
____
fwrite(&reg, sizeof(struct tpessoa), 1, arq);
A função sizeof devolve o
tamanho da estrutura ou
variável passada por parâmetro
Uso de registro para organizar um 
arquivo - Exemplo
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>
struct tReg{
char nome[30];
int idade, mesAniversario;
};
main(){
struct tReg reg;
FILE *arq;
arq=fopen("Dados.dat","w+");
printf("nome: ");
scanf("%s", reg.nome);
while(strcmp(reg.nome, "fim")!=0){
printf("idade: ");
scanf("%d", &reg.idade);
printf("Mes de aniversario: ");
scanf("%d", &reg.mesAniversario);
fwrite(&reg, sizeof(struct tReg), 1, arq);
printf("nome: ");
scanf("%s", reg.nome);
●No programa ao lado, os dados são recebido 
pelo teclado e organizados no registro reg.
●Uma vez preenchidos os campos, os dados são 
gravados em arquivo um campo após o outro. 
Cada campo terá sempre o mesmo tamanho para 
todos os registros do arquivo.
●Os registros terão, portanto, tamanho fixo.
●A entrada de dados termina quando o usuário 
digita “fim” como nome da pessoa.
●O arquivo é organizado como uma sequência de 
registros do tipo tReg.
Uso de registro para organizar um 
arquivo – Exemplo 2
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>
struct tReg{
char nome[30];
int idade, mesAniversario;
};
main(){
struct tReg reg;
FILE *arq;
arq=fopen("Dados.dat","r");
fread(&reg, sizeof(struct tReg), 1, arq);
while(!feof(arq)){
printf("nome: %s\n", reg.nome);
printf("idade: %d\n", reg.idade);
printf("Mes de aniversario: %d\n", reg.mesAniversario);
_sleep(1000);
fread(&reg, sizeof(struct tReg), 1, arq);
}
fclose(arq);
}
●No programa ao lado, os dados são recebido do 
arquivo no registro reg.
●O registro reg tem que ser do mesmo tipo do 
programa anterior, usado para gravar os dados no 
disco.
Arquivo – acesso direto
●Uma vez que usamos registros de tamanho
fixo para organizar o arquivo, podemos
contar com o recurso do índice para ir
diretamente a uma posição do arquivo.
●Para tanto devemos multiplicar o índice
desejado pelo tamanho da estrutura.
●O tamanho da estrutura pode ser
conseguido usando a função sizeof vistaanteriormente.
●O comando usado para saltar para uma
determinada posição é o fseek.
Arquivo – acesso direto
fseek → função que permite posicionarmos o cursor do arquivo num ponto 
específico do arquivo.
int fseek (FILE *fp,long numbytes,int origem);
Onde:
fp → manipulador do arquivo
numbytes → quantidades de bytes a saltar (se numbytes>0, salta para a 
direita, senão salta para a esquerda)
origem → define a partir de que ponto o salto acontecerá. Podem ser usadas 
as constantes SEEK_SET, SEEK_CUR ou SEEK_END, 
conforme definido na tabela abaixo:
Constante Valor Significado
SEEK_SET 0 Início do arquivo
SEEK_CUR 1 Ponto corrente no arquivo
SEEK_END 2 Fim do arquivo
Arquivo – acesso direto - Exemplo
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>
struct tReg{
char nome[30];
int idade, mesAniversario;
};
main(){
struct tReg reg;
int numReg;
FILE *arq;
arq=fopen("Dados.dat","r");
printf(“Digite o numero do registro: “);
scanf(“%d”, &numReg);
fseek(arq,numReg*sizeof(struct tReg), SEEK_SET); 
fread(&reg, sizeof(struct tReg), 1, arq);
printf("nome: %s\n", reg.nome);
printf("idade: %d\n", reg.idade);
printf("Mes de aniversario: %d\n", reg.mesAniversario);
fclose(arq);
Arquivo – Modificando um registro
Para alterar o valor de um campo num registro de um arquivo 3 operações devem ser realizads:
●Leitura do registro. → quando o registro é levado do disco à memória principal.
●Modificação do valor no registro em memória
●regravação do registro no disco na mesma posição em que se encontrava.
●Observação:
●Ao ler o rgistro, o ponteiro do arquivo se posicionará no registro seguinte
●É necessário reposicionar o ponteiro do arquivo realizando um fseek a partir da posição corrente.
Ex:
fread(&reg, sizeof(struct tReg), 1, arq);
reg.idade++;
fseek(arq, -1*sizeof(struct tReg), SEEK_CUR);
fwrite(&reg, sizeof(struct tReg), arq);