Programación I Teoría VIII: Entrada/Salida

Presentación del tema: "Programación I Teoría VIII: Entrada/Salida"— Transcripción de la presentación:

1 Programación I Teoría VIII: Entrada/Salida http://proguno.unsl.edu.ar proguno@unsl.edu.ar

2 Entrada/Salida Interacción del programa con su ambiente para leer (entrada) y escribir (salida) datos. 2

3 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

4 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

5 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

6 Redireccionamiento de la Entrada y la Salida Estándar Ej: programa sumador: 6 #include 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); }

7 Redireccionamiento de la Entrada y la Salida Estándar Al ejecutar sumador en la línea de comandos escribiremos: $ sumador Podemos redireccionar el flujo de entrada a un archivo, desde la línea de comandos: $ sumador <input.txt 7 Nombre del programa a ejecutar Prompt del sistema Nombre del archivo de entrada

8 Redireccionamiento de Entrada y Salida Estándar Igualmente, podemos redireccionar la salida a un archivo: $ sumador >output.txt o ambos: $ sumador output.txt 8 Nombre del archivo de salida

9 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

10 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

11 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

12 12 Carácter de conversión Tipo del argumentoImpreso como d,iint Número decimal. oint Número en octal sin signo (sin cero inicial). x,Xint Número sin signo en hexadecimal (sin 0x o 0X inicial), usa abcdef o ABCDEF, respectivamente. uint Número decimal sin signo. cint Un caracter. schar * Imprime caracteres del string hasta encontrar un '\0' o el número de caracteres dados por la precisión. fdouble 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). e,Edouble I mprime el número real con el formato [-] m.dddddd e+/- xx o el formato [-] m.dddddd E+/- xx, donde el numero de d's está dado por la precisión (por defecto asume 6). g,Gdouble 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. pvoid * Puntero (representación dependiente de la implementación). % No se con- vierte ningún argumento Imprime un %

13 13 printf( ":%d:\n", 455 ); :455: printf( ":%i:\n", 455 ); :455: printf( ":%d:\n", +455 ); :455: printf( ":%d:\n", -455 ); :-455: printf( ":%hd:\n", 32000 ); :32000: printf( ":%ld:\n", 2000000000L ); :2000000000: printf( ":%o:\n", 455 ); :707: printf( ":%u:\n", 455 ); :455: printf( ":%u:\n", -455 ); :4294966841: printf( ":%x:\n", 455 ); :1c7: printf( ":%X:\n", 455 ); :1C7: printf( ":%4d:\n", 1 ); : 1: printf( ":%4d:\n", 12 ); : 12: printf( ":%4d:\n", 123 ); : 123:

14 14 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:

15 15 printf( ":%.4d:\n", 873); :0873: printf(":%.9d:\n", 873); :000000873: printf(":%9.3f:\n", 123.456789 ); : 123.457: printf(":%s:\n", "hello, world"); :hello, world: printf(":%10s:\n", "hello, world"); :hello, world: printf(":%.10s:\n", "hello, world"); :hello, wor: printf(":%-10s:\n", "hello, world"); :hello, world: printf(":%15s:\n", "hello, world"); : hello, world: printf(":%.15s:\n", "hello, world"); :hello, world: printf(":%-15s:\n", "hello, world"); :hello, world : printf(":%15.10s:\n", "hello, world"); : hello, wor: printf(":%-15.10s:\n", "hello, world"); :hello, wor : printf("%.*s", max, s); Imprime a lo sumo max caracteres de string s printf(“%”); Imprime %

16 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

17 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

18 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

19 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 entrada; una h, l ó L indicando la amplitud del argumento objetivo;  Termina con un caracter de conversión. 19

20 20 Carácter de conversión Datos de la entrada Tipo del correspondiente argumento d Entero decimal int * i Entero. El entero puede estar en octal (empezando con 0 ) o en hexadecimal (empezando con 0x o 0X ). int * o Entero en octal (con o sin cero inicial) int * u Entero decimal sin signo unsigned int * x Entero hexadecimal octal (con o sin 0x o 0X inicial) int *

21 21 c Caracter char * s Cadena de caracteres (string), sin las comillas. 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. e,f,g Números de punto flotante con signo opcional, punto decimal opcional u exponente opcional float * % literal % No se asigna nada.

22 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

23 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); 23 Entre un string: SABADO La entrada fue: el caracter "S" y el string “ABADO"

24 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); 24 Entre un entero de 6 digitos: 123456 Los enteros ingresados fueron 12 y 3456

25 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

26 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

27 Apertura de Archivos Para poder leer/escribir un archivo, este debe encontrarse abierto: FILE *fopen(char *name, char *mode); 27 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

28 Apertura de Archivos – Modos de Apertura 28

