MÓDULO 9
---------------------------- --------------------- #include //para el sistema () # include ... {códigos C ++ ...} --------- ---------------------------------------- debe ser cambiado a: ----- -------------------------------------------- #include //uso de C ++ envoltorio para llamar a funciones de C de los programas en C ++ ... #include using namespace std; ... {Códigos C ++ ...} ---------------------------------------- --------- En VC ++ /VC ++ .Net la iostream.h (encabezado con .h) ya no es válida. Debe ser cabecera de C ++, de manera que cumpla con el estándar.
En mayor compilador Borland C ++ esto todavía funciona, pero no adecuado más ... y por estándar de C /C ++ de la portabilidad debe ser ningún problema o mejor que leer Module23 en https://www.tenouk.com/Module23.html llegar el panorama ... Para los códigos C, todavía códigos C: o) ================================= ======================================== ========== ================================================== ============= //Abrir y cerrar archivo de ejemplo #include #include //ÉXITO = 0, FALLO = 1 usando enumeración enumeración {ÉXITO, FALLO}; int main (void) {FILE * fptr; //el nombre del archivo es tkk1103.
txt y situado //en la misma carpeta que este carbón programa de nombre de archivo [] = "tkk1103.txt"; //establecer el reval valor a 0 int reval = ÉXITO; //abrir el archivo de prueba para la lectura, si falla ... if ((fptr = fopen (nombre de archivo, "r")) == NULL) {printf (, nombre de archivo "\\ n No se puede abrir% s."); reval = FALLO; //restablecer reval al 1} //si tiene éxito lo hacen ... else {printf ("Abrir el archivo% s satisfactoriamente \\ n", nombre de fichero); //el programa mostrará la dirección donde //el puntero de archivo para ..
printf ("El valor de fptr: 0x% p \\ n", fptr); printf ("\\ n .... procesamiento de archivos se debe hacer aquí .... \\ n"); printf ("\\ nReady para cerrar el archivo% s. \\ n", nombre de fichero); //cerrar el flujo de archivos ... si (fclose (fptr) == 0) printf ("Cierre el archivo% s satisfactoriamente \\ n", nombre de fichero); } //Para Borland ... puede eliminar la siguiente pausa y la biblioteca, //stdlib.h para el sistema de otros compiladores ("pause"); volver reval; } ------------------------------ Testtwo.
txt ---------------- ---------------------------------- APERTURA, LECTURA, ESCRITURA Y CIERRE ARCHIVO -------- ----------------------------------- Archivo de la prueba. Este archivo nombrado testtwo.txt. Después de abrir los archivos para la lectura y la escritura, sin error, el contenido de este archivo (testtwo.txt) será leído y salida (escritura) a otro archivo llamado testone.
txt y salida estándar (pantalla /consola) carácter por carácter !!! --- FELIZ APRENDIZAJE GENTE !!! ---- ------------------------------------- -------------------------------------------------- ----- //Lectura y escritura de un carácter a la #include #include tiempo //tipo de datos enumerados, ÉXITO = 0, FALLO = 1 enum {ÉXITO, FALLO}; //función prototipo para leer y escribir ... vacío CharReadWrite (FILE * aleta, FILE * fout); int main () {//declarar dos apuntadores de archivo ... FILE * fptr1, * fptr2; //definir el nombre de dos archivos ... Char nombrearchivo1 [] = "testone.
txt"; charlas nombrearchivo2 [] = "testtwo.txt"; int reval = ÉXITO; //probar la nombrearchivo1 apertura para escribir .... //si falla .... si ((fptr1 = fopen (nombrearchivo1, "w")) == NULL) {printf ("El problema, no puede abrir% s. \\ n ", nombrearchivo1); reval = FALLO; } //Si abrir nombrearchivo1 para la escritura se realiza correctamente, //test para la apertura de la lectura nombrearchivo2, si falla ... else if ((fptr2 = fopen (nombrearchivo2, "r")) == NULL) {printf ("Problema, no puede abrir% s \\ n ", nombrearchivo2).
; reval = FALLO; } //Si exitosa apertura para la lectura de nombrearchivo2 //y escribir en nombrearchivo1 ... else {//llamada a la función para la lectura y la escritura ... CharReadWrite (fptr2, fptr1); //cerrar ambos archivos ... si (fclose (fptr1) == 0) printf ("% s \\ estrecha con éxito n", nombrearchivo1); si (fclose (fptr2) == 0) printf ("% s \\ estrecha con éxito n", nombrearchivo2); } //Para Borland si se compila utilizando su IDE ...
Sistema ("pause"); volver reval; } //Leer definición de la función de escritura nula CharReadWrite (FILE * aleta, FILE * fout) {int c; //si se alcanza el final del archivo, do ... while ((c = fgetc (fin)) = EOF!) {//escribir a un archivo ... fputc (c, fout); //visualización en la pantalla ... putchar (c); } Printf ("\\ n"); } ------------------------------------ Testfour.txt ---------- --------------------------- APERTURA, leer, escribir una línea de caracteres -------------- -------------------------------------- Este es el archivo testfour.txt.
El contenido de este archivo se lee línea por línea de caracteres hasta no más línea de carácter encontrado. Entonces, será la salida a la pantalla, y también será copiado en presentar testhree.txt. Compruebe el contenido del archivo testhree.txt ... --------------------------------------- ------------- ------------------QUE TENGAS UN BUEN DÍA--------------- ---- ---------------------------------------------- --------------------------------------- //Lectura y escritura de una línea a la vez # incluir #include enum {ÉXITO, FALLO, MAX_LEN = 100}; //prototipo de función para lectura y escribe a línea .
.. vacío LineReadWrite (FILE * aleta, ARCHIVO fout *); int main (void) {FILE * fptr1, * fptr2; //archivo testhree.txt se encuentra en la raíz, c: //usted puede poner este archivo en cualquier lugar siempre //usted proporciona la ruta completa, lo mismo para testfour.txt carbón nombrearchivo1 [] = "c: \\\\ testhree. TXT"; Char nombrearchivo2 [] = "c: \\\\ testfour.txt"; Char reval = ÉXITO; //test abrir testhree.txt archivo para escribir, si falla ... if ((fptr1 = fopen (nombrearchivo1, "w")) == NULL) {printf ("El problema, no puede abrir% s para escritura.
\\ n" , nombrearchivo1); reval = FALLO; } //Abrir testfour.txt archivo para lectura, si falla ... else if ((fptr2 = fopen (nombrearchivo2, "r")) == NULL) {printf ("El problema, no puede abrir% s para la lectura de la prueba \\. n ", nombrearchivo2); reval = FALLO; } //Si la apertura de la escritura y la lectura de aquí para allá con éxito, hacer ... else {//llamada a la función para la lectura y escritura, línea por línea ... LineReadWrite (fptr2, fptr1); //cerrar ambos archivos de flujo de ... si (fclose (fptr1) == 0) printf ("% s cerrado con éxito.
\\ n", nombrearchivo1); si (fclose (fptr2) == 0) printf ("% s cerrado con éxito. \\ n", nombrearchivo2); } //Para el sistema Borland captura de pantalla ("pause"); volver reval; } //Definición de función para lectura de línea, escribir ... vacío LineReadWrite (FILE * aleta, FILE * fout) {//variable local ... buff char [MAX_LEN]; while (! fgets (piel de ante, MAX_LEN, fin) = NULL) {//escribir en el archivo ... fputs (piel de ante, fout); //escribir a la pantalla ... printf ("% s", buff); }} ----------------------------------------- Testsix.
txt ---- ------------------------------------------ APERTURA, LECTURA Y ESCRITURA A UNA CUADRA DE DATOS ----------------------------------------------- Esto es presentar testsix.txt. Su contenido será leída y luego la salida a la pantalla /consola y copiada a testfive.txt archivo. La lectura y la escritura basan en bloque de datos. Puede ser que este método es más rápido en comparación con lectura /escritura por carácter, por la línea .....
----------------------------- ------------------ ------------------FIN------------- ------------- ------------------------------------- -------------------------------------------------- ----------- //Lectura y escritura de un bloque a la #include #include //tiempo de declarar el tipo de datos de enumeración, se esta //aprender en otro módulo ... enum {ÉXITO, FALLO, MAX_LEN = 80}; //prototipo de la función para la lectura y la escritura de bloque vacío BlockReadWrite (FILE * aleta, ARCHIVO fout *); //prototipo de la función de mensajes de error ...
int ErrorMsg (char * str); int main (void) {FILE * fptr1, * fptr2; //definir los nombres de archivo ... //la ubicación de archivos está en c: \\ Temp carbón nombrearchivo1 [] = "c: \\\\ temp \\\\ testfive.txt"; Char nombrearchivo2 [] = "c: \\\\ temp \\\\ testsix.txt"; int reval = ÉXITO; //abrir testfive.txt archivo para escribir, si falla ... if ((fptr1 = fopen (nombrearchivo1, "w")) == NULL) {reval = ErrorMsg (nombrearchivo1) de prueba; } //Abrir testsix.txt archivo para lectura, si falla ...
else if ((fptr2 = fopen (nombrearchivo2, "r")) == NULL) {reval = ErrorMsg (nombrearchivo2) de prueba; } //Si la apertura de los archivos para la escritura y la lectura es correcta, hacer ... else {//función de llamada para leer y escribir BlockReadWrite (fptr2, fptr1); //cerrar ambas corrientes archivos ... si (fclose (fptr1) == 0) printf ("% s con éxito cerrado \\ n", nombrearchivo1); si (fclose (fptr2) == 0) printf ("% s con éxito cerrado \\ n", nombrearchivo2); } Printf ("\\ n"); //para Borland ...
Sistema ("pausa"); volver reval; } //Definición de función para el bloque de lectura, escritura nula BlockReadWrite (FILE * aleta, FILE * fout) {int num; Char buff [MAX_LEN + 1]; //mientras no termina de archivo para el archivo de entrada, do ... while {//leyendo ... num = fread (piel de ante, sizeof (char), MAX_LEN, fin) (feof (fin)!); //anexar un aficionado carácter nulo [num * sizeof (char)] = '\\ 0'; printf ("% s", buff); //escribir ...
fwrite (piel de ante, sizeof (char), num, fout); }} //Definición de la función de mensaje de error int ErrorMsg (char * str) {//mostrar el mensaje de error ... printf ("El problema, no puede abrir% s. \\ N", str); volver FALLO; } -----------------------------------------tesseven.txt------------------------------------------------------ ESTA ES LA PRIMERA LÍNEA DE TEXTO, tesseven.txt archivo Esta es la segunda línea de texto, tesseven.txt archivo Esta es la tercera línea de texto, tesseven.txt archivo ESTA ES LA LÍNEA DE CUARTA TEXTO, tesseven.
txt archivo - -------------------------------------------------- -------------------------------------------- //acceso aleatorio a un presentar #include #include enum {ÉXITO, FALLO, MAX_LEN = 120}; //prototipos de funciones, buscan el indicador de posición del fichero vacío PtrSeek (FILE * fptr); //prototipo de función, dice el indicador de posición del fichero ... larga PtrTell (FILE * fptr); //prototipo de función lee y escribe ... anulará DataRead (FILE * fptr); int ErrorMsg (char * str); int main (void) {FILE * fptr; Char nombre [] = "c: \\\\ temp \\\\ tesseven.
txt"; int reval = ÉXITO; //si hay algún archivo de la apertura para la lectura de error ... si ((fptr = fopen (nombre de archivo, "r")) == NULL) {reval = ErrorMsg (nombre de fichero); } //Si la apertura es exitosa ... else {//PtrSeek () llamada a la función ... PtrSeek (fptr); //cerrar el flujo de archivos ... si (fclose (fptr) == 0) printf ("% s cerrado con éxito. \\ n", nombre de fichero); } //Para Borland ...
Sistema ("pause"); volver reval; } //PtrSeek () definición de la función void PtrSeek (FILE * fptr) {Offset1 largo, Desplz2, Offset3, offset4; Offset1 = PtrTell (fptr); DataRead (fptr); Desplz2 = PtrTell (fptr); DataRead (fptr); Offset3 = PtrTell (fptr); DataRead (fptr); offset4 = PtrTell (fptr); DataRead (fptr); printf ("\\ nReread la tesseven.txt, en orden aleatorio: \\ n"); //releer la segunda línea de la fseek tesseven.txt (fptr, Desplz2, SEEK_SET); DataRead (fptr); //releer la primera línea de la fseek tesseven.
txt (fptr, Offset1, SEEK_SET); DataRead (fptr); //releer la cuarta línea de la fseek tesseven.txt (fptr, offset4, SEEK_SET); DataRead (fptr); //releer la tercera línea de la fseek tesseven.txt (fptr, Offset3, SEEK_SET); DataRead (fptr); } //PtrTell () definición de la función a largo PtrTell (FILE * fptr) {long reval; //decir la posición fptr ... reval = ftell (fptr); printf ("El fptr está en% ld \\ n", reval); volver reval; } //DataRead () definición de la función void DataRead (FILE * fptr) {buff char [MAX_LEN]; //leer línea de texto en la posición fptr ...
fgets (piel de ante, MAX_LEN, fptr); //y mostrar el texto ... printf ("->% s \\ n", buff); } //Error definición de la función de mensajes int ErrorMsg (char * str) {//mostrar este mensaje de error ... printf ("El problema, no puede abrir% s. \\ N", str); volver FALLO; } ------------------------------------------------- ------------------------------------------- //Lectura, escritura, rebobinado y datos binarios #include #include enum {ÉXITO, FALLO, MAX_NUM = 5}; //funciones prototipo ...
vacío Datawrite (FILE * fout); anular DataRead (FILE * fin); int ErrorMsg (char * str); int main (void) {FILE * fptr; //archivos de tipo binario ... Char nombre [] = "c: \\\\ temp \\\\ teseight.bin"; int reval = ÉXITO; //test para crear, abrir archivo binario para escribir ... si ((fptr = fopen (nombre, "wb +")) == NULL) {reval = ErrorMsg (nombre de fichero); } Else {//datos de escritura en un archivo teseight.bin Datawrite (fptr); //restablecer el indicador de posición del fichero ... rebobinado (fptr); //leer datos ... DataRead (fptr); //cerrar el flujo de archivos ...
si (fclose (fptr) == 0) printf ("% s con éxito cerrado \\ n", nombre de fichero); } //Para el sistema de Borland ("pause"); volver reval; } //Datawrite () definición de la función void Datawrite (FILE * fout) {int i; doble buff [MAX_NUM] = {145.23, 589.69, 122.12, 253.21, 987.234}; printf ("El tamaño de aficionado:% d bytes \\ n", sizeof (buff)); for (i = 0; i {printf ("% 5.
2f \\ n", buff [i]); fwrite (y buff [i], sizeof (doble), 1, fout);}} //DataRead () definición de función anular DataRead (FILE * fin) {int i; dobles x; printf ("\\ nReread del archivo binario: \\ n"); for (i = 0; i {fread (& X, sizeof (doble), (size_t) 1 , fin); printf ("% 5.2f \\ n", x);}} //ErrorMsg () definición de la función int ErrorMsg (char * str) {printf ("No se puede abrir% s. \\ n", str); retorno FALLO;} --------------------------------------- testcal.
txt ----- ---------------------------------- 23 12 33 10 4 6 44 31 7 50 ------ -------------------------------------------------- --------------------------------- /* Programa C para calcular el promedio de una lista de números. * //* calcular el total de un archivo, la salida de la media * //* en otro archivo * /#include /* para la salida () * # include (void) {valor int main int /, el total = 0, count = 0; /* fileptrIn y fileptrOut son variables de tipo (FILE *) * /FILE * fileptrIn, * fileptrOut; Char filenameIn [100], filenameOut [100]; printf ("Introduzca un nombre de archivo de entrada (usar ruta si es necesario): \\ n" ); scanf ("% s", filenameIn); printf ("Introduzca un nombre de archivo de salida (usar ruta si es necesario): \\ n"); scanf ("% s", filenameOut); /* archivos abiertos para leer, "r" y la escritura, "w" * /if ((fileptrIn = fopen (filenameIn, "r")) == NULL) {printf ("Error al abrir% s para la lectura.
\\ n" , filenameIn); exit
(1); } Else printf ("Abriendo% s para la lectura está bien. \\ N", filenameIn); if ((fileptrOut = fopen (filenameOut, "w")) == NULL) {printf ("Error al abrir% s para escritura. \\ n", filenameOut); exit
(1); } Else printf ("Abriendo% s para escritura está bien. \\ N", filenameOut); /* fscanf * /printf ("\\ nCalculate total ... \\ n"); while (EOF = fscanf (fileptrIn, "% i", y valor)!) {total de + = valor; ++ contar; } /* fin del bucle while * //* Escriba el valor medio en el fichero * //* fprintf * /printf ("Calcular la media ... \\ n \\ n.
"); fprintf (fileptrOut, "la media de% i números =% f \\ n", cuenta, /(doble) recuento total); printf ("La media de% i números =% f \\ n \\ n", cuento, /(doble) recuento total); printf ("Check también su% s contenido del archivo \\ n", filenameOut); si (fclose (fileptrIn) == 0) printf ("% s closed \\ n éxito", filenameIn); si (fclose (fileptrOut) == 0) printf ("% s closed \\ n éxito", filenameOut); return 0; } ------------------------------------------------- -------------------------------------------- //Redirigir una corriente estándar #include #include enum {ÉXITO, FALLO, STR_NUM = 6}; void StrPrint (char ** str); int ErrorMsg (char * str); int main (void) {//declarar y definir un puntero a la cadena .
.. char * str [STR_NUM] = {"Redirigir una corriente estándar para el archivo de texto." "Estos 5 líneas de texto serán redirigidos", " tantas cosas que puede hacer si usted entiende el "," concepto, idea fundamental - prueba este "," -------------- HECHO ---------- ---------------- "}; Char nombre [] = "c: \\\\ temp \\\\ testnine.txt"; int reval = ÉXITO; StrPrint (str); //crear el archivo si no existe y abierto para escritura ... //si existe, deseche el contenido anterior ...
si (freopen (nombre de archivo, "w", stdout) == NULL) {reval = ErrorMsg (nombre de fichero); } Else {//llame StrPrint función () ... StrPrint (str); //cerrar la salida estándar ... fclose (stdout); } Return reval; } //StrPrint () definición de la función void StrPrint (char ** str) {int i; for (i = 0; i //estándar de pantalla de salida /console ... printf ("% s \\ n", str [i]), sistema ("pause");} //ErrorMsg () Función definición int ErrorMsg (char * str) {printf ("El problema, no puede abrir% s.
\\ n", str); volver FALLO;} ---------------------- -------------------------------------------------- -------------- //Demostrar la #include remove () función #include void main () {//declarar una matriz para almacenar el nombre de archivo ... Char nombre [80]; printf ("Introduzca el nombre del archivo que desea eliminar:"); gets (nombre de fichero); //comprobar cualquier error ... si (Eliminar (nombre del archivo) == 0) printf (". El archivo% s ha sido eliminado \\ n", nombre de archivo ); lo demás fprintf (stderr, "Error al eliminar el archivo% s.
\\ n", nombre de archivo), sistema ("pause");} --------------------- -------------------------------------------------- ---------------- //Usando renombrar () para cambiar un nombre de archivo #include #include void main () {char nombre_antiguo [80], newname [80]; printf ("Enter nombre actual: "); gets (nombre_antiguo); printf (" Introduzca el nuevo nombre para el archivo: "); gets (newname), si (renombrar (nombre_antiguo, newname) == 0) {printf ("% s ha sido renombrar% s \\ n ", nombre_antiguo, newname).; } Else {fprintf (stderr, ".
Se ha producido un error renombrar% s \\ n", nombre_antiguo); } Del sistema ("pausa"); } ------------------------------------------------- ------------------------------------------- //Copia de un archivo #include #include int file_copy (char * nombre_antiguo, char newname *); void main () {fuente char [80], el destino [80]; //obtener el printf nombres de origen y destino ("archivo de origen \\ nNo:"); gets (fuente); printf ("archivo de destino \\ nNo:"); gets (destino); si (file_copy (origen, destino) == 0) puts ("operación de copia con éxito"); otra cosa fprintf (stderr, "Error de operación de copia"); del sistema ("pausa"); } Int file_copy (char * nombre_antiguo, char * newname) {FILE * veces, * fNew; int c; //Abrir el archivo de origen para la lectura en modo binario if ((fold = fopen (nombre_antiguo, "rb")) == NULL) return -1; //Abrir el archivo de destino para escribir en modo binario si ((= fNew fopen (newname "wb")) == NULL) {fclose (veces); devuelve -1; } //Lee un byte a la vez de la fuente, si //no se ha alcanzado el final del archivo, escriba el byte al destino while
(1) {c = fgetc (veces); if (! feof (fold)) fputc (c, fNew); ruptura más; } Fclose (fNew); fclose (veces); return 0; } ------------------------------- Testfour.
txt --------------- --------------------- ------------------ LINUX LOR! -------- ---------------- ------------ FEDORA 3, xxx gcc ----------------- --- APERTURA, leer, escribir una línea de caracteres -------------------------------------- -------------- Este es el archivo testfour.txt. El contenido de este archivo se lee línea por línea de caracteres hasta no más línea de carácter encontrado. Entonces, será la salida a la pantalla, y también será copiado en presentar testhree.txt. Compruebe el contenido del archivo testhree.txt ...
--------------------------------------- ------------- ------------------QUE TENGAS UN BUEN DÍA--------------- ---- ---------------------------------------------- --------------------------------- /***************línea de lectura .c ************ /* Leer y escribir una línea a la vez * /#include #include enum {ÉXITO, FALLO, MAX_LEN = 100}; /* prototipo de función para lectura y escribe a línea ... * /void LineReadWrite (FILE * aleta, FILE * fout); int main (void) {FILE * fptr1, * fptr2; /* archivo testhree.txt se encuentra en el directorio actual.
usted puede poner este archivo en cualquier lugar siempre que se proporcione la ruta completa, lo mismo para testfour.txt * /char nombrearchivo1 [] = "testhree.txt"; charlas nombrearchivo2 [] = "testfour.txt"; Char reval = ÉXITO; /* abrir testhree.txt archivo para escribir, si fallan ... * /if ((fptr1 = fopen (nombrearchivo1, "w")) == NULL) {printf ("El problema, no puede abrir% s para escritura de ensayo. \\ n ", nombrearchivo1); reval = FALLO; } /* Prueba de apertura testfour.txt archivo para lectura, si falla ...
* /else if ((fptr2 = fopen (nombrearchivo2, "r")) == NULL) {printf ("El problema, no puede abrir% s para la lectura . \\ n ", nombrearchivo2); reval = FALLO; } /* Si la apertura de la escritura y la lectura de aquí para allá con éxito, hacer ... * /else {/* llamada a la función para la lectura y escritura, línea por línea ... * /LineReadWrite (fptr2, fptr1); /* cerrar ambos archivos de flujo de ... * /if (fclose (fptr1) == 0) printf ("% s cerraron con éxito. \\ n", nombrearchivo1); si (fclose (fptr2) == 0) printf ("% s cerrado con éxito.
\\ n", nombrearchivo2); } Return reval; } /* Definición de la función de lectura de línea, escribir * /void LineReadWrite (FILE * aleta, FILE * fout) {variable local /* ... * /char buff [MAX_LEN].; while (! fgets (piel de ante, MAX_LEN, fin) = NULL) {/* escribir en el archivo ... * /fputs (piel de ante, fout); /* escritura en pantalla ... * /printf ("% s", buff); }} ------------------------------------------------ ---------------------------------------------- ////////////rwbinary.
c////////////////FEDORA 3, gcc xxx ///////Lectura, escritura, rebobinar y #include enumeración de datos binarios {ÉXITO, FALLO, MAX_NUM = 5}; //funciones prototipo ... vacío Datawrite (FILE * fout); anular DataRead (FILE * fin); int ErrorMsg (char * str); int main (void) {FILE * fptr; //archivos de tipo binario ... nombre char [] = "/testo1/testo2/teseight.bin"; int reval = ÉXITO; //test para crear, abrir archivo binario para escribir ... si ((fptr = fopen (nombre, "wb +")) == NULL) {reval = ErrorMsg (nombre de fichero); } Else {//datos de escritura en un archivo teseight.
bin Datawrite (fptr); //restablecer el indicador de posición del fichero ... rebobinado (fptr); //leer datos ... DataRead (fptr); //cerrar el flujo de archivos ... si (fclose (fptr) == 0) printf ("% s con éxito cerrado \\ n", nombre de fichero); } Return reval; } //Datawrite () definición de la función void Datawrite (FILE * fout) {int i; doble buff [MAX_NUM] = {145.23, 589.69, 122.12, 253.21, 987.234}; printf ("El tamaño de aficionado:% d bytes \\ n", sizeof (buff)); for (i = 0; i {printf ("% 5.
2f \\ n", buff [i]); fwrite (y buff [i], sizeof (doble), 1, fout);}} //DataRead () definición de función anular DataRead (FILE * fin) {int i; dobles x; printf ("\\ nReread del archivo binario: \\ n"); for (i = 0; i {fread (& X, sizeof (doble), (size_t) 1 , fin); printf ("% 5.2f \\ n", x);}} //ErrorMsg () definición de la función int ErrorMsg (char * str) {printf ("No se puede abrir% s. \\ n", str); retorno FALLAR; } ====================================================================================================;>;>.h>.h>.h>.h>.h>.h>.h>.h>.h>;>.h>.h>.h>.h>;>;>.h>.h>.h>.h>.h>.h>.h>.h>.h>.h>.
h>.h>.h>.h>