Un programa que pida al usuario que teclee frases, y las almacene en el fichero

“frases.txt”. Acabará cuando el usuario pulse Intro sin teclear nada. Después deberá mostrar
el contenido del fichero.  

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

int main()
{
FILE* ficheroU;
char frase[61];
int i=0;

ficheroU = fopen("frases.txt", "wt");

printf(" PROGRAMA para ESCRIBIR y almacenar FRASES.\n"
"Cuando quiera salir, simplemente pulse \"Intro\".\n\n");
do
{
if (i == 0)
puts("\nEscriba una FRASE:\n(o pulse \"Intro\"). \n");
else
puts("\nEscriba otra FRASE:\n(o pulse \"Intro\"). \n");
gets(frase);
fprintf(ficheroU, "%s\n", frase);
i++;
}
while (strcmp(frase, "") != 0);
printf("He aqui lo que escribio:\n\n");
fclose(ficheroU);

ficheroU = fopen("frases.txt", "rt");

do
{
fgets(frase, 60, ficheroU);
puts(frase);
}
while (!feof(ficheroU));
getchar();
printf("...Hasta luego!");
getchar();
fclose(ficheroU);

return 0;
}

Un programa que pregunte un nombre de fichero y muestre en pantalla el contenido de ese

fichero, haciendo una pausa después de cada 25 líneas, para que dé tiempo a leerlo. Cuando el usua-
rio pulse intro, se mostrarán las siguientes 25 líneas, y así hasta que termine el fichero.

#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fichero;
char linea[100], nombre[40];
int i=0;
do
{
printf("\nNombre de fichero: ");
gets(nombre);

fichero = fopen(nombre, "rt");

if (fichero == NULL)
{
printf("No existe el fichero\n\n");
i++;
if (i == 5)
exit(1);
}
}
while (fichero == NULL);
while (!feof(fichero))
{
for (i=0; i<25; i++){
fgets(linea, 100, fichero);
if (!feof(fichero))
{
puts(linea);
}
}
getchar();
}
fclose(fichero);
return 0;
}

Crear un struct que almacene los siguientes datos de una persona: nombre, edad, ciudad de
residencia. Pedir al usuario esos datos de una persona y guardarlos en un fichero llamado
“gente.dat”. Cerrar el fichero, volverlo a abrir para lectura y mostrar los datos que se habían
guardado.

#include <stdio.h>

int main()
{
struct datos
{
char nombre[21];
int edad;
char ciudad[21];
 }persona;

FILE *fichero;
int i;

fichero = fopen("gente.dat", "wt");

if (fichero == NULL)
printf("No se pudo abrir el archivo.\n");
else
{
puts("Nombre:");
gets(persona.nombre);
fprintf(fichero, "%s ", persona.nombre);
puts("Edad:");
scanf("%d", &persona.edad);
getchar();
fprintf(fichero, "%d ", persona.edad);
puts("Ciudad:");
gets(persona.ciudad);
fputs(persona.ciudad, fichero);
fclose(fichero);
}
fichero = fopen("gente.dat", "rt");
if (fichero == NULL)
printf("No se pudo abrir el archivo.\n");
else
{
while (!feof(fichero))
// while (feof(fichero) == 0)
{
fgets(persona.nombre, 60, fichero);
puts(persona.nombre);
fscanf(fichero, "%d", &persona.edad);
getchar();
printf("%d", persona.edad);
fgets(persona.ciudad, 60, fichero);
puts(persona.ciudad);
}
fclose(fichero);
}
return 0;
}
/* 6.4.ii_ Ampliar el programa anterior para que use un “array de structs”,
de forma que se puedan
tener datos de 10 personas. Se deberá pedir al usuario los datos de las 10
personas y guardarlos
en el fichero. Después se pedirá al usuario un número del 1 al 10 y se
mostrarán los datos de la
persona indicada por ese número, que se deberán leer de fichero (1 será la
primera ficha, y 10 será
la última). Por ejemplo, si el usuario indica que quiere ver los datos de la
persona 3 (tercera),
se deberá leer las dos primeras, ignorando su contenido, y después leer la
tercera, que sí se deberá
mostrar. */

#include <stdio.h>
#include <stdlib.h>

