sábado, julho 09, 2011

Aula 9 - Entradas e Saídas Padronizadas

Introdução
O sistema de entrada e saída da linguagem C está estruturado na forma de uma biblioteca de funções . Já vimos algumas destas funções, e agora elas serão reestudadas. Novas funções também serão apresentadas.
Não é objetivo deste curso explicar, em detalhes, todas as possíveis funções da biblioteca de entrada e saída do C. A sintaxe completa destas funções pode ser encontrada no manual do seu compilador. Alguns sistemas trazem um descrição das funções na ajuda do compilador, que pode ser acessada "on line". Isto pode ser feito, por exemplo, no Rhide.
Um ponto importante é que agora, quando apresentarmos uma função, vamos, em primeiro lugar, apresentar o seu protótipo. Você já deve ser capaz de interpretar as informações que um protótipo nos passa. Se não, deve voltar a estudar a aula sobre funções.
Outro aspecto importante, quando se discute a entrada e saída na linguagem C é o conceito de fluxo. Seja qual for o dispositivo de entrada e saída (discos, terminais, teclados, acionadores de fitas) que se estiver trabalhando, o C vai enxergá-lo como um fluxo, que nada mais é que um dispositivo lógico de entrada ou saída. Todos os fluxos são similares em seu funcionamento e independentes do dispositivo ao qual estão associados. Assim, as mesmas funções que descrevem o acesso aos discos podem ser utilizadas para se acessar um terminal de vídeo. Todas as operações de entrada e saída são realizadas por meio de fluxos.
Na linguagem C, um arquivo é entendido como um conceito que pode ser aplicado a arquivos em disco, terminais, modens, etc ... Um fluxo é associado a um arquivo através da realização de uma operação de abertura. Uma vez aberto, informações podem ser trocadas entre o arquivo e o programa. Um arquivo é dissociado de um fluxo através de uma operação de fechamento de arquivo.

Lendo e Escrevendo Caracteres

Uma das funções mais básicas de um sistema é a entrada e saída de informações em dispositivos. Estes podem ser um monitor, uma impressora ou um arquivo em disco. Vamos ver os principais comandos que o C nos fornece para isto.

- getche e getch

As funções getch() e getche() não são definidas pelo padrão ANSI. Porém, elas geralmente são incluídas em compiladores baseados no DOS, e se encontram no header file conio.h. Vale a pena repetir: são funções comuns apenas para compiladores baseados em DOS e, se você estiver no UNIX normalmente não terá estas funções disponíveis.

Protótipos:
                int getch (void);
                int getche (void);
getch() espera que o usuário digite uma tecla e retorna este caractere. Você pode estar estranhando o fato de getch() retornar um inteiro, mas não há problema pois este inteiro é tal que quando igualado a um char a conversão é feita corretamente. A função getche() funciona exatamente como getch(). A diferença é que getche() gera um "echo" na tela antes de retornar a tecla.
Se a tecla pressionada for um caractere especial estas funções retornam zero. Neste caso você deve usar as funções novamente para pegar o código da tecla extendida pressionada.
A função equivalente a getche() no mundo ANSI é o getchar(). O problema com getchar é que o caracter lido é colocado em uma área intermediária até que o usuário digite um , o que pode ser extremamente inconveniente em ambientes interativos.

- putchar

Protótipo:
                int putchar (int c);
putchar() coloca o caractere c na tela. Este caractere é colocado na posição atual do cursor. Mais uma vez os tipos são inteiros, mas você não precisa se preocupar com este fato. O header file é stdio.h.

Lendo e Escrevendo Strings

- gets

Protótipo:
                char *gets (char *s);
Pede ao usuário que entre uma string, que será armazenada na string s. O ponteiro que a função retorna é o próprio s. gets não é uma função segura. Por quê? Simplesmente porque com gets pode ocorrer um estouro da quantidade de posições que foi especificada na string . Veja o exemplo abaixo:
#include
int main()
{
    char buffer[10];
    printf("Entre com o seu nome");
    gets(buffer);
    printf("O nome é: %s", buffer);
    return 0;
}


Se o usuário digitar como entrada:
Renato Cardoso Mesquita
ou seja, digitar um total de 23 caracteres: 24 posições (incluindo o '\0' ) serão utilizadas para armazenar a string. Como a string buffer[] só tem 10 caracteres, os 14 caracteres adicionais serão colocados na área de memória subsequente à ocupada por ela, escrevendo uma região de memória que não está reservada à string. Este efeito é conhecido como "estouro de buffer" e pode causar problemas imprevisíveis. Uma forma de se evitar este problema é usar a função fgets, conforme veremos posteriormente 

- puts

Protótipo:
                int puts (char *s);
puts() coloca a string s na tela.
AUTO AVALIAÇÃO
Veja como você está. Escreva um programa que leia nomes pelo teclado e os imprima na tela. Use as funções puts e gets para a leitura e impressão na tela.

Entrada e Saída Formatada

As funções que resumem todas as funções de entrada e saída formatada no C são as funções printf() e scanf(). Um domínio destas funções é fundamental ao programador.

- printf

Protótipo:
                int printf (char *str,...);
As reticências no protótipo da função indicam que esta função tem um número de argumentos variável. Este número está diretamente relacionado com a string de controle str, que deve ser fornecida como primeiro argumento. A string de controle tem dois componentes. O primeiro são caracteres a serem impressos na tela. O segundo são os comandos de formato. Como já vimos, os últimos determinam uma exibição de variáveis na saída. Os comandos de formato são precedidos de %. A cada comando de formato deve corresponder um argumento na função printf(). Se isto não ocorrer podem acontecer erros imprevisíveis no programa.



Abaixo apresentamos a tabela de códigos de formato:
 
Código
Formato
%c
Um caracter (char)
%d
Um número inteiro decimal (int)
%i
O mesmo que %d
%e
Número em notação científica com o "e"minúsculo
%E
Número em notação científica com o "e"maiúsculo
%f
Ponto flutuante decimal
%g
Escolhe automaticamente o melhor entre %f e %e
%G
Escolhe automaticamente o melhor entre %f e %E
%o
Número octal
%s
String
%u
Decimal "unsigned" (sem sinal)
%x
Hexadecimal com letras minúsculas
%X
Hexadecimal com letras maiúsculas
%%
Imprime um %
%p
Ponteiro
Vamos ver alguns exemplos:
Código
Imprime
printf ("Um %%%c %s",'c',"char");
Um %c char
printf ("%X %f %e",107,49.67,49.67);
6B 49.67 4.967e1
printf ("%d %o",10,10);
10 12
É possível também indicar o tamanho do campo, justificação e o número de casas decimais. Para isto usa-se códigos colocados entre o % e a letra que indica o tipo de formato.
Um inteiro indica o tamanho mínimo, em caracteres, que deve ser reservado para a saída. Se colocarmos então %5d estamos indicando que o campo terá cinco caracteres de comprimento no mínimo. Se o inteiro precisar de mais de cinco caracteres para ser exibido então o campo terá o comprimento necessário para exibi-lo. Se o comprimento do inteiro for menor que cinco então o campo terá cinco de comprimento e será preenchido com espaços em branco. Se se quiser um preenchimento com zeros pode-se colocar um zero antes do número. Temos então que %05d reservará cinco casas para o número e se este for menor então se fará o preenchimento com zeros.
O alinhamento padrão é à direita. Para se alinhar um número à esquerda usa-se um sinal - antes do número de casas. Então %-5d será o nosso inteiro com o número mínimo de cinco casas, só que justificado a esquerda.

Pode-se indicar o número de casas decimais de um número de ponto flutuante. Por exemplo, a notação %10.4f indica um ponto flutuante de comprimento total dez e com 4 casas decimais. Entretanto, esta mesma notação, quando aplicada a tipos como inteiros e strings indica o número mínimo e máximo de casas. Então %5.8d é um inteiro com comprimento mínimo de cinco e máximo de oito.
Vamos ver alguns exemplos: 
Código
Imprime
printf ("%-5.2f",456.671);
| 456.67|
printf ("%5.2f",2.671);
| 2.67|
printf ("%-10s","Ola");
|Ola       |
Nos exemplos o "pipe" ( | ) indica o início e o fim do campo mas não são escritos na tela.

- scanf

Protótipo:
                int scanf (char *str,...);
