15:16 22 abr 2016

Portada
Streams
Funciones
fopen
fwrite
Curso de programación en C moderno
(II Edición)
fread
fputs
fgets
fprintf
fscanf
Neira Ayuso, Pablo
Falgueras García, Carlos
Funciones
peligrosas
Tema 10
Entrada/Salida
Índice
Portada
1 ¿Qué es un stream?
Streams
Funciones
fopen
fwrite
fread
fputs
fgets
fprintf
fscanf
Funciones
peligrosas
2 Funciones básicas
fopen
fwrite
fread
fputs
fgets
fprintf
fscanf
3 Funciones peligrosas
¿Qué es un stream?
Portada
Flujo de bytes de longitud indeterminada, al que se accede de
forma secuencial.
Streams
Funciones
fopen
fwrite
fread
fputs
fgets
fprintf
fscanf
Funciones
peligrosas
En un stream:
• Al leer uno o más bytes, en la próxima lectura
obtendremos los siguientes.
• Al escribir uno o más bytes, en la próxima escritura los
añadiremos a continuación.
Streams estándar:
• stdout: Salida estándar (normalmente por consola)
• stdin: Entrada estándar (normalmente por teclado)
• stderr: Salida estándar de errores (normalmente por
consola)
Funciones básicas
Portada
Streams
Funciones
fopen
fwrite
fread
fputs
fgets
fprintf
fscanf
Funciones
peligrosas
• Apertura y cierre de ficheros:
• FILE ∗f = fopen(" file . txt", "r");
• fclose ( f ) ;
• Lectura/Escritura en crudo:
• size_t read = fread(buf, sizeof (char) , bufsize , f ) ;
• size_t written = fwrite(buf, sizeof (char) , bufsize , f ) ;
• Lectura/Escritura sin formato:
• fputs ("Hola Mundo", f);
• fgets (buf, bufsize , f ) ;
• Lectura/Escritura con formato:
• fprintf ( f , "Hola", name);
• fscanf ( f , "%10s %d", str, &i);
Para más información ver:
http://es.cppreference.com/w/c/io
fopen
Portada
Streams
Funciones
FILE *fopen(const char *fname, const char *mode);
int fclose(FILE *stream);
fopen
fwrite
fread
fputs
fgets
Modos:
fprintf
fscanf
Funciones
peligrosas
modo
"r"
"w"
"a"
"r+"
"w+"
"a+"
significado
Abre para leer
Crea para escribir
Crea para añadir
Abre para leer/escribir
Crea para leer/escribir
Crea para leer/añadir
si ya existe
lee desde el principio
descarta el contenido
escribe al final
lee/escribe desde el principio
descarta el contenido
lee*/escribe desde el final
si no existe
error
lo crea
lo crea
error
lo crea
lo crea
fwrite
Portada
Streams
Funciones
fopen
fwrite
fread
fputs
fgets
fprintf
fscanf
Funciones
peligrosas
size_t fwrite (const void ∗buf, size_t size , size_t count,FILE ∗strm);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#i n c l u d e < s t d i o . h>
#i n c l u d e < s t d l i b . h>
#i n c l u d e < s t r i n g . h>
#d e f i n e FNAME " f i l e "
i n t main ( ) {
FILE ∗ f ;
c h a r b u f [ ] = " H o l a Mundo" ;
f = f o p e n (FNAME, "w+" ) ;
i f (! f ) {
perror (" Error al abrir ") ;
e x i t ( EXIT_FAILURE ) ;
}
f w r i t e ( buf , s i z e o f ( c h a r ) , s t r l e n ( buf ) ,
if ( ferror ( f )) {
perror (" Error al e s c r i b i r ") ;
e x i t ( EXIT_FAILURE ) ;
}
}
fclose ( f ) ;
return 0;
f);
fread
Portada
Streams
Funciones
fopen
fwrite
fread
fputs
fgets
fprintf
fscanf
Funciones
peligrosas
size_t fread (void ∗buf, size_t size , size_t cnt , FILE ∗strm);
1 #d e f i n e FNAME " f i l e "
2 #d e f i n e BUFSIZE 256
3
4 i n t main ( ) {
5
FILE ∗ f ;
6
c h a r b u f [ BUFSIZE ] ;
7
i n t read ;
8
9
f = f o p e n (FNAME, " r " ) ;
10
i f (! f ) {
11
p e r r o r ( "No s e ha p o d i d o a b r i r e l f i c h e r o " ) ;
12
e x i t ( EXIT_FAILURE ) ;
13
}
14
15
r e a d = f r e a d ( b u f , s i z e o f ( c h a r ) , BUFSIZE − 1 , f ) ;
16
if ( ferror ( f )) {
17
perror (" Error al leer ") ;
18
e x i t ( EXIT_FAILURE ) ;
19
}
20
21
b u f [ r e a d ] = ' \0 ' ;
22
p r i n t f ( "%s " , b u f ) ;
23
24
fclose ( f ) ;
25
return 0;
26 }
fputs
Portada
Streams
Funciones
fopen
fwrite
fread
fputs
fgets
fprintf
fscanf
Funciones
peligrosas
int fputs (const char ∗ str , FILE ∗strm);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#i n c l u d e < s t d i o . h>
#i n c l u d e < s t d l i b . h>
#i n c l u d e < s t r i n g . h>
#d e f i n e FNAME " f i l e "
i n t main ( )
{
FILE ∗ f ;
c h a r b u f [ ] = " H o l a Mundo" ;
f = f o p e n (FNAME, "w+" ) ;
i f (! f ) {
perror (" Error al abrir ") ;
e x i t ( EXIT_FAILURE ) ;
}
f p u t s ( buf , f ) ;
if ( ferror ( f )) {
perror (" Error al e s c r i b i r ") ;
e x i t ( EXIT_FAILURE ) ;
}
}
fclose ( f ) ;
return 0;
fgets
Portada
Streams
Funciones
fopen
fwrite
fread
fputs
fgets
fprintf
fscanf
Funciones
peligrosas
char ∗ fgets (char ∗buf, int bufsize , FILE ∗strm);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#d e f i n e FNAME " f i l e "
#d e f i n e BUFSIZE 256
i n t main ( )
{
FILE ∗ f ;
c h a r b u f [ BUFSIZE ] ;
f = f o p e n (FNAME, " r " ) ;
i f (! f ) {
perror (" Error al abrir ") ;
e x i t ( EXIT_FAILURE ) ;
}
int i = 0;
w h i l e ( f g e t s ( b u f , BUFSIZE , f ) )
p r i n t f ( "%d : \"% s \"\ n " , i ++, b u f ) ;
if ( ferror ( f )) {
perror (" Error al leer ") ;
e x i t ( EXIT_FAILURE ) ;
}
}
fclose ( f ) ;
return 0;
fprintf
Portada
Streams
Funciones
fopen
fwrite
fread
fputs
fgets
fprintf
fscanf
Funciones
peligrosas
int fprintf (FILE ∗strm, const char ∗frmt, ...) ;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#i n c l u d e < s t d i o . h>
#i n c l u d e < s t d l i b . h>
#i n c l u d e < s t r i n g . h>
#d e f i n e FNAME " f i l e "
i n t main ( )
{
FILE ∗ f ;
f = f o p e n (FNAME, "w+" ) ;
i f (! f ) {
perror (" Error al abrir ") ;
e x i t ( EXIT_FAILURE ) ;
}
f p r i n t f ( f , " H o l a Mundo\ n 2 + 2 = %d " , 2 + 2 ) ;
if ( ferror ( f )) {
perror (" Error al e s c r i b i r ") ;
e x i t ( EXIT_FAILURE ) ;
}
}
fclose ( f ) ;
return 0;
fscanf
Portada
Streams
Funciones
fopen
fwrite
fread
fputs
fgets
fprintf
fscanf
Funciones
peligrosas
int fscanf (FILE ∗strm, const char ∗frmt, ...) ;
1 i n t main ( )
2 {
3
FILE ∗ f ;
4
char s t r 1 [1 0] , s r t 2 [ 1 0 ] ;
5
int a , b , c , ret ;
6
7
f = f o p e n (FNAME, " r " ) ;
8
i f (! f ) {
9
perror (" Error al abrir ") ;
10
e x i t ( EXIT_FAILURE ) ;
11
}
12
13
w h i l e ( ( r e t = f s c a n f ( f , "%10 s %10 s %d + %d = %d " ,
14
s t r 1 , s t r 2 , &a , &b , &c ) ) == 5 ) {
15
p r i n t f ( "%s %s \ n %d + %d = %d \ n " , s t r 1 , s t r 2 , a , b , c ) ;
16
}
17
if ( ferror ( f )) {
18
perror (" Error al leer ") ;
19
e x i t ( EXIT_FAILURE ) ;
20
}
21
e l s e i f ( r e t != EOF) {
22
f p r i n t f ( s t d e r r , " E r r o r a l a n a l i z a r : %d/%d \ n " , r e t , 5 ) ;
23
}
24
25
fclose ( f ) ;
26
return 0;
27 }
Funciones peligrosas
Portada
Streams
Funciones
fopen
fwrite
fread
fputs
fgets
fprintf
fscanf
Funciones
peligrosas
Todas las funciones que lean un número indefinido de bytes sin
comprobar el tamaño del buffer de destino.
• scanf y sus variantes si no especificamos el tamaño al
escanear una cadena: "%s"
• gets, que lee una cadena de stdin sin posibilidad de
especificar ningún límite para su tamaño. Eliminada en el
estándar de 2011.