Programación Científica Dr. Romeo Sánchez Nigenda. E-mail: romeo.sanchez@gmail.com http://yalma.fime.uanl.mx/~romeo/ Oficina: 1er. Piso del CIDET. Oficina con Dr. Oscar Chacón Horas de Tutoría: 10am-11am Martes y Jueves Website: http://yalma.fime.uanl.mx/~romeo/ Sesiones: 48 * Slides aumentados con información de Dr. Roger Ríos, y Dr. Fernando López

Fundamentos de Programación en C Apuntadores y Funciones 40% Proyecto 30% Examen Parcial 30% Examen Final 10% Participación Temario: Fundamentos de Programación en C Apuntadores y Funciones Arreglos y Estructuras Manejo de Memoria Recursividad Entrada y Salida de Archivos Desarrollo y Depuración de Proyecto de Programación Total a calificar: 110 puntos!

Material de apoyo: Software: A. KELLY, I. POHL. A Book on C. Addison-Wesley, Reading, EUA, 1998. 2. B. KERNIGHAN, D. RITCHIE. The C Programming Language. Prentice Hall, Second Edition, 1988. 3. D. KNUTH. The Art of Computer Programming. Addison Wesley, 1998. 4. H. DEITEL, P. DEITEL. Como Programar en C/C++. Prentice Hall, Segunda Edición. 1995. 5. L. Joyanes, I. Zahonero. Programación en C - Metodología, Algoritmos y Estructura de Datos. McGraw Hill-Interamericana, 2006. 6. B. Stroustrup. The C++ Programming Language. Addison Wesley. Third Edition. 1997. Software: Compiladores GCC (GNU Compiler Collection) IDEs (Integrated Development Environment): http://www.eclipse.org/downloads/ http://kdevelop.org/ http://www.bloodshed.net/devcpp.html

Entradas y Salidas por Archivos Objetivo General: Aprender a utilizar las características típicas de los mecanismos de Entrada y Salida para archivos en C, así como las funciones de acceso más utilizadas.

Preliminares Lectura: Es la operación de introducir (leer) datos al sistema. Se realiza usualmente desde el teclado, el disco, o cualquier otro dispositivo de entrada Escritura: Se relaciona a la operación de generar datos por el sistema. Se realiza usando cualquier dispositivo de salida como monitor o impresora. En C las funciones para entrada y salida están incorporadas como Biblioteca de Ejecución. stdio.h: proporciona tipos de datos, macros y funciones para acceder a archivos. El manejo de archivos se hace a través de flujos (streams) o canales, que conducen los datos entre el programa en ejecución y los dispositivos externos.

Flujos Un flujo (stream) es una abstracción que refiere a una corriente de datos entre un origen o fuente (productor) y un destino (consumidor). Entre el origen y destino debe existir una conexión o canal (pipe) por donde circulan los datos. Por ejemplo: extern FILE *stdout; Es el flujo que asocia la salida estándar (pantalla) con el programa. Cuando ejecutamos: printf(“Ejemplo en clase.”); Se escriben los datos en stdout, es decir, en pantalla.

Punteros FILE Los archivos se ubican en dispositivos externos, y se utilizan buffers para accesarlos: Dentro del programa, se hace referencia a los archivos usando punteros a una estructura predefinida: FILE FILE contiene información sobre el archivo tal como la dirección del buffer que utiliza, su modo de apertura, etc. FILE se encuentra en stdio.h.

Ejemplos: Declaración de punteros a FILE: FILE * pfile; FILE * stdin, stdout; En funciones: FILE * escribir(FILE *); Apertura de archivos: Conexión del archivo externo con el programa en un determinado modo (e.g., binario, de texto). Se utiliza la función: FILE * fopen(const char * nombre_archivo, const char * modo) Ejemplo: char nombre_archivo = “C:\test.txt”; FILE * pfile = fopen(nombre_archivo, “r”); if(pfile==NULL) puts(“ERROR al abrir el archivo…”);

Modos de apertura de un archivo Descripción r Abre para lectura w Crea un archivo nuevo, si existe se pierden sus datos a Abre para añadir al final del archivo r+ Abre archivo existente para leer o escribir w+ Crea un archivo para leer o escribir, si existe se pierden sus datos a+ Abre archivo para leer o escribir al final. Si no existe es como w+ Tipo de archivos: Texto: Se utiliza una “t” al final, e.g., “rt”, “a+t” Binario: Se utiliza una “b”, eg., “rb”, “w+b”.