A string de controle str determina, assim como com a função printf(), quantos parâmetros a função vai necessitar. Devemos sempre nos lembrar que a função scanf() deve receber ponteiros como parâmetros. Isto significa que as variáveis que não sejam por natureza ponteiros devem ser passadas precedidas do operador &. Os especificadores de formato de entrada são muito parecidos com os de printf(). Os caracteres de conversão d, i, u e x podem ser precedidos por h para indicarem que um apontador para short ao invés de int aparece na lista de argumento, ou pela letra l (letra ele) para indicar que que um apontador para long aparece na lista de argumento. Semelhantemente, os caracteres de conversão e, f e g podem ser precedidos por l para indicarem que um apontador para double ao invés de float está na lista de argumento.  Exemplos:
Código
Formato
%c
Um único caracter (char)
%d
Um número decimal (int)
%i
Um número inteiro
%hi
Um short int
%li
Um long int
%e
Um ponto flutuante
%f
Um ponto flutuante
%lf
Um double
%h
Inteiro curto
%o
Número octal
%s
String
%x
Número hexadecimal
%p
Ponteiro
- sprintf e sscanf
sprintf e sscanf são semelhantes a printf e scanf. Porém, ao invés de escreverem na saída padrão ou lerem da entrada padrão, escrevem ou leem em uma string. Os protótipos são:
int sprintf (char *destino, char *controle, ...);
int sscanf (char *destino, char *controle, ...);
Estas funções são muito utilizadas para fazer a conversão entre dados na forma numérica e sua representação na forma de strings. No programa abaixo, por exemplo, a variável i é "impressa" em string1. Além da representação de i como uma string, string1 também conterá "Valor de i=" .
#include 
int main()
{
    int i;
    char string1[20];
    printf( " Entre um valor inteiro: ");
    scanf("%d", &i);
    sprintf(string1,"Valor de i = %d", i);
    puts(string1);
    return 0;
}
Já no programa abaixo, foi utilizada a função sscanf para converter a informação armazenada em string1 em seu valor numérico:
#include 
int main()
{
    int i, j, k;
    char string1[]= "10 20 30";
    sscanf(string1, "%d %d %d", &i, &j, &k);
    printf("Valores lidos: %d, %d, %d", i, j, k);
    return 0;
}
AUTO AVALIAÇÃO
Veja como você está. Escreva um programa que leia (via teclado) e apresente uma matriz 3X3 na tela. Utilize os novos códigos de formato aprendidos para que a matriz se apresente corretamente identada. Altere os tipos de dados da matriz (int, float, double) e verifique a formatação correta para a identação. Verifique também a leitura e impressão de números hexadecimais.


 Abrindo e Fechando um Arquivo
O sistema de entrada e saída do ANSI C é composto por uma série de funções, cujos protótipos estão reunidos em stdio.h . Todas estas funções trabalham com o conceito de "ponteiro de arquivo". Este não é um tipo propriamente dito, mas uma definição usando o comando typedef. Esta definição também está no arquivo stdio.h. 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 texto para leitura. O arquivo deve existir antes de ser aberto.
"w"
Abrir um arquivo texto para gravação. Se o arquivo não existir, ele será criado. Se já existir, o conteúdo anterior será destruído.
"a"
Abrir um arquivo texto para gravação. Os dados serão adicionados no fim do arquivo ("append"), se ele já existir, ou um novo arquivo será criado, no caso de arquivo não existente anteriormente.
"rb"
Abre um arquivo binário para leitura. Igual ao modo "r" anterior, só que o arquivo é binário.
"wb"
Cria um arquivo binário para escrita, como no modo "w" anterior, só que o arquivo é binário.
"ab"
Acrescenta dados binários no fim do arquivo, como no modo "a" anterior, só que o arquivo é binário.
"r+"
Abre um arquivo texto para leitura e gravação. O arquivo deve existir e pode ser modificado.
"w+"
Cria um arquivo texto para leitura e gravação. Se o arquivo existir, o conteúdo anterior será destruído. Se não existir, será criado.
"a+"
Abre um arquivo texto para gravação e leitura. Os dados serão adicionados no fim do arquivo se ele já existir, ou um novo arquivo será criado, no caso de arquivo não existente anteriormente.
"r+b"
Abre um arquivo binário para leitura e escrita. O mesmo que "r+" acima, só que o arquivo é binário.
"w+b"
Cria um arquivo binário para leitura e escrita. O mesmo que "w+" acima, só que o arquivo é binário.
"a+b"
Acrescenta dados ou cria uma arquivo binário para leitura e escrita. O mesmo que "a+" acima, só que o arquivo é binário

