Programación I
Teoría : Entrada/Salida - Archivos
http://proguno.unsl.edu.ar
[email protected]
Entrada/Salida
Interacción del programa con su
ambiente para leer (entrada) y
escribir (salida) datos.
2
Modelo de Entrada/Salida en C
Las entradas o salidas en C, sin importar de
dónde vienen o hacia dónde van, tratan con
streams (flujos) de bytes.
En las operaciones de entrada, los bytes
fluyen desde un dispositivo de entrada a la
memoria principal.
En las operaciones de salida, los bytes fluyen
desde la memoria principal a un dispositivo
de salida.
3
Entrada/Salida
Hasta ahora hemos trabajado sólo:
Entrada estándar: teclado
getchar: lee un caracter
scanf: lee entradas con formato
Salida estándar: pantalla
printf: imprime datos con formato
Existen otras formas …
4
Entrada y Salida Estándar
Entrada estándar (o por defecto):
generalmente es el teclado
Salida estándar (o por defecto):
generalmente es la pantalla
Ambos pueden ser redireccionados a
archivos.
5
Redireccionamiento de la Entrada y la
Salida Estándar
Ej: programa sumador:
#include <stdio.h>
main(){
float sum, x;
sum = 0;
while (scanf("%f", &x) == 1)
sum = sum + x;
printf("La suma de los numeros
ingresados es %.2f\n", sum);
}
6
Redireccionamiento de la Entrada y la
Salida Estándar
Al ejecutar sumador en la línea de
comandos escribiremos:
$ sumador
Nombre del
programa a ejecutar
Prompt del
sistema
Podemos redireccionar el flujo de entrada a
un archivo, desde la línea de comandos:
$ sumador <input.txt
Nombre del
archivo de
entrada
7
Redireccionamiento de Entrada y
Salida Estándar
Igualmente, podemos redireccionar la salida
a un archivo:
$ sumador >output.txt
Nombre del
archivo de
salida
o ambos:
$ sumador <input.txt >output.txt
8
Salida Formateada con printf
int printf(char *format, arg1, arg2, ...)
printf convierte, formatea e imprime en
la salida estándar sus argumentos arg1,
arg2, ..., bajo el control del formato
especificado por el string format.
Retorna el número de caracteres impresos
o un valor negativo si hubo algún error.
9
Salida Formateada con printf
El string de formato format contiene
caracteres ordinarios mezclados con
especificadores de conversión.
Cada especificador de conversión:
Provoca una conversión e impresión del
correspondiente argumento del printf.
10
Salida Formateada con printf
Cada especificador de conversión:
Empieza con %
Puede seguir con:
Un signo menos para indicar justificación a izquierda.
Un número para el ancho mínimo del campo.
Un punto, que separa el ancho del campo de la precisión.
Un número, la precisión, que especifica:
el n° máximo de caracteres a ser impresos, en el caso de un string;
el n° de dígitos después del punto decimal de un punto flotante;
el n° mínimo de dígitos para un entero.
Una h si el entero debe ser impreso como un short, o
una letra l si como un long.
Termina con un carácter de conversión.
11
Carácter de
conversión
d,i
o
x,X
Tipo del
argumento
int
int
int
u
c
s
f
e,E
g,G
p
%
int
int
char *
double
double
double
void *
No se con-
vierte ningún
argumento
Impreso como
Número decimal.
Número en octal sin signo (sin cero inicial).
Número sin signo en hexadecimal (sin 0x o 0X inicial), usa
abcdef o ABCDEF, respectivamente.
Número decimal sin signo.
Un caracter.
Imprime caracteres del string hasta encontrar un '\0' o el número
de caracteres dados por la precisión.
Imprime el número real con el formato[-]m.dddddd, donde el
número de d's está dado por la precisión (por defecto asume 6).
Imprime el número real con el formato [-]m.dddddde+/-xx
o el formato [-]m.ddddddE+/-xx, donde el numero de d's está
dado por la precisión (por defecto asume 6).
Usar %e o %E si el exponente es menor que -4 o mayor o igual a
la precisión; sino usar %f. Los ceros y un punto decimal final no
son impresos.
Puntero (representación dependiente de la implementación).
Imprime un %
12
:455:
:455:
:455:
:‐455:
:32000:
printf( ":%d:\n", 455 );
printf( ":%i:\n", 455 );
printf( ":%d:\n", +455 );
printf( ":%d:\n", -455 );
printf( ":%hd:\n", 32000 );
printf( ":%ld:\n", 2000000000L ); :2000000000:
printf( ":%o:\n", 455 );
printf( ":%u:\n", 455 );
printf( ":%u:\n", -455 );
printf( ":%x:\n", 455 );
printf( ":%X:\n", 455 );
printf( ":%4d:\n", 1 );
printf( ":%4d:\n", 12 );
printf( ":%4d:\n", 123 );
:707:
:455:
:4294966841:
:1c7:
:1C7:
:
1:
:
12:
: 123:
13
printf( ":%4d:\n", 1234 );
:1234:
printf( ":%4d:\n", 12345 );
:12345:
printf( ":%4d:\n", -1 );
:
‐1:
printf( ":%4d:\n", -12 );
: ‐12:
printf( ":%4d:\n", -123 );
:‐123:
printf( ":%4d:\n", -1234 );
:‐1234:
printf( ":%4d:\n", -12345 );
:‐12345:
printf( ":%-4d:\n", -12 );
:‐12 :
printf( ":%e:\n", 1234567.89 );
:1.234568e+006:
printf( ":%e:\n", +1234567.89 ); :1.234568e+006:
printf( ":%e:\n", -1234567.89 ); :‐1.234568e+006:
printf( ":%E:\n", 1234567.89 );
:1.234568E+006:
printf( ":%f:\n", 1234567.89 );
:1234567.890000:
printf( ":%g:\n", 1234567.89 );
:1.23457e+006:
printf( ":%G:\n", 1234567.89 );
:1.23457E+006:
14
printf( ":%.4d:\n", 873);
printf(":%.9d:\n", 873);
printf(":%9.3f:\n", 123.456789 );
printf(":%s:\n", "hello, world");
printf(":%10s:\n", "hello, world");
printf(":%.10s:\n", "hello, world");
printf(":%-10s:\n", "hello, world");
printf(":%15s:\n", "hello, world");
printf(":%.15s:\n", "hello, world");
printf(":%-15s:\n", "hello, world");
printf(":%15.10s:\n", "hello, world"); :
printf(":%-15.10s:\n", "hello, world"); :hello, wor
printf("%.*s", max, s);
:0873:
:000000873:
: 123.457:
:hello, world:
:hello, world:
:hello, wor:
:hello, world:
:
:hello, world:
:hello, world
hello, world:
:
hello, wor:
:
printf(“%%”);
Imprime a lo sumo max
caracteres de string s
Imprime %
15
Entrada Formateada: scanf
int scanf(char *format, arg1, arg2, ...)
scanf lee caracteres del flujo de entrada estándar,
los interpreta de acuerdo a la especificación dada en
el string format, y almacena los resultados en los
argumentos.
scanf ignora caracteres de espacios en blanco
(blancos, tabuladores, newlines, carriage return etc.)
que estén en su string de formato.
que aparezcan mientras busca los valores de entrada.
16
Entrada Formateada: scanf
Se detiene cuando:
consumió todo su string de formato format, o
alguna de las entradas no concuerda con la
especificación de control dada en él. La sgte. llamada
a scanf reasume desde donde dejó la anterior.
Retorna la cantidad de campos de entrada
leídos.
17
Entrada Formateada: scanf
El string de formato format contiene uno o
más especificadores de conversión. Puede
contener:
Espacios en blanco (tabulador vertical y horizontal,
new line, carriage return, blanco): son ignorados.
Caracteres ordinarios: deben hacer matching con la
entrada.
18
Entrada Formateada: scanf
Un especificador de conversión:
Empieza con %
Puede, opcionalmente, tener:
un caracter * de supresión de asignación;
un número que indica el ancho máximo del campo de
una h, l ó L indicando la amplitud del argumento
entrada;
objetivo;
Termina con un caracter de conversión.
19
Carácter
de
conversión
d
i
o
u
x
Datos de la entrada
correspondiente
Tipo del
Entero decimal
Entero. El entero puede estar
en octal (empezando con 0) o
en hexadecimal (empezando
con 0x o 0X).
Entero en octal (con o sin
cero inicial)
Entero decimal sin signo
Entero hexadecimal octal
(con o sin 0x o 0X inicial)
argumento
int *
int *
int *
unsigned int
*
int *
20
c
s
Caracter
Cadena de caracteres
(string), sin las
comillas.
e,f,g Números de punto
flotante con signo
opcional, punto
decimal opcional u
exponente opcional
literal %
%
char *
char *
Apuntando a un arreglo de
caracteres lo suficientemente
grande como para almacenar el
string más el caracter de
finalización \0 que será agregado.
float *
No se asigna nada.
21
Ejemplos
int day, month, year;
char monthname[20];
scanf("%d %s %d", &day, monthname,
&year);
scanf("%d/%d/%d", &day, &month,
&year);
scanf("%d-%d-%d", &day, &month,
&year);
scanf("%d%*c%d%*c%d", &day, &month,
&year );
22
Ejemplos
char x;
char y[9];
printf("Entre un string: ");
scanf("%c%s", &x, y);
printf("La entrada fue:\n");
printf("el caracter \"%c\" ", x);
printf("y el string \"%s\"\n", y);
Entre un string: SABADO
La entrada fue:
el caracter "S" y el string “ABADO"
23
Ejemplos
int x;
int y;
printf("Entre un entero de 6 digitos:");
scanf("%2d%d”, &x, &y);
printf("Los enteros ingresados fueron %d
y %d\n", x, y);
Entre un entero de 6 digitos: 123456
Los enteros ingresados fueron 12 y 3456
24
Lectura formateada desde un string
sscanf
Análogo de scanf pero lee desde un string
en vez de hacerlo desde la entrada estándar.
int sscanf(char *string, char *format, ...);
25
Acceso a Archivos
Hasta ahora nuestros programas leen y
escriben sólo en la entrada y salida
estándar.
Queremos poder leer/escribir en archivos.
26
Apertura de Archivos
Para poder leer/escribir un archivo, este debe
encontrarse abierto:
FILE *fopen(char *name, char *mode);
Puntero a archivo.
Usado en las
subsecuentes
lecturas y/o
escrituras del
archivo.
Retorna NULL si
no pudo realizar la
operación.
Nombre
del
archivo a
abrir
Modo de
apertura
del
archivo
27
Apertura de Archivos – Modos de Apertura
28
Apertura de Archivos - Ejemplos
FILE *fp1, *fp2, *fp3;
fp1 = fopen("fechas.txt","r"); /*
fp2 = fopen("empleados.txt","a"); /*
abre archivo fechas.txt para lectura
*/
abre archivo empleados.txt para
añadir */
fp3 = fopen("master.dat","w+"); /*
crea archivo master.dat para lectura
o escritura */
29
Acceso a Archivos
Entrada, Salida y Error Estándar
Cuando un programa C es iniciado, el
sistema operativo es responsable de abrir
tres flujos y de proveer los correspondientes
punteros a FILE:
la entrada estándar (stdin)
la salida estándar (stdout)
el error e
Comentarios de: Programación I Teoría : Entrada/Salida - Archivos (0)
No hay comentarios