Parte 6 - Arquivos (Parte 2) (PUC)

Prévia do material em texto

Prof. Edson J. R. Justino
Prof. Claudio Carvilhe
Parte 6
Pontifícia Universidade Católica do Paraná - PUCPR
ARQUIVOS EM C
� A biblioteca C oferece três categorias para 
manipulação de arquivos, que são:
� Alto Nível
São chamadas de buffered stream (rotinas de 
saída com área intermediária de memória) 
porque o buffer se interpõe entre o arquivo e o 
programa
� Médio Nível
São chamados de no buffered, porque o 
programa acessa o arquivo diretamente (através do sistema operacional SO). Não será
abordada nesse estudo.
� Baixo Nível
Usam níveis não portáveis do BIOS, não será
abordada nesse estudo.
ARQUIVOS EM C
� As rotinas de médio e alto nível possuem dois 
modos de manipulação de dados, o modo texto e 
o modo binário
� Modo texto
� É usado como arquivo texto, ou arquivos que armazenam 
texto no formato ASCII(programas fontes, etc.)
� Modo binário
� É usado em arquivos que armazenam dados na forma 
binária( imagens, sons, programas executáveis, etc.). 
� No modo texto, o caractere Ctrl+z (um byte 
contendo o valor 0x1A) é a marca de final de 
arquivo. 
� Nos arquivos binários Ctrl+z é uma parte legal (dado) do arquivo, o SO é quem guarda o 
tamanho do arquivo (no diretório).
ENTRADA E SAÍDA EM ALTO NÍVEL
� Todas as funções de I/O em alto nível, necessitam que 
se inicie o programa com #include <stdio.h>. Esse 
arquivo header, contém as definições para FILE, o tipo 
que se usa para manipular arquivos
#include <stdio.h>
.
.
FILE *fp;
sendo *fp um ponteiro para a estrutura do tipo FILE.
ENTRADA E SAÍDA EM ALTO NÍVEL
� Abrindo um arquivo
� Antes de você acessar um arquivo para leitura , 
gravação ou ambos, você deve inicialmente abrir o 
arquivo. Para as rotinas de I/O com buffers, você deve 
usar um ponteiro para o arquivo e abrir o mesmo com a 
função fopen( )
Ex:
fp = fopen(nomearq, operação);
Abrir p/ leitura, gravação ou ambos
path - nome do arquivo
ENTRADA E SAÍDA EM ALTO NÍVEL
� Tabela de operações
� Com a adição da letra b é possível manipular os arquivos 
binários. Ex. “rb”, “wb”, “ab”, “r+b”, “w+b” e “a+b”
modomodo DescriDescriççãoão
““rr”” Abre para leitura apenas. O arquivo deve existir.Abre para leitura apenas. O arquivo deve existir.
““ww”” Abre para gravaAbre para gravaçção apenas. Cria o arquivo se não existir e apaga o antigo se jão apenas. Cria o arquivo se não existir e apaga o antigo se jáá existir e existir e 
cria um novo.cria um novo.
““aa”” Abre para inclusão. Grava novos dados no final do arquivo.Abre para inclusão. Grava novos dados no final do arquivo.
““r+r+”” Abre para leitura/gravaAbre para leitura/gravaçção. O arquivo deve existir.ão. O arquivo deve existir.
““w+w+”” Abre para leitura/gravaAbre para leitura/gravaçção. Cria o arquivo se não existir e apaga se jão. Cria o arquivo se não existir e apaga se jáá existir criando um existir criando um 
novo.novo.
““a+a+”” Abre para leitura/gravaAbre para leitura/gravaçção, Grava novos dados no final do arquivo. Cria um novo arquivo ão, Grava novos dados no final do arquivo. Cria um novo arquivo 
se não existir.se não existir.
ENTRADA E SAÍDA EM ALTO NÍVEL
� Cada arquivo aberto requer um ponteiro 
para si
#include <stdio.h>
.
.
FILE *fp_in, *fp_out;
.
.
fp_in = fopen("teste.txt","r");
fp_out = fopen("teste2.txt","w");
LENDO UM CARACTER DO ARQUIVO
� O fgetc( ) é uma versão para arquivo da 
função getchar( )
� Ela retorna o próximo caractere lido do 
arquivo
� Usando uma variável do tipo inteiro 
podemos identificar o final de arquivo 
facilmente.
LENDO UM BYTE DO ARQUIVO
if((ch= fgetc(fp)) == EOF)
{
/* Se for o final do arquivo */
}
� A chamada para fopen( ) com o operador "rb" :
fp = fopen(“nome do arquivo”, "rb")
é uma declaração específica do PC. O "rb" 
habilita a abertura de arquivo binários
LENDO UM CARACTER DO ARQUIVO
� Tabela de definições
modomodo DescriDescriççãoão
tt texttext modemode -- converte converte carriegecarriege returnreturn//lineline feedfeed em um em um lineline feedfeed na leitura e o na leitura e o 
contrcontráário na gravario na gravaçção. ão. CtrlCtrl+z+z éé a marca de final de arquivo.a marca de final de arquivo.
bb binarybinary modemode -- Elimina as conversões. O sistema operacional guarda o Elimina as conversões. O sistema operacional guarda o 
tamanho do arquivo.tamanho do arquivo.
FECHANDO ARQUIVOS
� Você deve fechar cada arquivo aberto após o 
uso.
� Fechar um arquivo aberto para escrita significa 
atualizar a entrada do diretório para o arquivo e 
liberar o ponteiro de arquivo.
if ( fclose(fp) == EOF)
{
/* Não habilitado p/ fechamento */
}
Exemplo de leitura de arquivo 
texto
/****************************************
Lista um arquivo texto
****************************************/
#include <stdio.h> /* para FILE e EOF */
#include <stdlib.h>
int main() {
FILE *fp;
int ch;
char nome_arquivo[50];
printf("entre com o caminho e nome do arquivo\n");
scanf("%s", nome_arquivo); fflush(stdin);
if ((fp = fopen(nome_arquivo,"rt")) == NULL){
printf("Não abriu %s\n",nome_arquivo);
system("PAUSE");
return(-1);
}
while ((ch = fgetc(fp)) != EOF){
printf("%c", ch);
}
if ( fclose(fp) == EOF)
printf("arquivo não pode ser fechadio\n");
system("PAUSE");
return 0;
}
GRAVANDO UM BYTE NO ARQUIVO
� A função fputc() grava um byte em um 
arquivo
#include <stdio.h> 
FILE *f_out;
Int c;
If ( fputc(int c, f_out) == EOF) {
/* se ocorrer erro de gravação */
} 
Exemplo de gravação de arquivo texto
/* Copiar um arquivo binário ou texto */
#include <stdio.h> /* para FILE e EOF */
#include <stdlib.h>
int main() {
FILE *f_in, *f_out; 
int ch; 
char arquivo_origem[50], arquivo_destino[50];
printf("entre com o arquivo de origem: ");
scanf("%s", arquivo_origem); fflush(stdin);
printf("entre com o arquivo de destino: ");
scanf("%s", arquivo_destino); fflush(stdin);
if ((f_in = fopen(arquivo_origem,"rb")) == NULL){
printf("Não abriu arquivo origem: %s\n",arquivo_origem);
system("PAUSE");
return(-1);
}
if ((f_out = fopen(arquivo_destino,"wb")) == NULL){
printf("Não abriu arquivo de destino: %s\n",arquivo_destino);
system("PAUSE");
return(-1);
}
while ((ch = fgetc(f_in)) != EOF)
if (fputc(ch, f_out) == EOF){
printf("Erro na escrita do arquivo de saida\n");
system("PAUSE");
return (-2);
} 
if ( fclose(f_in) == EOF)
printf("arquivo origem nao pode ser fechado\n");
if ( fclose(f_out) == EOF)
printf("arquivo destino nao pode ser fechado\n");
system("PAUSE");
return 0;
}
Funções
� Existe uma função particular chamada main(), que normalmente 
não recebe parâmetros de entrada, mas isso pode ocorrer. A 
característica principal, que a difere das demais funções, está no 
uso de dois parâmetro, argv e argc.
� Quando você executa programas no ambiente do 
interpretador de comando do S.O., você pode especificar 
argumentos a serem passador para o programa que será
executado.
Ex. copy a:\meu.doc c:\
No exemplo, o programa copy recebe dois path como 
argumento, (a:\meu.doc) e (c:\). A função main do programa 
copy ,seria:
void main( int argc, char *argv[] )
Funções
� O argumento argc contém o número de parâmetros 
passados como argumento. O contador de argumento inclui 
também o nome do próprio programa. Já argv[ ] é um vetor 
de strings, que contém as cadeias de caracteres passadas 
como parâmetros.
Ex:
copy a:\meu.doc c:\
argc = 3
argv[0] = “copy”
argv[1] = “a:\meu.doc”
argv[2] = “c:\”
argv[3] = NULL
Funções
#include <stdio.h>
void main( int argc, char *argv[]){
int i;
printf(“argc = %d\n”,argc);
printf(“\n”);
for (i= 0; i <= argc ;++i){
printf(“argv[%d] -> \”%s\”\n”,i, 
argv[i]);
}
printf(“\n”);
}
copycopy a:a:\\meu.doc c:meu.docc:\\
argcargc = 3= 3
argvargv[0] = [0] = ““copycopy””
argvargv[1] = [1] = ““a:a:\\meu.docmeu.doc””
argvargv[2] = [2] = ““c:c:\\””
argvargv[3] = NULL[3] = NULL
Exemplo
/****************************************/****************************************
Lista um arquivo texto Lista um arquivo texto –– comando comando typetype do DOS do DOS 
****************************************/****************************************/
#include <#include <stdiostdio.h> .h> /* para FILE e EOF *//* para FILE e EOF */
intint mainmain((intint argcargc,,charchar **argvargv[]) {[]) {
FILE *FILE *fpfp;;
intint chch;;
ifif ((argcargc != 2){!= 2){
fprintffprintf((stderrstderr,","Formato: MOSTRE [Unidade:][Caminho]ARQUIVOTEXTOFormato: MOSTRE [Unidade:][Caminho]ARQUIVOTEXTO\\nn");");
returnreturn((--1);1);
}}
ifif ((((fpfp = = fopenfopen((argvargv[1],"[1],"rbrb")) == NULL){")) == NULL){
fprintffprintf((stderrstderr,","Arquivo de entrada invalido: %sArquivo de entrada invalido: %s\\nn",",argvargv[1]);[1]);
returnreturn((--2);2);
}}
whilewhile ((((chch = = fgetcfgetc((fpfp)) != EOF){)) != EOF){
printfprintf("%c", ("%c", chch););
}}
}}
Exercícios
� 1) Elabore um programa em C para contar 
o número de letras “A” contidas num 
arquivo texto.
� 2) Elabore um programa em C para contar 
o número de incidências de uma letra 
qualquer em um arquivo.
� 3) Elabore um programa em C para contar 
o número de caracteres de um arquivo.
� 4) Elabore um programa em C para contar 
o número de letras (a-z; A-Z) em um 
arquivo.
Exercícios
� 5) Elabore um programa em C para contar 
o número de linhas em determinado 
arquivo.
� 6) Elabore um programa em C para contar 
o número de palavras em determinado 
arquivo.
� 7) Elabore um programa em C que efetue 
a cópia de um arquivo. Em linha de 
comando, deve ser possível efetuar a 
seguinte linha de programação:
repeat original.txt copia.txt
Exercícios
� 7) (Continuação) Para tal, deve o 
programa deve receber os 3 argumentos, 
sendo que o argumento 1 é o arquivo texto 
de origem, e o argumento 2 é o arquivo 
texto que consistirá na cópia exata do 
primeiro.
� 8) Construa um programa que grave uma 
cópia de determinado arquivo codificado 
(Defina o critério de codificação. Exemplo: 
Cada caracter do arquivo gravado 
consistirá no complemento do caracter
original)
Exercícios
� 9) Com base no exercício anterior. Efetue 
a leitura de um arquivo codificado e exiba 
o caracter correto na tela.
� 10) Modifique a codificação (dos exercícios 
8 e 9) de acordo com o critério que segue. 
� Seu texto deve ser “criptografado” da 
seguinte maneira: O bit 1 e o bit 5 de cada 
caracter, deve ter seu valor invertido (de 0 
para 1 ou vice-versa).