int main()
{
struct datos
{
char nombre[21];
int edad;
char ciudad[21];
}persona[10]; // Array de struct con datos para 10 personas.

FILE *fichero;
int i, numero=0;

fichero = fopen("gente.dat", "wt");

if (fichero == NULL)
printf("No se pudo abrir el archivo.\n");
else
{
for (i=0; i<10; i++) //Pide datos de 10 personas y los guarda en el
fichero.
{
puts("Nombre:");
gets(persona[i].nombre);
fprintf(fichero, "%s", persona[i].nombre);
puts("Edad:");
scanf("%d", &persona[i].edad);
getchar();
fprintf(fichero, "%d", persona[i].edad);
puts("Ciudad:");
gets(persona[i].ciudad);
fputs(persona[i].ciudad, fichero);
}
}
fclose(fichero);
fichero = fopen("gente.dat", "rt");
if (fichero == NULL)
printf("No se pudo abrir el archivo.\n");
else
{
do
{
puts("Escriba el numero del fichero a leer:\n" // Pide número del
1 al 10.
"(Para salir, digite 0).");
scanf("%d", &numero);
for (i=0; i<numero; i++) // Muestra los datos de la persona
indicada por su número.
{ // Se leen todas las anteriores al
número
if (i == (numero-1)) // indicado, pero no se muestran.
{
printf("Nombre:%s\nEdad:%d\nCiudad:%s\n",
persona[i].nombre, persona[i].edad, persona[i].ciudad);
getchar();
}
}
 }
while(numero!=0);
fclose(fichero);
}
return 0;
}

/*6.6.i_ Un programa que pida al usuario que teclee frases, y las almacene en
el fichero
"registro.txt", que puede existir anteriormente (y que no deberá borrarse,
sino añadir al final
de su contenido). Cada sesión acabará cuando el usuario pulse Intro sin
teclear nada. */

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

int main()
{
FILE *fichero;
char frase[61];
int i;

fichero = fopen("registro.txt", "a+");

if (fichero == NULL)
printf("No se pudo abrir el archivo.\n");
else
{
do
{
fgets(frase, 60, fichero);
puts(frase);
}
while (!feof(fichero));

puts("Escriba algunas frases.\n \"Enter\" para salir.\n");

do
{
puts("Frase: \n");

gets(frase);
fprintf(fichero, "%s\n", frase);
}
while (strcmp(frase, "") != 0);
fclose(fichero);
}
return 0;
}

/* 6.6.ii_ Crear un programa que pida al usuario pares de números enteros y

escriba su suma (con el
formato "20 + 3 = 23") en pantalla y en un fichero llamado "sumas.txt", que
se encontrará en un
subdirectorio llamado "resultados". Cada vez que se ejecute el programa,
deberá añadir los nuevos
resultados a continuación de los resultados de las ejecuciones anteriores. */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main()
{
FILE *resultados;
int numero1=0, numero2=0, suma=0;

resultados = fopen("sumas.txt", "a+");

if (resultados == NULL)
printf("No se pudo abrir el archivo.\n");
else
{
do
{
fscanf(resultados, "%d + %d = %d", &numero1, &numero2, &suma);
if (feof(resultados))
break;
printf("%d + %d = %d\n", numero1, numero2, suma);
}
while (!feof(resultados));

printf("Escriba dos numeros.\n\"000\" para salir.\n");

do
{
printf("Primer numero: ");
scanf("%d", &numero1);
if (numero1 == 0)
exit(1);
printf("Segundo numero: ");
scanf("%d", &numero2);
suma = numero1 + numero2;
printf("%d + %d = %d\n", numero1, numero2, suma);
fprintf(resultados, "%d + %d = %d\n", numero1, numero2, suma);
}
while (numero1 != 0);
fclose(resultados);
}
return 0;

}
ACCESO A FICHEROS CON C: SECUENCIAL, ALEATORIO O BINARIO.

C nos permite el acceso a ficheros gracias a la biblioteca studio.h, que nos facilita todo lo
necesario para el trabajo con ficheros. El acceso a un fichero puede ser:

a) Acceso secuencial: orientado a su uso en archivos donde la información está dispuesta

como tipo texto.

b) Acceso aleatorio: orientado a su uso en archivos con datos contenidos en registros de

longitud fija, que a su vez pueden estar subdivididos en campos. Un campo puede contener un
valor numérico o ser tipo texto.

c) Acceso binario: permite guardar datos con el orden y estructura que se desee, siendo
posible acceder a ellos conociendo la posición (número de byte) en que se encuentran.

Al existir distintas formas de acceso, se habla de "archivos secuenciales", "archivos aleatorios" y

"archivos binarios", aunque esta terminología debe tomarse con precaución. Es decir, un
"archivo binario" hace referencia a un archivo donde habitualmente guardamos y extraemos
datos usando el acceso binario. Sin embargo, podríamos usar este archivo con otro tipo de
acceso. En resumen, un archivo es "información" y la información puede reordenarse, cambiar,
manipularse de distintas maneras, etc. Usar un tipo de acceso en un momento dado no obliga a
usarlo siempre, aunque así pueda ser.

En la analogía fichero físico - fichero informático, las equivalencias aproximadas serían las de:

- Archivo secuencial = La información no está en campos de longitud predefinida.

- Archivo aleatorio = Existen campos de longitud predefinida, que pueden carecer de

información por no estar disponible.