Poderíamos então, para abrir um arquivo binário para escrita, escrever:
FILE *fp;         /* Declaração da estrutura
fp=fopen ("exemplo.bin","wb");  /* o arquivo se chama 
exemplo.bin e está localizado no diretório corrente */
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). 
Uma vez aberto um arquivo, vamos poder ler ou escrever nele utilizando as funções que serão apresentadas nas próximas páginas.
Toda vez que estamos trabalhando com arquivos, há uma espécie de posição atual no arquivo. Esta  é a posição de onde será lido ou escrito o próximo caractere. 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()).

- exit

Aqui abrimos um parênteses para explicar a função exit() cujo protótipo é:
void exit (int codigo_de_retorno);
Para utilizá-la deve-se colocar um include para o arquivo de cabeçalho stdlib.h. 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 nestes casos, se o programa não conseguir a memória necessária ou abrir o arquivo, a melhor saída pode ser terminar a execução do programa. Poderíamos reescrever o exemplo da seção anterior usando agora o exit() para garantir que o programa não deixará de abrir o arquivo:
#include 
#include  /* Para a função exit() */
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 acabamos de usar um arquivo que abrimos, devemos fechá-lo. Para tanto usa-se a função fclose():
int fclose (FILE *fp);
O ponteiro fp passado à função fclose() determina o arquivo a ser fechado. A função retorna zero no caso de sucesso.
Fechar um arquivo faz com que qualquer caracter que tenha permanecido no "buffer" associado ao fluxo de saída seja gravado. Mas, o que é este "buffer"? Quando você envia caracteres para serem gravados em um arquivo, estes caracteres são armazenados temporariamente em uma área de memória (o "buffer") em vez de serem escritos em disco imediatamente. Quando o "buffer" estiver cheio, seu conteúdo é escrito no disco de uma vez. A razão para se fazer isto tem a ver com a eficiência nas leituras e gravações de arquivos. Se, para cada caracter que fossemos gravar, tivéssemos que posicionar a cabeça de gravação em um ponto específico do disco, apenas para gravar aquele caracter, as gravações seriam muito lentas. Assim estas gravações só serão efetuadas quando houver um volume razoável de informações a serem gravadas ou quando o arquivo for fechado.
A função exit() fecha todos os arquivos que um programa tiver aberto.

Lendo e Escrevendo Caracteres em Arquivos

- putc

A função putc é a primeira função de escrita de arquivo que veremos. Seu protótipo é:
int putc (int ch,FILE *fp);
Escreve um caractere no arquivo.
O programa a seguir lê uma string do teclado e escreve-a, caractere por caractere em um arquivo em disco (o arquivo arquivo.txt, que será aberto no diretório corrente).
#include 
#include 
int main()
{
 FILE *fp;
 char string[100];
 int i;
fp = fopen("arquivo.txt","w");/* Arquivo ASCII, para escrita */
if(!fp)
{
    printf( "Erro na abertura do arquivo");
    exit(0);
}
printf("Entre com a string a ser gravada no arquivo:");
gets(string);
 for(i=0; string[i]; i++) putc(string[i], fp);
 /* Grava a string, caractere a caractere */
 fclose(fp);
return 0;
}
Depois de executar este programa, verifique o conteúdo do arquivo arquivo.txt (você pode usar qualquer editor de textos). Você verá que a string que você digitou está armazenada nele.

- getc

Retorna um caractere 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);
Outra forma de se verificar se o final do arquivo foi atingido é comparar o caractere lido por getc com EOF. O programa a seguir abre um arquivo já existente e o lê, caracter por caracter, até que o final do arquivo seja atingido. Os caracteres lidos são apresentados na tela:
#include
#include
int main()
{
FILE *fp;
char c;
fp = fopen("arquivo.txt","r");/* Arquivo ASCII, para leitura */
if(!fp)
{
    printf( "Erro na abertura do arquivo");
    exit(0);
}
while((c = getc(fp) ) != EOF)/* Enquanto não chegar ao final do arquivo */

    printf("%c", c);         /* imprime o caracter lido */
fclose(fp);
return 0;
}