29 Apertura de Archivos - Ejemplos FILE *fp1, *fp2, *fp3; fp1 = fopen("fechas.txt","r"); /* abre archivo fechas.txt para lectura */ fp2 = fopen("empleados.txt","a"); /* abre archivo empleados.txt para añadir */ fp3 = fopen("master.dat","w+"); /* crea archivo master.dat para lectura o escritura */ 29

30 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 estándar ( stderr ) 30

31 Algunas Funciones de Entrada/Salida int fscanf(FILE *stream, const char *format,...) Lee datos desde un flujo de entrada, los interpreta de acuerdo a un formato dado y los almacena en variables. Retorna la cantidad de entradas leídas o EOF si hubo error antes de la 1ra lectura. ( fscanf usado con stdin  scanf ) 31

32 Algunas Funciones de Entrada/Salida int fprintf(FILE *stream, const char *format,...) Imprime datos en un flujo de salida con el formato dado. Retorna el nro. de caracteres escritos o un valor negativo si hubo error. ( fprintf usado con stdout  printf ) 32

33 Algunas Funciones de Entrada/Salida void rewind(FILE *stream) Coloca el apuntador al comienzo del archivo de un flujo de datos. int fclose(FILE *stream) Cierra la conexión entre un archivo y su apuntador, dejando libre al apuntador para ser usado, si fuera necesario, con un nuevo archivo. Limpia el buffer. Retorna 0 si tuvo éxito, sino EOF. 33

34 #include int main() { char str1[10], str2[10]; int year; FILE * fp1, *fp2; fp1 = fopen ("file1.txt", "w+"); fp2 = fopen ("file2.txt", "w"); fputs("Estamos en 2014", fp1); rewind(fp1); fscanf(fp1, "%s %s %d", str1, str2, &year); fprintf(fp2, "String1 leido |%s|\n", str1 ); fprintf(fp2, "String2 leido |%s|\n", str2 ); fprintf(fp2, "Entero leido |%d|\n", year ); fclose(fp1); fclose(fp2); return(0); } 34

35 Algunas Funciones de Entrada/Salida int fgetc(FILE *stream) int getc(FILE *stream) Lee y retorna el próximo caracter en un flujo de entrada avanzando el apuntador al próximo carácter en el flujo de entrada. ( getc/fgetc usado con stdin  getchar ) 35

36 Algunas Funciones de Entrada/Salida int fputc(int char, FILE *stream) int putc(int char, FILE *stream) Escribe un caracter especificado por el argumento char en el flujo especificado y avanza la posición del apuntador en el flujo. Retorna el carácter escrito si no hubo error, sino EOF. ( putc/fputc usado con stdout  putchar ) 36

37 Ejemplo /* filecopy: copia archivo ifp a archivo ofp */ void filecopy(FILE *ifp, FILE *ofp){ int c; while ((c = getc(ifp)) != EOF) putc(c, ofp); } 37

38 Algunas Funciones de Entrada/Salida char *fgets(char *str, int n, FILE *stream) Lee una línea de un flujo y la almacena en el string apuntado por str. Para cuando leyó ( n-1 ) caracteres o leyó ‘\n’ o se alcanzó el fin de archivo (lo que ocurra primero). Retorna la línea leída; si lee el fin del archivo u ocurre algún error durante la lectura retorna NULL. ( fgets usado con stdin  gets ) 38

39 Algunas Funciones de Entrada/Salida int fputs(const char *str, FILE *stream) Escribe un string, sin \0, en un flujo de salida. Retorna un entero positivo, o EOF si hubo error. ( fputs usado con stdout  puts ) 39

40 int main(){ FILE *fp; char str[60]; fp = fopen("file2.txt", "r"); if(fp == NULL) { perror("Error al abrir file2.txt"); return(-1); } while (fgets(str, 60, fp) != NULL) fputs(str, stdout); fclose(fp); return(0); } 40

41 Parámetros de un Programa Muchas veces, resulta necesario al invocar un programa para su ejecución, desde la línea de comandos, pasarle argumentos de entrada. Ejemplo: Programa echo que reproduce sus argumentos de la línea de comandos, en una línea aparte, separados por blancos: $ echo hello, world imprime en la pantalla: hello, world ¿Cómo lo hacemos? Por medio de los parámetros del programa int main(int argc, char *argv[]); 41

42 Parámetros de un Programa Ejemplo 42 argc3 argv[0] argv[1] argv[2] argv[3]NULL ‘e’‘c’‘h’‘o’‘\0’ ‘h’‘e’‘l’ ‘o’‘,’‘\0’ ‘w’‘o’‘r’‘l’‘d’‘\0’ $ echo hello, world

43 Parámetros de un Programa Ejemplo 43 #include /* comando echo */ main(int argc, char *argv[]){ int i; for (i = 1; i < argc; i++){ printf(”%s”, argv[i]); if (i < argc-1) printf(” ”); } printf("\n"); return 0; }