Apostila C
275 pág.

Apostila C


DisciplinaMétodos e Técnicas de Programação22 materiais161 seguidores
Pré-visualização45 páginas
para
o pro´ximo caractere a ser lido.
Similar ao que acontece com a func¸a\u2dco fputc(), a func¸a\u2dco fgetc() tambe´m
pode ser utilizada para a leitura de caracteres do teclado. Para tanto,
basta modificar o arquivo do qual se deseja ler para a constante stdin.
Essa constante trata-se de um dos arquivos pre´-definidos do sistema, um
ponteiro para o dispositivo de entrada padra\u2dco (geralmente o teclado) das
aplicac¸o\u2dces. Assim, o comando
char c = fgetc(stdin);
le\u2c6 um caractere do teclado (dispositivo de entrada padra\u2dco) ao inve´s de um
arquivo no disco r\u131´gido.
247
O que acontece quando a func¸a\u2dco fgetc() tenta ler um ca-
ractere de um arquivo que ja´ acabou?
Neste caso, precisamos que a func¸a\u2dco retorne algo indicando que o arquivo
acabou. Pore´m, todos os 256 caracteres da tabela ASCII sa\u2dco \u201cva´lidos\u201d em
um arquivo. Para evitar esse tipo de situac¸a\u2dco, a func¸a\u2dco fgetc() na\u2dco devolve
um valor do tipo char, mas do tipo int. O conjunto de valores do tipo
char esta´ contido dentro do conjunto de valores do tipo int. Se o arquivo
tiver acabado, a func¸a\u2dco fgetc() devolve um valor inteiro que na\u2dco possa ser
confundido com um valor do tipo char.
Quando atinge o final de um arquivo, a func¸a\u2dco fgetc() de-
volve a constante EOF (End Of File), que esta´ definida
na biblioteca stdio.h. Em muitos computadores o valor de
EOF e´ definido como -1.
1 #include <s t d i o . h>
2 #include <s t d l i b . h>
3 i n t main ( ) {
4 FILE \u2217arq ;
5 char c ;
6 arq = fopen ( \u2018 \u2018 a rqu ivo . t x t \u2019 \u2019 , \u2018 \u2018 r \u2019 \u2019 ) ;
7 i f ( arq == NULL) {
8 p r i n t f ( \u2018 \u2018 Erro na aber tu ra do arqu ivo \u2019 \u2019 ) ;
9 system ( \u2018 \u2018 pause \u2019 \u2019 ) ;
10 e x i t ( 1 ) ;
11 }
12 while ( ( c = fge t c ( arq ) ) != EOF)
13 p r i n t f ( \u2018 \u2018% c \u2019 \u2019 , c ) ;
14 f c l o s e ( arq ) ;
15 system ( \u2018 \u2018 pause \u2019 \u2019 ) ;
16 return 0;
17 }
No exemplo anterior, a func¸a\u2dco fgetc() e´ utilizada juntamente com a cons-
tante EOF para ler na\u2dco apenas alguns caracteres, mas para continuar
lendo caracteres enquanto na\u2dco chegarmos ao final do arquivo.
11.5.2 FIM DO ARQUIVO
Como visto anteriormente, a constante EOF (\u201cEnd of file\u201d) indica o fim de
um arquivo. Pore´m, quando manipulando dados bina´rios, um valor inteiro
248
igual ao valor da constante EOF pode ser lido. Nesse caso, se utilizarmos
a constante EOF para verificar se chegamos ao final do arquivo, vamos
receber a confirmac¸a\u2dco de ter chegado ao final do arquivo, quando na ver-
dade ainda na\u2dco chegamos ao seu final. Para evitar este tipo de situac¸a\u2dco,
a linguagem C inclui a func¸a\u2dco feof() que determina quando o final de um
arquivo foi atingido. Seu proto´tipo e´:
int feof(FILE *fp)
Basicamente, a func¸a\u2dco feof() recebe como para\u2c6metro o ponteiro fp que
determina o arquivo a ser verificado. Como resultado, a func¸a\u2dco retorna um
valor inteiro igual a ZERO se ainda na\u2dco tiver atingido o final do arquivo.
Um valor de retorno diferente de zero significa que ja´ foi atingido o final do
arquivo.
Basicamente, a func¸a\u2dco feof() retorna um valor inteiro dife-
rente de zero se o arquivo chegou ao fim, caso contra´rio,
retorna ZERO.
1 #include <s t d i o . h>
2 #include <s t d l i b . h>
3 i n t main ( ) {
4 FILE \u2217 fp ;
5 char c ;
6 fp = fopen ( \u2018 \u2018 a rqu ivo . t x t \u2019 \u2019 , \u2018 \u2018 r \u2019 \u2019 ) ;
7 i f ( ! fp ) {
8 p r i n t f ( \u2018 \u2018 Erro na aber tu ra do arqu ivo \n \u2019 \u2019 ) ;
9 system ( \u2018 \u2018 pause \u2019 \u2019 ) ;
10 e x i t ( 1 ) ;
11 }
12 while ( ! f e o f ( fp ) ) {
13 c = fge t c ( fp ) ;
14 p r i n t f ( \u2018 \u2018% c \u2019 \u2019 , c ) ;
15 }
16 f c l o s e ( fp ) ;
17 system ( \u2018 \u2018 pause \u2019 \u2019 ) ;
18 return 0;
19 }
11.5.3 ARQUIVOS PRE´-DEFINIDOS
Como visto durante o aprendizado das func¸o\u2dces fputc() e fgetc(), os pon-
teiros stdin e stdout podem ser utilizados para acessar os dispositivos
249
de entrada (geralmente o teclado) e sa\u131´da (geralmente o v\u131´deo) padra\u2dco.
Pore´m, existem outros ponteiros que podem ser utilizados.
No in\u131´cio da execuc¸a\u2dco de um programa, o sistema auto-
maticamente abre alguns arquivos pre´-definidos, entre eles
stdin e stdout.
stdin Dispositivo de entrada padra\u2dco (geralmente o teclado)
stdout Dispositivo de sa\u131´da padra\u2dco (geralmente o v\u131´deo)
stderr Dispositivo de sa\u131´da de erro padra\u2dco (geralmente o v\u131´deo)
stdaux Dispositivo de sa\u131´da auxiliar (em muitos sistemas, associ-
ado a` porta serial)
stdprn Dispositivo de impressa\u2dco padra\u2dco (em muitos sistemas, as-
sociado a` porta paralela)
11.5.4 ESCRITA E LEITURA DE STRINGS
Ate´ o momento, apenas caracteres u´nicos puderam ser escritos em um
arquivo. Pore´m, existem func¸o\u2dces na linguagem C que permitem escrever e
ler uma seque\u2c6ncia de caracteres, isto e´, uma string, em um arquivo.
Para se escrever uma string em um arquivo usamos a func¸a\u2dco fputs(), cujo
proto´tipo e´:
int fputs (char *str,FILE *fp);
A func¸a\u2dco fputs() recebe 2 para\u2c6metros de entrada
\u2022 str: a string (array de caracteres) a ser escrita no arquivo;
\u2022 fp: a varia´vel que esta´ associada ao arquivo onde a string sera´ es-
crita.
e retorna
\u2022 a constante EOF (em geral, -1), se houver erro na escrita;
\u2022 um valor diferente de ZERO, se o texto for escrito com sucesso.
250
Exemplo: escrevendo uma string em um arquivo com fputs()
1 #include <s t d i o . h>
2 #include <s t d l i b . h>
3 i n t main ( ) {
4 char s t r [ 2 0 ] = \u2018 \u2018 He l lo World ! \u2019 \u2019 ;
5 i n t r e s u l t ;
6 FILE \u2217arq ;
7 arq = fopen ( \u2018 \u2018 ArqGrav . t x t \u2019 \u2019 , \u2018 \u2018w \u2019 \u2019 ) ;
8 i f ( arq == NULL) {
9 p r i n t f ( \u2018 \u2018 Problemas na CRIACAO do arqu ivo \n \u2019 \u2019 ) ;
10 system ( \u2018 \u2018 pause \u2019 \u2019 ) ;
11 e x i t ( 1 ) ;
12 }
13 r e s u l t = f pu t s ( s t r , arq ) ;
14 i f ( r e s u l t == EOF)
15 p r i n t f ( \u2018 \u2018 Erro na Gravacao\n \u2019 \u2019 ) ;
16
17 f c l o s e ( arq ) ;
18 system ( \u2018 \u2018 pause \u2019 \u2019 ) ;
19 return 0;
20 }
No exemplo anterior, o comando fopen() abre um arquivo de nome \u201cArq-
Grav.txt\u201d no modo de escrita para arquivos texto, \u201cw\u201d. Na seque\u2c6ncia, a
string contida na varia´vel str e´ escrita no arquivo por meio do comando
fputs(str,arq), sendo o resultado dessa operac¸a\u2dco devolvido na varia´vel re-
sult.
A func¸a\u2dco fputs() na\u2dco coloca o caracter de nova linha \u2018\n\u2019,
nem nenhum outro tipo de caractere, no final da string es-
crita no arquivo. Essa tarefa pertence ao programador.
Imagine o seguinte conjunto de comandos:
fputs(\u201cHello\u201d,arq);
fputs(\u201cWorld\u201d,arq);
O resultado da execuc¸a\u2dco desses dois comandos sera´ a escrita da string
\u201cHelloWorld\u201d no arquivo. Note que nem mesmo um espac¸o entre elas
foi adicionado. A func¸a\u2dco fputs() simplesmente escreve no arquivo aquilo
que o programador ordenou, e mais nada. Se o programador quisesse
separa´-las com um espac¸o, deve fazer como abaixo:
251
fputs(\u201cHello \u201d,arq);
fputs(\u201cWorld\u201d,arq);
Note que agora existe um espac¸o ao final da string \u201cHello \u201d. Portanto,
o resultado no arquivo sera´ a string \u201cHello World\u201d. O mesmo vale para
qualquer outro caractere, como a quebra de linha \u2018\n\u2019.
Como a func¸a\u2dco fputc(), a func¸a\u2dco fputs() tambe´m pode ser
utilizada para escrever uma string no dispositivo de sa\u131´da
padra\u2dco (geralmente a tela do monitor).
1 #include <s t d i o . h>
2 #include <s t d l i b . h>
3 i n t main ( ) {
4 \ t e x t b f {char} t e x t o [ 3 0 ] = \u2018 \u2018 He l lo World\n \u2019 \u2019 ;
5 f pu t s ( tex to , s tdou t ) ;
6 system ( \u2018 \u2018 pause \u2019 \u2019 ) ;
7 return 0;
8 }
Da mesma maneira como e´ poss\u131´vel gravar uma string em um arquivo,
tambe´m e´ poss\u131´vel fazer a sua leitura. A func¸a\u2dco utilizada para realizar
essa tarefa e´ a func¸a\u2dco fgets(), cujo proto´tipo e´:
char *fgets (char *str, int tamanho, FILE *fp);
A func¸a\u2dco fgets() recebe 3 para\u2c6metros de entrada
\u2022 str: a string onde os caracteres lidos sera\u2dco armazenados;
\u2022 tamanho: o limite ma´ximo de caracteres a serem lidos;
\u2022 fp: a varia´vel que esta´ associada ao arquivo de onde a string sera´
lida.
e retorna
\u2022 NULL: no caso de erro ou fim do arquivo;
\u2022 O ponteiro para o primeiro caractere da string recuperada em str.
252
Exemplo: lendo uma string de um arquivo com fgets()
1 #include <s t d i o . h>
2 #include <s t d l i b . h>
3 i n t main ( ) {
4 char s t r [ 2 0 ] ;
5 i n t r e s u l t ;
6 FILE \u2217arq ;
7 arq = fopen