PDF de programación - Programación I Teoría : Entrada/Salida - Archivos

Imágen de pdf Programación I Teoría : Entrada/Salida - Archivos

Programación I Teoría : Entrada/Salida - Archivosgráfica de visualizaciones

Publicado el 29 de Diciembre del 2019
680 visualizaciones desde el 29 de Diciembre del 2019
301,5 KB
43 paginas
Creado hace 6a (22/05/2017)
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
  • Links de descarga
http://lwp-l.com/pdf17092

Comentarios de: Programación I Teoría : Entrada/Salida - Archivos (0)


No hay comentarios
 

Comentar...

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad