Leer un fichero en C

Ahora que ya sabemos abrir o crear un fichero y escribir en él voy a explicar como tenemos que hacer para leer su contenido. El mecanismo de lectura es sencillo, cuando abrimos un fichero el puntero se encuentra al inicio de este. Si hacemos una operación de lectura se lee el elemento sobre el que está el puntero, y a continuación el puntero avanza hacia el siguiente elemento, pero hasta que no se haga otra operación de lectura no se lee. A continuación detallo cuales son las principales operaciones o funciones de lectura de ficheros.

fgetc

La función fgetc se utiliza para leer un carácter de un fichero de texto, y devuelve dicho carácter. La sintaxis general es:

fgetc(puntero);

El parámetro puntero es el identificador de la variable puntero a FILE correspondiente al fichero de texto que estamos leyendo. Veamos un ejemplo:

#include <stdio.h>


int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	/* Declaramos la variable caracter de tipo char. */
	char caracter;

	/* Abrimos "fichero1.txt" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("fichero1.txt", "rt");

	if (fichero == NULL) {
		printf("Error: No se ha podido crear el fichero fichero1.txt");
	} else {
		/* Se obtiene el primer caracter del fichero
		 * y se almacena en la variable caracter. */
		caracter = fgetc(fichero);

		printf("El primer caracter leído es: \"%c\"\n", caracter);

		/* Cerramos "fichero1.txt". */
		fclose(fichero);
	}
}

Como podemos ver, tras leer el primer carácter del archivo "fichero1.txt" este se almacena en la variable caracter, y a continuación imprimimos un mensaje indicando cuál es ese primer caracter.

feof

La función feof nos permite detectar el final de un fichero (end-of-file) y así poder averiguar todos los caracteres que existen dentro del mismo. La sintaxis general es:

feof(puntero);

Donde puntero es el identificador de la variable puntero al fichero. Esta llamada a la función feof nos devolverá un 0 si no se ha llegado al final del fichero, y por el contrario devolverá un valor distinto de 0 si se llega al final. Veámoslo con un ejemplo:

#include <stdio.h>

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	/* Declaramos la variable caracter de tipo char. */
	char caracter;

	/* Abrimos "fichero1.txt" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("fichero1.txt", "rt");

	if (fichero == NULL) {
		printf("Error: No se ha podido crear el fichero fichero1.txt");
	} else {
		/* Se obtiene el primer caracter del fichero
		 * y se almacena en la variable caracter. */
		caracter = fgetc(fichero);

		while (feof(fichero) == 0) {
			printf("%c\n", caracter);
			caracter = fgetc(fichero);
		}

		/* Cerramos "fichero1.txt". */
		fclose(fichero);
	}
}

Este ejemplo lo que hace es leer un carácter, a continuación comprueba si hemos llegado al final del fichero, y si no se ha llegado al final lo imprime. Este proceso se repite por cada uno de los caracteres escritos en el fichero (incluidos saltos de línea).

fgets

Con la función fgets podemos leer una cadena de caracteres, su sintaxis general es:

fgets(cadena, tamaño, puntero);

Donde cadena es la variable que va a almacenar la cadena de caracteres que se lea del fichero, tamaño es la cantidad máxima de caracteres que vamos a leer del fichero (y almacenar en cadena), y puntero es el identificador de la variable puntero al fichero. Decimos que tamaño es la cantidad máxima de caracteres que vamos a leer del fichero por que la lectura se podría detener antes si encuentra un salto de línea. La función fgets devuelve la cadena de caracteres leída o NULL si hubiera un error o se llegase al final del archivo. El mismo ejemplo de antes utilizando la función fgets sería así:

#include <stdio.h>

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	/* Declaramos la variable cadena de tipo array char. */
	char cadena[256];

	/* Declaramos la variable reslutado como puntero. */
	char *resultado;

	/* Abrimos "fichero1.txt" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("fichero1.txt", "rt");

	if (fichero == NULL) {
		printf("Error: No se ha podido crear el fichero fichero1.txt");
	} else {
		/* Se obtiene la cadena de caracteres de
		 * tamaño 256 dentro de fichero1.txt. */
		resultado = fgets(cadena, 256, fichero);

		while (resultado != NULL) {
			printf("%s", cadena);
			resultado = fgets(cadena, 256, fichero);
		}

		/* Cerramos "fichero1.txt". */
		fclose(fichero);
	}
}

fread

La función fread ofrece la misma potencia que la función fread, pero para leer, y nos permite leer datos de diferentes tipos. La sintaxis es la misma:

fread(direccion_dato, tamaño, veces, puntero);

Donde direccion_dato es la dirección de la variable o elemento donde queremos almacenar los datos leídos del fichero indicado por la variable puntero. En tamaño debemos indicar el tamaño en bytes que queremos leer del fichero, y en veces indicamos cuántos elementos de tamaño tamaño vamos a leer. Se nos podría plantear la duda de qué valores indicamos en tamaño y veces, pero, como lo normal es que el fichero que vayamos a leer también lo hayamos creado nosotros, conoceremos estos valores, ya que los hemos usado previamente con la función frwrite.

Anteriormente hemos creado un fichero binario, llamado empleados.dat, en el que hemos almacenado estructuras con  la siguiente definición:

struct datos_empleado {
	char nombre[30];
	int edad;
};

Si queremos leer ese fichero binario y  mostrar todas las estructuras almacenadas en él podríamos hacerlo con un programa como este de ejemplo:

#include <stdio.h>

struct datos_empleado {
	char nombre[30];
	int edad;
};

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	struct datos_empleado empleado;

	/* Abrimos "empleados.dat" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("empleados.dat", "rb");

	if (fichero == NULL) {
		printf("Error: No se ha podido crear el fichero empleados.dat");
	} else {
		/* Leemos la primera estructura empleado
		 * del fichero "empleados.dat". */
		fread(&empleado, sizeof(empleado), 1, fichero);

		while (feof(fichero) == 0) {
			printf("\n\nNombre: %s", empleado.nombre);
			printf("\nEdad: %d", empleado.edad);

			/* Si aun no hemos llegado al final del fichero
			 * "empleados.dat" seguimos leyendo estructuras. */
			fread(&empleado, sizeof(empleado), 1, fichero);
		}

		/* Cerramos "empleados.dat". */
		fclose(fichero);
	}
}

De este modo, podremos comprobar que imprime cada una de las estructuras hasta llegar al final del fichero. Bien, ¿y si lo que queremos es que el programa imprima solo una estructura que cumpla un requisito? Por ejemplo, solo los datos de un empleado que tenga una edad determinada. En ese caso podemos hacer un programa que solicite al usuario introducir una edad y pedirle al programa que solo imprima los nombres de los empleados que cumplan con esa condición. Este sería un ejemplo:

#include <stdio.h>

struct datos_empleado {
	char nombre[30];
	int edad;
};

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	struct datos_empleado empleado;
	int filtroEdad;

	/* Creamos un flag con valor inicial 0, solo
	 * cambiara su valor a 1 cuando se encuentre
	 * un empleado con la edad buscada. */
	int encontrado = 0;

	/* Pedimos al usuario una edad a buscar. */
	printf("Edad del empleado: ");
	scanf("%d", &filtroEdad);

	/* Abrimos "empleados.dat" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("empleados.dat", "rb");

	if (fichero == NULL) {
		printf("Error: No se ha podido crear el fichero empleados.dat");
	} else {
		/* Leemos la primera estructura empleado
		 * del fichero "empleados.dat". */
		fread(&empleado, sizeof(empleado), 1, fichero);

		while (feof(fichero) == 0) {

			if(empleado.edad == filtroEdad){
				printf("\n\nNombre: %s", empleado.nombre);
				printf("\nEdad: %d", empleado.edad);

				/* Activamos el flag a true (1), para indicar
				 * que hemos encontrado al algo. */
				encontrado = 1;
			}

			/* Si aun no hemos llegado al final del fichero
			 * "empleados.dat" seguimos leyendo estructuras. */
			fread(&empleado, sizeof(empleado), 1, fichero);
		}

		/* Cerramos "empleados.dat". */
		fclose(fichero);

		if(encontrado == 0){
			printf("\n\nNo existe ningun empleado con edad %d.", filtroEdad);
		}
	}
}

Este es un método muy básico para realizar búsquedas dentro de una fichero, y cumple con el propósito de imprimir solo los datos de los empleados que tienen determinada característica.

fseek

Por último tenemos la función fseek, que nos permitirá acceder directamente a un registro de nuestro archivo. Esto nos puede interesar para leer o para modificar ese registro en concreto. Lo que hace la función fseek es situar el puntero del fichero  en una posición determinada de este. Su sintaxis general es:

fseek(puntero, tamaño_salto, desde);

Donde puntero es la variable puntero del fichero, tamaño_salto es el tamaño en bytes del salto realizado desde la posición desde. El argumento desde tiene tres posibles valores constantes, que son:

Constante Valor Descripción
SEEK_SET 0 Salta desde el principio del fichero.
SEEK_CUR 1 Salta desde la posición actual.
SEEK_END 2 Salta desde el final del fichero.

Siguiendo con el ejemplo anterior, veamos un ejemplo que imprimirá la estructura de datos del empleado que se encuentra en tercer lugar dentro del archivo binario empleados.dat.

#include <stdio.h>

struct datos_empleado {
	char nombre[30];
	int edad;
};

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	struct datos_empleado empleado;

	/* Abrimos "empleados.dat" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("empleados.dat", "rb");

	if (fichero == NULL) {
		printf("Error: No se ha podido crear el fichero empleados.dat");
	} else {

		/* Nos posicionamos en la tercera estructura empleado
		 * desde el inicio del fichero "empleados.dat". */
		fseek(fichero, 2 * sizeof(empleado), SEEK_SET);

		/* Leemos esa estructura. */
		fread(&empleado, sizeof(empleado), 1, fichero);

		/* La imprimimos. */
		printf("\n\nNombre: %s", empleado.nombre);
		printf("\nEdad: %d", empleado.edad);

		/* Cerramos "empleados.dat". */
		fclose(fichero);
	}
}

Voy a explicar la línea:

fseek(fichero, 2 * sizeof(empleado), SEEK_SET);

El parámetro fichero, tal y como ya se ha explicado en varias ocasiones en ejemplos anteriores, indica el puntero del archivo que vamos a leer. Lo tenemos que tener abierto mediante la función fopen previamente. Antes de explicar el segundo parámetro voy a hablar sobre el tercer parámetro, SEEK_SET, que sirve para decirle a la función que vamos a mover el puntero del archivo hasta una determinada distancia desde el inicio del fichero. La cuestión ahora es ¿a qué distancia voy a mover el puntero desde el inicio del fichero? En el ejemplo anterior hemos dicho que nos interesa leer el tercer registro del fichero, bien, pues necesitaremos dar un salto desde el inicio hasta los dos primeros registros, y para ello deberemos indicar esa distancia o tamaño en bytes. Como son dos estructuras las que tenemos que saltar debemos multiplicar por dos el tamaño de una estructura, y para averiguar dinámicamente el tamaño de nuestra estructura empleado podemos utilizar la función sizeof(empleado). Así pues, 2*sizeof(empleado) nos permite saltar dos registros desde el inicio (SEEK_SET) del fichero (fichero), con lo que la llamada a la función fseek hace que el puntero se encuentre al principio del tercer registro. Por último se llama a la función fread que lee el tercer registro y luego lo imprime.

Otro ejemplo de uso de la función fseek es utilizando la constante SEEK_CUR, que realiza un salto desde la posición actual, o lo que es lo mismo, salta un registro. Esto nos puede servir si lo que queremos es imprimir registros uno sí , uno no, por ejemplo los impares, veamos un ejemplo:

#include <stdio.h>

struct datos_empleado {
	char nombre[30];
	int edad;
};

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	struct datos_empleado empleado;

	/* Abrimos "empleados.dat" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("empleados.dat", "rb");

	if (fichero == NULL) {
		printf("Error: No se ha podido crear el fichero empleados.dat");
	} else {

		/* Leemos el primer registro. */
		fread(&empleado, sizeof(empleado), 1, fichero);

		while (!feof(fichero)) {
			/* Imprimimos los datos del registro. */
			printf("\n\nNombre: %s", empleado.nombre);
			printf("\nEdad: %d", empleado.edad);

			/* saltamos un registro desde la posicion actual. */
			fseek(fichero, 1 * sizeof(empleado), SEEK_CUR);

			/* Leemos el siguiente registro. */
			fread(&empleado, sizeof(empleado), 1, fichero);
		}

		/* Cerramos "empleados.dat". */
		fclose(fichero);
	}
}

Poder saltar con el puntero a una posición concreta del fichero nos permite realizar búsquedas mas precisas en menos tiempo.

Escribir dentro de un fichero en C