Cierre de archivos Los archivos en C trabajan con una memoria intermedia conocida como buffer. La entrada y salida de datos se almacenan en ese buffer, vaciándose a los archivos cuando están llenos. Al terminar la ejecución del programa se tienen que cerrar los archivos para que cualquier dato en los buffers se vacíe a los archivos. int fclose (FILE * pfile) Devuelve EOF si hay un error al cerrar. Es una macro definida en stdio.h para indicar que se ha leído el fin del archivo.

Manejo de archivos secuenciales Las funciones de E/S de archivos tienen mucho parecido con las funciones de E/S para los flujos stdin (teclado) y stdout (pantalla): printf, scanf, getchar, putchar, gets, puts, putc, getc antecediendo la letra f, ejemplo: fprintf, fscanf, fputc, fgetc, etc. Ejemplo: Crea un archivo de texto con caracteres introducidos desde teclado, utiliza enter para parar. char * nfile = "test.txt"; FILE * pf = fopen(nfile,"w+t"); if(pf==NULL){ puts("Error al abrir archivo!"); exit(0); }else{ int c; do{ c=getchar(); fputc(c,pf); }while(c!='\n'); fclose(pf); }

Manejo de archivos secuenciales Ejemplo: Lectura de archivos secuenciales. Lee un archivo y muestra sus caracteres en pantalla. Termina cuando se encuentre el fin del archivo (EOF). FILE * pf; char * nfile = "test.txt"; pf = fopen(nfile,"rt"); if(pf==NULL){ puts("Error abriendo archivo."); return 1; }else{ int c; do{ c=fgetc(pf); if(c=='\n') printf("\n"); else putchar(c); }while(c!=EOF); //Puedes utilizar feof()! fclose(pf); }

Manejo de archivos secuenciales Ejemplo: Manipulando cadenas de caracteres, funciones fputs() y fgets(). fputs() escribe la cadena en el archivo asociado, devuelve EOF si no ha podido escribirla fgets() lee una cadena del archivo, termina su lectura cuando encuentra el carácter de fin de línea, o cuando ha leído n-1 caracteres si se especifica n en sus argumentos. Ejemplos: Lee los primeros 10 caracteres de un archivo, y los coloca en un segundo. FILE * pf, *pf2; char * nfile = "test.txt"; char * nfile2 = "test2.txt"; pf = fopen(nfile,"rt"); pf2 = fopen(nfile2,"wt"); char cadena[10]; if(pf==NULL || pf2==NULL){ puts("Error abriendo archivos."); return 1; }else{ fgets(cadena,10,pf); fputs(cadena,pf2); fclose(pf); fclose(pf2); }

Manejo de archivos secuenciales Ejemplo: Manipulando variables de cualquier tipo de dato estándar usando códigos de formato (%d, %f, etc) con los flujos asociados, fprint() y fscanf(). fprintf() escribe datos en secuencia en el archivo asociado formateados según los argumentos de la función. Retorna el número total de caracteres impresos si tuvo éxito, o un número negativo en caso contrario. fscanf() lee datos formateados de un archivo asociado, y los almacena según el formato dado en variables adicionales pasadas como parámetros a la función. Ejemplos: char * nfile2 = "test2.txt"; FILE *pf2 = fopen(nfile2,"w+"); if(pf2==NULL){ puts("Error abriendo archivos."); return 1; }else{ fprintf(pf2,"%f %s",3.1416f,"PI"); rewind(pf2); //Coloca el indicador de posición al principio float valorpi; char descripcion [100]; fscanf(pf2,"%f",&valorpi); fscanf(pf2,"%s",descripcion); printf("Valores leidos del archivo: %f %s",valorpi,descripcion); fclose(pf2); }

Resumen de Prototipo de funciones Las funciones de E/S se encuentran definidas en la librería stdio.h. int putc(int c, FILE * pf); int fputc(int c, FILE * pf); int getc(FILE * pf); int fgetc(FILE * pf); int fputs(char * cadena, FILE * pf); char * gets(char * cadena, int n, FILE * pf); int fprintf(FILE * pf, const char * formato, …); int fscanf(FILE * pf, const char * formato, …); int feof(FILE * pf);

Archivos binarios En C son secuencias de 0s y 1s. Optimizan la memoria ocupada por un archivo: En modo texto primero se convierte el valor numérico en una cadena de dígitos y después se escribe en el archivo. Sin embargo, la lectura de archivos binarios se tiene que realizar desde un entorno de un programa en C. C proporciona dos funciones de entrada y salida para archivos binarios: fread() y fwrite().

Archivos binarios fwrite(): Escribe un buffer de cualquier tipo de dato en un archivo binario. fwrite(const void * ptr, size_t tam, size_t n, FILE *pf) ptr: Puntero al buffer (e.g., arreglo, variable) que contiene los datos tam: Tamaño del tipo de datos de cada elemento del buffer n: Número de elementos a escribir pf: Puntero al archivo Ejemplo: Elevar una variable real al cuadrado y guardar los resultados en un archivo binario FILE *fd; double x; fd = fopen(“numeros.dat","wb"); for(x=0.5;x>0.01;){ fwrite(&x, sizeof(double), 1,fd); x = pow(x,2.0); } fclose(fd);

Archivos binarios fread(): Lee un archivo de n bloques de bytes y los almacena en un buffer. . fread(void * ptr, size_t tam, size_t n, FILE *pf) ptr: Puntero al buffer donde se depositarán los datos tam: Tamaño del tipo de datos de cada elemento a leer n: Número de elementos a leer pf: Puntero al archivo Ejemplo: Leer los cuadrados de los números reales del ejemplo anterior. FILE *fd; double x, suma; fd = fopen(“numeros.dat","wb"); while(!eof(fd)){ fread(&x, sizeof(double), 1,fd); } fclose(fd);

Ejemplo fread, fwrite typedef struct { char nombre[SIZEOFNAME]; int idacc; float limite; float balance; float cargos; float creditos; } ACCOUNT; ACCOUNT accounts[TOTALCUENTAS], acc; //…Asume que el arreglo de cuentas ha sido //inicializado con datos hasta TOTALCUENTAS FILE *fw, *fr; //Abre archivo para escritura, asume no error fw = fopen("cuentas.dat","wb");

Ejemplo fread, fwrite //Escribe todos los datos del arreglo al archivo fwrite(accounts,sizeof(ACCOUNT),TOTALCUENTAS,fw); fclose(fw); //Ahora abre el mismo archivo para lectura de datos fr = fopen("cuentas.dat","rb"); while(!feof(fr)){ //Lee el archivo registro por registro if(fread(&acc,sizeof(ACCOUNT),1,fr)) printAccount(acc); } EJERCICIOS: Modifica la escritura para escribir registro por registro Modifica la lectura para leer todo el bloque de datos en una instancia

Acceso aleatorio El acceso aleatorio a los datos de un archivo se hace mediante su posición, es decir, el lugar relativo que estos ocupan. Se pueden leer y escribir registros en cualquier orden y posición. Se tiene que programar la relación existente entre el contenido del registro y la posición que ocupa. Se utilizan las funciones fseek() y ftell().

Acceso aleatorio fseek(): Puede tratar un archivo en C como un array, situando el puntero de un archivo en una posición aleatoria dependiendo de sus argumentos. fseek(File * pf, long desplazamiento, int origen) El desplazamiento es el número de bytes a mover con respecto al origen. El origen es la posición desde la que se cuenta el número de bytes a mover. Toma tres valores: 0 : Desde el inicio del archivo (SEEK-SET) 1: Desde la posición actual del archivo (SEEK-CUR) 2: Desde el final del archivo (SEEK-END) Retorna 0 si es exitoso el posicionamiento

Acceso Aleatorio Ejemplo: //Solicita el numero de registro int regnum; ACCOUNT acc; cout<<“El numero de registro a visualizar:"; cin>>regnum; //Desplazate a la posicion del registro int result = fseek(fr,regnum*sizeof(ACCOUNT),SEEK_SET); if(result!=0){ cout<<"Error!"<<endl; }else{ //Lee e imprime el registro fread(&acc,sizeof(ACCOUNT),1,fr); printAccount(acc); }

Acceso aleatorio ftell(): Obtiene la posición actual del archivo. Devuelve la posición como el total de bytes desde el inicio del archivo. ftell(File * pf) Retorna -1L si un error ocurre Ejemplo: int result = fseek(fr,regnum*sizeof(ACCOUNT),SEEK_SET); long msize = ftell(fr); cout<<"Size "<<msize<<" sizeof account "<<sizeof(ACCOUNT)<<endl;