A seguir é apresentado um programa onde várias operações com arquivos são realizadas, usando as funções vistas nesta página. 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 
#include 
#include 
 
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 e o fecha ...*/
        strcat(frase, str);
        for (i=0; frase[i]; i++)
         putc(frase[i],p);
        fclose(p);
 
        /* Abre novamente para  leitura  */
        p = fopen(str,"r");
        c = getc(p);    /* Le o primeiro caracter */
        while (!feof(p))/* Enquanto não se chegar no final do arquivo */
        {    
                printf("%c",c); /*   Imprime o caracter na tela */
                c = getc(p);    /* Le um novo caracter no arquivo */
        }
        fclose(p);      /* Fecha o arquivo */
}
Auto-Avaliação
Veja como você está: escreva um programa que abra um arquivo texto e conte o número de caracteres presentes nele. Imprima o número de caracteres na tela.

Outros Comandos de Acesso a Arquivos

- Arquivos pré-definidos

Quando se começa a execução de um programa, o sistema automaticamente abre alguns arquivos pré-definidos:
  • stdin: dispositivo de entrada padrão (geralmente o teclado)
  • stdout: dispositivo de saída padrão (geralmente o vídeo)
  • stderr: dispositivo de saída de erro padrão (geralmente o vídeo)
  • stdaux: dispositivo de saída auxiliar (em muitos sistemas, associado à porta serial)
  • stdprn : dispositivo de impressão padrão (em muitos sistemas, associado à porta paralela)
Cada uma destas constantes pode ser utilizada como um ponteiro para FILE, para acessar os periféricos associados a eles. Desta maneira, pode-se, por exemplo, usar:
ch =getc(stdin);
para efetuar a leitura de um caracter a partir do teclado, ou :          
                    putc(ch, stdout);
para imprimí-lo na tela.

- fgets

Para se ler uma string num arquivo podemos usar fgets() cujo protótipo é:
char *fgets (char *str, int tamanho,FILE *fp);
A função recebe 3 argumentos: a string a ser lida, o limite máximo de caracteres a serem lidos e o ponteiro para FILE, que está associado ao arquivo de onde a string será lida. A função lê a string até que um caracter de nova linha seja lido ou tamanho-1 caracteres tenham sido lidos. Se o caracter de nova linha ('\n') for lido, ele fará parte da string, o que não acontecia com gets. A string resultante sempre terminará com '\0' (por isto somente tamanho-1 caracteres, no máximo, serão lidos).
A função fgets é semelhante à função gets(), porém, além dela poder fazer a leitura a partir de um arquivo de dados  e incluir o caracter de nova linha na string, ela ainda especifica o tamanho máximo da string de entrada. Como vimos, a função gets não tinha este controle, o que poderia acarretar erros de "estouro de buffer".  Portanto, levando em conta que o ponteiro fp pode ser substituído por stdin, como vimos acima, uma alternativa ao uso de gets é usar a seguinte construção:
                fgets (str, tamanho, stdin);
onde str e' a string que se está lendo e tamanho deve ser igual ao tamanho alocado para a string subtraído de 1, por causa do '\0'.

- fputs

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

- ferror e perror

Protótipo de ferror:
int ferror (FILE *fp);
A função retorna zero, se nenhum erro ocorreu e um número diferente de zero se algum erro ocorreu durante o acesso ao arquivo.
ferror() se torna muito útil quando queremos verificar se cada acesso a um arquivo teve sucesso, de modo que consigamos garantir a integridade dos nossos dados. Na maioria dos casos, se um arquivo pode ser aberto, ele pode ser lido ou gravado. Porém, existem situações em que isto não ocorre. Por exemplo, pode acabar o espaço em disco enquanto gravamos, ou o disco pode estar com problemas e não conseguimos ler, etc.
            Uma função que pode ser usada em conjunto com ferror() é a função perror() (print error), cujo argumento é uma string que normalmente indica em que parte do programa o problema ocorreu.
            No exemplo a seguir, fazemos uso de ferror, perror e fputs