En el artículo anterior explicaba cómo abrir, crear y cerrar un fichero en C, pero en este artículo os contaré cómo podemos escribir dentro de un fichero. Podremos hacerlo empleando las diferentes funciones que nos ofrece la librería stdio de C, como fputc, fputs y fwrite.

fputc

La función fputc nos permite escribir en un fichero caracteres, pero lo podremos hacer de uno en uno. La sintaxis es:

fputc(caracter, puntero);

Donde caracter es el carácter que queremos escribir y puntero es la dirección donde está el fichero en el que queremos escribir.

fputs

También podemos escribir cadenas de caracteres en un fichero, para ello utilizamos la función fputs. La sintaxis es:

fputs(cadena, puntero);

Donde cadena es la cadena de caracteres que queremos escribir en el archivo, al igual que antes, es la dirección de nuestro fichero.

fwrite

Esta función es diferente, la función fwrite nos permite trabajar tanto con fichero de texto como binarios y escribir cualquier tipo de datos. Al ser una función mas completa voy a desarrollar un poco mas su explicación con un ejemplo mas detallado. Su sintaxis general es:

fwrite(direccion_dato, tamaño, veces, puntero);

Aquí tenemos varios argumentos, por ejemplo direccion_dato es la dirección de la variable o elemento que queremos escribir en el fichero indicado por la variable puntero. En tamaño debemos indicar el tamaño en bytes de la variable o elemento  escribir en el fichero. Para obtener el tamaño de una variable podemos usar el operador sizeof y para obtener el tamaño de una cadena la función strlen. En veces indicamos cuántos elementos de tamaño tamaño vamos a escribir. ¡Cuidado!, veces no es el número de veces que queremos que se escriba repetidamente el dato indicado en direccion_dato. Veamos unos ejemplos:

#include <stdio.h>

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	/* Declaramos la variable caracter con un caracter ASCII. */
	char caracter = 'A';

	/* Abrimos "fichero1.txt" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("fichero1.txt", "wt");

	if(fichero == NULL) {
		printf("Error: No se ha podido crear el fichero archivo1.txt");
	} else {
		/* Escribimos dentro de "fichero1.txt". */
		fwrite(&caracter, sizeof(caracter), 1, fichero);

		/* Cerramos "fichero1.txt". */
		fclose(fichero);
	}

	fflush(stdin);
	printf("\n\nPulsa Intro para finalizar...");
	getchar();
}

En la línea

fwrite(&caracter, sizeof(caracter), 1, fichero);

hemos escrito en el fichero "fichero1.txt" el contenido de la variable caracter,  que es 'A'. Para ello indicamos en el primer parámetro la dirección de memoria de la variable caracter, cuyo contenido queremos escribir en el fichero. En el segundo parámetro escribimos el tamaño en bytes de la variable caracter. Utilizamos el operador sizeof  para que lo calcule. El tercer parámetro indica cuántos elementos de tamaño sizeof(caracter) hay en la variable caracter, en este caso 1. Este parámetro generalmente será 1, aunque al escribir arrays en los ficheros puede variar. El cuarto parámetro es la variable puntero al fichero abierto.

Si en lugar de un caracter quisiéramos escribir una cadena de caracteres podemos hacerlo de la siguiente manera:

char nombre[30];
fwrite(&nombre, strlen(nombre), 1, fichero);

Y si lo que queremos es almacenar en un archivo binario el contenido de una variable de tipo struct llamada empleado debemos hacerlo de la siguiente manera:

fwrite(&empleado, sizeof(empleado), 1, fichero);

En el siguiente programa se escribe en el fichero "archivo1.txt" una frase que se le pide introducir al usuario:

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

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	/* Declaramos la variable frase de tipo array. */
	char frase[100];

	/* Abrimos "fichero1.txt" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("fichero1.txt", "wt");

	if(fichero == NULL) {
		printf("Error: No se ha podido crear el fichero archivo1.txt");
	} else {

		/* Se pide al usuario que introduzca una frase. */
		printf("Escriba una frase: ");
		scanf("%s", frase);

		/* Escribimos dentro de "fichero1.txt". */
		fwrite(&frase, strlen(frase), 1, fichero);

		/* Cerramos "fichero1.txt". */
		fclose(fichero);
	}
}

Y por último veamos un ejemplo en el que queremos crear un fichero binario, llamado "empleados.dat", en el que almacenamos tres estructuras con la siguiente definición:

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

