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

Entrada/Salida Nos referimos a la interacción del programa con su ambiente para leer (entrada) y escribir (salida) datos.

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 a la memoria principal. En las operaciones de salida, los bytes fluyen desde la memoria principal a un dispositivo de salida.

Entradas y Salidas Hasta ahora: Existen otras formas … Entrada: por teclado getchar: lee un caracter scanf: lee entradas con formato Salida: por pantalla printf: imprime datos con formato Existen otras formas …

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.

Redireccionamiento de Entrada y Salida Estándar Ej: programa sumador que suma números, leídos por medio de la función scanf. 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

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

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.

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.

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° 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.

Carácter de conversión Tipo del argumento Impreso como d,i int Número decimal. o Número en octal sin signo (sin cero inicial). x,X Número sin signo en hexadecimal (sin 0x o 0X inicial), usa abcdef o ABCDEF, respectivamente. u Número decimal sin signo. c Un caracter. s char * Imprime caracteres del string hasta encontrar un '\0' o el número de caracteres dados por la precisión. f double 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,E 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). g,G 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. p void * Puntero (representación dependiente de la implementación). % No se con-vierte ningún argumento Imprime un %

printf( ":%d:\n", 455 ); :455: printf( ":%i:\n", 455 ); printf( ":%d:\n", +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 ); 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:

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 ); 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:

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"); printf(":%.10s:\n", "hello, world"); :hello, wor: printf(":%-10s:\n", "hello, world"); printf(":%15s:\n", "hello, world"); : hello, world: printf(":%.15s:\n", "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 %

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.

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.

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.

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.

Tipo del correspondiente argumento 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). o Entero en octal (con o sin cero inicial) u Entero decimal sin signo unsigned int * x Entero hexadecimal octal (con o sin 0x o 0X inicial)

c Caracter char * s Cadena de caracteres (string), sin las comillas. 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.

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 );

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"

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

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, ...);

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

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)

Algunas Funciones de Entrada/Salida fscanf 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 con stdin  scanf) fprintf imprime datos con el formato dado en un flujo de salida. Retorna nro. de caracteres escritos o un valor negativo si hubo error. (fprintf en stdout  printf )

Algunas Funciones de Entrada/Salida fgetc getc lee y retorna el próximo caracter en un flujo de entrada; retorna EOF si alcanzó el fin del archivo o hubo error. (getc/fgetc con stdin  getchar) fputc putc escribe un caracter en un flujo de salida. Retorna el carácter grabado o EOF si hubo error. (putc/fputc con stdout  putchar)

Algunas Funciones de Entrada/Salida fgets lee la próxima línea (incluyendo el caracter newline) desde un flujo de entrada en un arreglo de caracteres; a lo sumo se leerán un n° dado de caracteres. La línea resultante es terminada con '\0'. Normalmente, fgets retorna la línea leída; si lee el fin del archivo u ocurre algún error durante la lectura retorna NULL. fputs escribe un string (que no debe contener un caracter de newline) en un flujo de salida y le agrega el newline. Retorna un entero positivo, o EOF si hubo error. (fputs con stdout  puts) fclose Cierra la conexión entre un archivo y su apuntador, dejando libre al apuntador para ser usado, si fuera necesario, con un nuevo archivo.

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[]);

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

Parámetros de un Programa Ejemplo #include <stdio.h> /* 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;