#include
#include
int main()
{
    FILE *pf;
    char string[100];
    if((pf = fopen("arquivo.txt","w")) ==NULL)
    {
        printf("\nNao consigo abrir o arquivo ! ");
        exit(1);
    }
    do
    {
        printf("\nDigite uma nova string. Para terminar, digite : ");
        gets(string);
        fputs(string, pf);
        putc('\n', pf);
        if(ferror(pf))
        {
            perror("Erro na gravacao");
            fclose(pf);
            exit(1);
        }
    } while (strlen(string) > 0);
    fclose(pf);
}

- 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. count 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 count quando o fim do arquivo for encontrado ou ocorrer algum erro.
Quando o arquivo for aberto para dados binários, fread pode ler qualquer tipo de dados.

- fwrite

A função fwrite() funciona como a sua companheira fread(), porém escrevendo no arquivo. Seu protótipo é:
unsigned fwrite(void *buffer,int numero_de_bytes,int count,FILE *fp);
A função retorna o número de itens escritos. Este valor será igual a count a menos que ocorra algum erro.
O exemplo abaixo ilustra o uso de fwrite e fread para gravar e posteriormente ler uma variável float em um arquivo binário.
#include
#include
int main()
{
FILE *pf;
float pi = 3.1415;
float pilido;
if((pf = fopen("arquivo.bin", "wb")) == NULL) /* Abre arquivo binário para escrita */
{
    printf("Erro na abertura do arquivo");
    exit(1);
}
if(fwrite(&pi, sizeof(float), 1,pf) != 1)     /* Escreve a variável pi */
    printf("Erro na escrita do arquivo");
fclose(pf);                                  /* Fecha o arquivo */
if((pf = fopen("arquivo.bin", "rb")) == NULL)/* Abre o arquivo novamente para leitura */
{
    printf("Erro na abertura do arquivo");
    exit(1);
}


if(fread(&pilido, sizeof(float), 1,pf) != 1)/* Le em pilido o valor da variável armazenada anteriormente */
    printf("Erro na leitura do arquivo");
printf("\nO valor de PI, lido do arquivo e': %f", pilido);
fclose(pf);
return(0);
}

Note-se o uso do operador sizeof, que retorna o tamanho em bytes da variável ou do tipo de dados.

- fseek

Para se fazer procuras e acessos randômicos em arquivos usa-se a função fseek(). Esta move a posição corrente de leitura ou escrita 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 origem determina a partir de onde os numbytes de movimentação serão contados. Os valores possíveis são definidos por macros em stdio.h 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ão dados na posição atual.  

- rewind

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

- remove

Protótipo:
                int remove (char *nome_do_arquivo);
Apaga um arquivo especificado.
O exercício da página 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 
#include 
#include 
 
 
int main()
{
      FILE *p;
      char str[30], frase[] = "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");
      fgets(str,29,stdin);                             /* Usa fgets como se fosse gets */
      for(i=0; str[i]; i++) if(str[i]=='\n') str[i]=0; /* Elimina o \n da string lida */
      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, e o fecha ...*/
      fputs(frase, p);
      fputs(str,p);
      fclose(p);
 
      /* abre novamente e le */
      p = fopen(str,"r");
      fgets(resposta, 79, p);
      printf("\n\n%s\n", resposta);
      fclose(p);              /* Fecha o arquivo */
      remove(str);            /* Apaga o arquivo */
      return(0);
}

Fluxos Padrão

Os fluxos padrão em arquivos permitem ao programador ler e escrever em arquivos da maneira padrão com a qual o  já líamos e escrevíamos 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 do teclado 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 da página 97 seja usando fprintf () e fscanf(). Fica assim:
#include 
#include 
int 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  */
        p = fopen(str,"r");
        while (!feof(p))
        {
                fscanf(p,"%c",&c);
                printf("%c",c);
        } 
        fclose(p);
        return(0);
}
AUTO AVALIAÇÃO
Veja como você está. Escreva um programa que leia uma lista de nomes e idades de um arquivo texto. Prepare um arquivo para ser lido com nomes e idades. Apresente os dados lidos em forma de tabela na tela. Use as funções de sua preferência, mas faça pelo menos duas versões do programa usando funções de leitura diferentes.