struct datos_empleado {
	char nombre[30];
	int edad;
};

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	struct datos_empleado empleado;

	/* Abrimos "empleados.dat" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("empleados.dat", "wb");

	if (fichero == NULL) {
		printf("Error: No se ha podido crear el fichero empleados.dat");
	} else {
		int n;

		/* Se pide al usuario que introduzca
		 * los datos de 3 empleados. */
		for(n=0;n<=2;n++){
			fflush (stdin);
			printf("\nNombre: ");
			scanf("%s", empleado.nombre);
			printf("Edad: ");
			scanf("%d", &empleado.edad);
			fwrite(&empleado, sizeof(empleado), 1, fichero);
		}

		/* Cerramos "empleados.dat". */
		fclose(fichero);
	}
}

En el próximo artículo explicaré cómo leer el contenido de un archivo en C.

Abrir, crear y cerrar un fichero en C

En este artículo voy a explicar cómo se abre un fichero desde un programa en C. En artículos posteriores explicaré como leer el contenido de un fichero y cómo escribirlo.

Así pues, te hago un pregunta: ¿Sabes lo que es un un fichero? Seguramente dirás que si, pero ¿y si te piden que des una explicación de lo que es? Ahí... parece que se complica la cosa. En los siguientes párrafos voy a intentar explicar cómo funciona esto de los ficheros en un sistema. Un fichero es un conjunto de datos que se almacenan en un soporte como pudiera ser un disco duro o un soporte externo como un USB, CD-ROM, etc. A estos ficheros se le ponen nombres para que los podamos identificar, por ejemplo, telefonos.txt o empleados.dat. Y ¿qué podemos almacenar en un fichero? Podemos almacenar datos de muchos tipos primitivos como int, char, float, pero también cadenas de caracteres o estructuras. Al final, a mas bajo nivel lo que estamos almacenando de un modo u otro son ceros y unos (011010100110...)

Para explicar todo el proceso con ejemplos vamos a utilizar el lenguaje de programación C, y algunas de sus funciones para el caso. Todas las funciones que necesitaremos para poder abrir, crear, acceder a su contenido, modificar y cerrar, pertenecen a la biblioteca stdio de C, así que podremos usarlas indicando la siguiente directiva al inicio de nuestros programas.

#include <stdio.h>

Comencemos pues. Imagina lo que le puede costar a una computadora encontrar un fichero en concreto de entre centenares de miles de ficheros que hay almacenados. Quizás podríamos pensar que solo tiene que recorrer uno a uno hasta dar con el que quiere, pero claro, este puede estar en cualquier lugar, e incluso el último de una lista enorme de ficheros. Para ello, las computadoras tienen una tabla donde existe una relación entre el nombre de un fichero y la dirección o lugar en la que se encuentra dentro del disco duro. Así pues, cuando abramos un fichero desde un programa C, en realidad lo que hacemos es obtener esa dirección y utilizarla para realizar diferentes operaciones. Aquí podemos ver un ejemplo:

Nombre del fichero Dirección del puntero
archivo1.txt 0x7fff7ad1f070
archivo2.txt 0x7fff7ad1f108
archivo3.txt 0x7fff7ad1f1a0
\vdots \vdots

fopen

Ahora que ya sabemos lo que es un fichero y cómo se almacena podemos ver qué es lo que hay que hacer para crear un fichero nuevo o abrir uno existente. Para ello utilizaremos la función fopen, que nos devolverá la dirección del fichero, un puntero a FILE. La sintaxis general es:

fopen(nombre, modo);

Donde nombre puede ser una cadena con el nombre del fichero o la ruta absoluta (por ejemplo: /var/tmp/archivo1.txt). Y el parámetro modo es una cadena que contiene una serie de caracteres que indican cómo queremos que se abra o se cree el fichero. En la siguiente tabla se indican las distintas posibilidades y su significado:

Modo Descripción
r (read) Si el fichero existe se abre en modo solo lectura y, por defecto, en modo texto.Si el fichero no existe la función devuelve NULL. Se utiliza para leer los datos de un fichero en modo texto.
w (write) Si el fichero no existe lo crea para escribir en él y lo deja abierto, por defecto, en modo texto, y si ya existe lo sobrescribe. Todas las operaciones de escritura con el modo 'w' se realizan al final del fichero.
a (add) Si el fichero no existe lo crea para escribir en él y lo deja abierto, por defecto, en modo texto, y si ya existe permite añadir mas datos al final de este respetando sus datos anteriores.
r+ Este modo es igual que el modo 'r' pero  también permite escribir en cualquier punto del fichero. Se utiliza para leer y modificar los datos de un fichero en modo texto.
w+ Igual que 'w' pero también permite leer del fichero. Se utiliza para crear un fichero y poder realizar operaciones de lectura.
a+ Igual que 'a' pero pero también permite leer del fichero. Se utiliza para añadir datos a un fichero en modo texto y poder realizar operaciones de lectura.
rt Igual que 'r'. la 't' es de texto.
wt Igual que 'w'. la 't' es de texto.
at Igual que 'a'. la 't' es de texto.
rt+ Igual que 'r+'.
wt+ Igual que 'w+'.
at+ Igual que 'a+'.
rb Igual que 'r' pero en modo binario, en vez de en modo texto. La 'b' es de binario.
wb Igual que 'w' pero en modo binario, en vez de en modo texto. La 'b' es de binario.
ab Igual que 'a' pero en modo binario, en vez de en modo texto. La 'b' es de binario.
rb+ Igual que 'r+' pero en modo binario, en vez de en modo texto. La 'b' es de binario.
wb+ Igual que 'w+' pero en modo binario, en vez de en modo texto. La 'b' es de binario.
ab+ Igual que 'a+' pero en modo binario, en vez de en modo texto. La 'b' es de binario.

Por ejemplo, si queremos abrir un archivo archivo1.txt y ver su contenido, debemos empezar por escribir lo siguiente:

fopen("archivo1.txt", "rt");

Antes he explicado que esto nos devuelve la dirección del fichero en un formato hexadecimal (0x7fff7ad1f070), así pues, dicha dirección la almacenaremos en una variable puntero a FILE, por ejemplo la llamaremos fichero.

#include <stdio.h>

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	/* Abrimos fichero1.txt en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("fichero1.txt", "rt");

	/* Imprimimos la direccion para este ejemplo. */
	printf("%p\n",fichero);
}

Con este pequeño fragmento de código, cualquier operación que hubiésemos realizado con la variable fichero la estaríamos realizando con el archivo fichero1.txt.

Otro ejemplo, si queremos crear un nuevo fichero binario llamado empleados.dat escribimos el siguiente código:

#include <stdio.h>

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	/* Creamos empleados.dat en modo binario y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("empleados.dat", "wb");

	/* Imprimimos la direccion para este ejemplo. */
	printf("%p\n",fichero);
}

fclose

Hasta ahora solo hemos abierto ficheros nuevos o existentes, y no hemos hecho ninguna operación con ellos. Es muy importante cerrar un fichero una vez hemos terminado de trabajar con él, para ello existe la función fclose, que tiene la siguiente sintaxis:

fclose(puntero);

Donde puntero es el identificador de la variable puntero a FILE que almacena la dirección del fichero abierto. Vamos a ver el ejemplo anterior cerrando el fichero:

#include <stdio.h>

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	/* Abrimos "fichero1.txt" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("fichero1.txt", "rt");

	/* Imprimimos la direccion para este ejemplo. */
	printf("%p\n",fichero);

	/* Cerramos "fichero1.txt". */
	fclose(fichero);
}

Si el archivo fichero1.txt no existiera, la función fopen devolverá un valor NULL, y no podremos cerrarlo, puesto que no existe. Así que vamos a añadir un control  que detecte si el fichero existe o no, de modo que solo lo cerraremos si el valor del puntero es distinto de NULL.

#include <stdio.h>

int main(void) {

	/* Declaramos la variable fichero como puntero a FILE. */
	FILE *fichero;

	/* Abrimos "fichero1.txt" en modo texto y
	 * guardamos su direccion en el puntero. */
	fichero = fopen("fichero1.txt", "rt");

	if(fichero == NULL) {
		/* Imprimimos un mensaje para indicar que no existe. */
		printf("El fichero no se ha podido abrir, no existe.");
	} else {
		/* Imprimimos mesaje de exito y la direccion para este ejemplo. */
		printf("El fichero existe y esta en la direccion: %p\n",fichero);

		/* Cerramos "fichero1.txt". */
		fclose(fichero);
	}
}

En el próximo artículo explicaré cómo escribir dentro de un archivo en C.