Archivos en C

[NoBass]

Hola, hace unos pocos meses que he empezado a curiosear por el  bonito mundo de la programación. Soy nuevo en el foro y por ahora no puedo aportar mas que dudas, espero que en un futuro no muy lejano pueda ser de ayuda a los que se encuentren en mi actual situación.

Dicho ésto, al lío:

Llevo días buscando y recopilando información acerca de cómo trabajar con archivos en lenguaje C. He encontrado bastante información a nivel básico acerca de:

-Lectura i escritura
-El variado elenco de funciones dedicadas a tales fines

Por ejemplo aquí:
https://kesquivel.files.wordpress.com/2013/08/ficheros2013.pdf
http://www.cs.buap.mx/~mrodriguez/MIS%20FRAMES/Files2.pdf
http://www.c.conclase.net/ficheros/?cap=002

He leído todo ésto con cariño y paciencia, pero muy a mi pesar, no he encontrado toda la información que deseo.

Entiendo que mis dudas, que ahora expongo, son de collejón, así que gracias por la paciencia de antemano.

1.-Si leo un archivo en binario (por ejemplo un pdf) y lo copio a otro archivo, que guardo como pdf, el documento resulta ilegible. Entiendo que ésto es porque el archivo original tiene un formato determinado, que al copiar bit a bit no se mantiene o que hay que interpretar de algún modo. Imagino la copia (bueno de hecho así la veo cuando la abro con el editor de texto) como una montaña absurda de caracteres descabellados que hay que organizar de algún modo, pero intuyo que es algo bastante complejo.

2.-Entonces ¿cómo se copia en C un archivo, manteniendo las características del mismo? Es decir: ¿Cómo se reproduce el clásico ctrl+c desde un programa escrito en C?

Lo que me gustaría es encontrar información acerca de éste y procesos similares, es decir, algo mas general acerca de cómo se construyen, organizan, leen e interpretan archivos de todo tipo.

Muchísimas gracias y saludos para todos.

NoBass
No groove

[class_OpenGL]

1.-Si leo un archivo en binario (por ejemplo un pdf) y lo copio a otro archivo, que guardo como pdf, el documento resulta ilegible. Entiendo que ésto es porque el archivo original tiene un formato determinado, que al copiar bit a bit no se mantiene o que hay que interpretar de algún modo. Imagino la copia (bueno de hecho así la veo cuando la abro con el editor de texto) como una montaña absurda de caracteres descabellados que hay que organizar de algún modo, pero intuyo que es algo bastante complejo.

Eso es rotundamente falso. Si abres un archivo en binario, copias byte a byte y lo guardas en otro archivo con la misma extensión, debería ser una copia exacta, y como tal, no debería haber problemas con la copia. Te dejo un código que copia exactamente un archivo a otro:

Código (c) [Seleccionar] Expandir

#include <string.h>
#include <stdio.h>

#define MAX_PATH 4096

int main() {
// Puedes poner MAX_PATH como quieras, o saber este valor a través de librerías
// no estándares
char ruta_entrada[MAX_PATH];
char ruta_salida[MAX_PATH];
FILE *entrada;
FILE *salida;
char byte;
int salir = 0;

// Obtenemos rutas
fprintf(stdout, "Introduzca la ruta del archivo a copiar: ");
fgets(ruta_entrada, MAX_PATH, stdin);
ruta_entrada[strlen(ruta_entrada) - 1] = '\0';
fprintf(stdout, "Introduzca la ruta del archivo de destino: ");
fgets(ruta_salida, MAX_PATH, stdin);
ruta_salida[strlen(ruta_salida) - 1] = '\0';

// Abrimos archivos
entrada = fopen(ruta_entrada, "rb");
if(NULL == entrada) {
fprintf(stderr, "Error abriendo archivo de entrada en '%s'\n", ruta_entrada);
perror("Detalles");
return -1;
}

salida = fopen(ruta_salida, "wb");
if(NULL == salida) {
fprintf(stderr, "Error abriendo archivo de salida en '%s'\n", ruta_salida);
perror("Detalles");
return -1;
}

// Copiando datos
while(0 == salir) {
byte = fgetc(entrada);

if(0 == feof(entrada)) {
fputc(byte, salida);

if(0 != ferror(entrada) || 0 != ferror(salida)) {
fprintf(stderr, "Error leyendo|escribiendo byte\n");
perror("Detalles");
return -1;
}
} else {
salir = 1;
}
}

// Terminando...
fprintf(stdout, "La copia de archivos ha finalizado\n");

fclose(entrada);
fclose(salida);
return 0;
}

Evidentemente, esto no es lo más básico, sino que es una forma "muy segura" de copiar archivos (se podrían haber omitido la comprobación de que los archivos existen, los mensajes de error...)

Espero que te sea de ayuda.

PD.: Probé el código con un PDF, y funcionó perfectamente

[do-while]

¡Buenas!

No se si lo estarás haciendo así o no, sin ver tu código es imposible saberlo, pero si utilizas feof para saber si has llegado al final del archivo tienes que tener en cuenta dos cosas.

- El indicador de final de archivo se activa después de realizar una lectura cuando ya no quedan más datos por leer: lees el último dato-> haces la siguiente lectura -> se activa el indicador de fin de archivo (y por lo tanto en la última lectura no has obtenido ningún dato útil y si escribes éste último dato estarás escribiendo información que no debería de estar ahí)

- Los archivos que no contienen solo texto (caracteres alfanuméricos, espacios, signos de puntuación y poco más), pueden dar lecturas falsas de final de archivo antes de haber llegado a éste. Así que lo mejor es utilizar las funciones fseek y ftell para para posicionarte al final del archivo, leer la cantidad de bytes que contiene y volver a la posición en la que estaba. Sabiendo la cantidad exacta de bytes que tienes que leer no te hace falta depender del indicador de final de archivo.

¡Saludos!

[class_OpenGL]

Lo primero si que lo tuve en cuenta en el código. Lo segundo, pues no

[NoBass]

Eso es rotundamente falso. Si abres un archivo en binario, copias byte a byte y lo guardas en otro archivo con la misma extensión, debería ser una copia exacta, y como tal, no debería haber problemas con la copia.

Pues me alegro muchísimo, porque había llegado a una conclusión aterradora. Gracias por escribir el código, se entiende muy bien.

No se si lo estarás haciendo así o no, sin ver tu código es imposible saberlo, pero si utilizas feof para saber si has llegado al final del archivo tienes que tener en cuenta dos cosas.

Soy tan listo que después de unas pruebas borré por error el código -lamentable- que había escrito, pero intuyo que el error tendría que ver con lo que sugieres o quizás con el uso de funciones dispares para leer y escribir, puesto que por lo demás se parecía (bueno, de lejos y sin gafas) al que había escrito class_OpenGL.

Gracias por vuestra ayuda.