- Archivo binario = La información no está en campos de longitud predefinida pero se dispone de

información referente a su ubicación.

Repetimos que todo es lo suficientemente complejo como para que sea difícil dar definiciones
exactas. Nosotros vamos a estudiar únicamente ciertas formas de extraer y guardar datos de un
fichero secuencial a través de algunas funciones disponibles en el lenguaje para este fin. Esto
será suficiente para poder crear programas que leen y guardan datos desde archivos de forma
simple. El resto de instrucciones y posibilidades de acceso no será objeto de estudio ya que
quedan fuera de nuestros objetivos.

 
 

ABRIR Y CERRAR FICHEROS SECUENCIALES EN C. FILE, FOPEN, FCLOSE.

Para manipular información de un fichero, por ejemplo guardar datos en él o leer datos desde él,
lo primero que hemos de hacer es abrir el fichero. El proceso a seguir es:

Abrir el fichero --> Manipular datos (extraer, guardar, modificar, etc.) -->Cerrar el fichero

fopen --> Manipular datos --> fclose

A su vez, cada vez que accedemos a un fichero hemos de indicar “bajo qué modalidad” vamos a
utilizar ese fichero: si es para leer datos, para escribir datos, y a su vez si se trata de escribir si
debemos añadir los datos a los que ya existieran en el fichero o si debemos desechar lo existente
y crear el fichero como si fuera nuevo.

La sintaxis que emplearemos para escribir o leer datos en ficheros secuenciales será la siguiente:

FILE* nombreInternoFichero;

nombreInternofichero = fopen
(“rutaNombreFichero.txt”, “modoDeAcceso”);

operación 1; operación 2; … ; operación n;

fclose (nombreInternofichero)

FILE* nombreInternoFichero: para manipular un fichero necesitamos “algo” que el programa

utilizará para almacenar información sobre el fichero (como el modo de acceso, ruta, etc.). Ese
“algo” (estructura de datos) lo creamos escribiendo FILE* y el nombre que queramos utilizar
para referirnos a la estructura de datos que almacenará la información relacionada con el fichero.
Cuando creamos esta estructura de datos (en realidad deberíamos usar el término puntero, pero
vamos a mantener las ideas claras usando simplificaciones) la creamos vacía (su contenido es
NULL), a la espera de rellenarla con información.

nombreInternoFichero = fopen (“nombreFichero.txt”, “modoDeAcceso”): es la instrucción

que da lugar a que la estructura de datos deje de estar vacía y comience a contener información y
a ser útil para poder actuar sobre un fichero. Para aportar la información necesaria se usa la
función fopen, que abre el fichero cuya ruta y nombre se especifica en rutaNombreFichero.txt
(no necesariamente tiene que ser un fichero txt, pero de momento vamos a suponer que es así) y
define el modo de acceso. El modo de acceso indica para qué se abre y cómo debe tratarse el
fichero según si existía previamente o si no existía.

Operación 1; Operación 2; …: indica las operaciones que se ejecutan. Pueden ser bucles,
condicionales, o instrucciones simples que normalmente se encargarán de extraer información
del fichero (leer datos) o incorporar información al fichero (escribir datos).

fclose (nombreInternoFichero): da lugar a la conclusión de procesos abiertos, al cierre del

fichero y a que “la línea de comunicación” quede libre para una posterior ocasión. Siempre que
abramos un fichero con fopen deberemos cerrarlo con fclose.

MODOS DE ACCESO O APERTURA DE ARCHIVOS CON C. LEER (READ),

ESCRIBIR (WRITE) O AÑADIR (APPEND).

Para acceder a un fichero se escriben sentencias similares a estas: 

FILE* fichero; fichero = fopen("cursoAF1.txt", "wt");

wt es una clave identificadora que consta de dos componentes: w y t. Vamos a definir cuál es el
significado de las dos componentes de “wt” y qué valores pueden aparecer en este lugar y su
significado. La comprensión se facilita si tenemos en cuenta que r proviene de read, w proviene
de write y a proviene de append.

Primer componente
Significado
(modo)

r Abre un archivo existente para lectura.

Crea un nuevo archivo para escritura (si ya existe, se pierden los datos
w
preexistentes).

Abre el archivo para añadir datos al final (se conservan datos

a
existentes), o crea el archivo si no existía.

 
El primer componente puede ir acompañado de un símbolo +, por ejemplo r+. El símbolo +
indica que se permite la lectura y la escritura. Por ejemplo r+ indica apertura de un archivo
existente para lectura o escritura, w+ indica creación de un nuevo archivo para lectura o escritura
y a+ indica apertura de un archivo para lectura o escritura al final.

El segundo componente indica el tipo de archivo que se abre.

Segundo componente (tipo de archivo) Significado

t Archivo de texto.

b Archivo binario.