Uncategorized

Programando en C: Persistencia

Capítulo 15: Persistencia

Persistencia, qué es?

Hasta ahora, detrás del programa que hemos generado, trata información que existe previamente en variables, o bien que podemos introducir de forma manual.

El programa realiza las operaciones que sean necesarios, y finalmente, devuelve un resultado al ser humano.

Sin embargo, en el trabajo diario de un ser humano, generalmente, es necesario que esta información quede guardada de una forma permanente en algún soporte estable.

Esto quiere decir que, hasta el momento, cada programa que hemos hecho olvidar completamente sus datos en el momento que el programa es cerrado.

Si ponemos como ejemplo el programa que estamos desarrollando a lo largo de este curso, es decir, la agenda, nos habremos dado cuenta, que, al final de la ejecución del programa, todos los datos que hemos introducido quedan completamente perdidos, y cuando ejecutamos el programa de nuevo, tenemos que volverlos a introducir.

Huelga decir lo inconveniente que es este hecho, ya que, lo que muy probablemente desearíamos, es que todo el trabajo que hemos creado quede guardado de alguna manera, tal que la próxima vez que volvamos a ejecutar nuestro programa, los datos se encuentran en el mismo punto en el que los dejamos.

esto exactamente es la persistencia.

Consiste, básicamente, en asegurar que los datos quedan guardados en un soporte persistente, es decir, no en un soporte volátil como es por ejemplo la memoria RAM, sino en un soporte en los que los datos puedan sobrevivir, tal y como por ejemplo un disco duro, o una tarjeta de memoria.

Persistencia en archivos de texto

Una de las formas más básica y más clásica de realizar esta persistencia es utilizando archivos dentro del ordenador.

En un momento dado, el programa puede escribir en estos archivos la información que necesite, y recuperar, mediante una operación de lectura, la información que quede contenida dentro de este archivo.

existen fundamentalmente dos tipos de archivo en cualquier sistema operativo, los archivos binarios, y los archivos de texto.

El soporte para escribir archivos binarios y para poder leerlos depende inmensamente del lenguaje de programación en el que estemos trabajando.

Sin embargo, prácticamente cualquier lenguaje de programación incluye soporte para poder escribir y leer archivos en formato texto.

además, las instrucciones necesarias para poder leer y escribir archivos de texto, si bien rara vez se encuentran en el núcleo de un lenguaje de programación, sí que suelen encontrarse en esa colección de librerías por defecto añadidas al núcleo de cualquier lenguaje de programación.

escritura de archivos.

A continuación se muestra un ejemplo de código en el que, en primer lugar, se hace uso de una librería, con la que importamos la capacidad de poder leer y poder escribir archivos de texto.

A continuación, dentro del bloque inicial, dentro de la función principal, establecemos el código que nos permite, en primer lugar, abrir un archivo, y a continuación, escribir texto dentro de

El

main.c
#include <stdio.h>
int main(int argc, char** argv) {    FILE *archivo;    archivo = fopen(«prueba.txt»,»w»);    fprintf(archivo,»Esto es una prueba \n»);    fclose(archivo);    return 0;}

El cierre de los recursos.

siempre que trabajamos con archivos externos al propio programa principal, se entiende que, en el momento en el que abrimos un archivo, realmente estamos abriendo un recurso.

Esto es importante ya que, en la mayoría de ocasiones, cuando se abre un recurso este recurso queda bloqueado, para impedir que, mientras que tenemos el recurso abierto, cualquier otra persona desde cualquier otra ubicación pues pueda escribir dentro de él, introduciendo una situación de inconsistencia.

de esta manera, si el programa es capaz de bloquear un recurso para darnos acceso exclusivo a él, debemos tener cuidado de liberar el recurso una vez que hemos finalizado su utilización.

Es por esto que al final del programa que hemos mencionado anteriormente existe esta línea:

Que nos permite que el programa cierre, de manera manual, el recurso que estaba siendo utilizado.

aunque la mayoría de lenguajes de programación tienen mecanismos de cierre automático de recursos, bien cuando se dejan de usar, o bien cuando el programa se cierra, es importante acostumbrarse a cerrar los recursos de forma manual, ya que de otro modo, podemos cerrar el acceso accidentalmente a un recurso de manera temporal o de manera permanente, dificultando el trabajo de otras personas, o incluso de nosotros mismos cuando queremos acceder a ese recurso a través de cualquier otro medio que no sea el programa que lo ha bloqueado.

cómo leer un archivo

Una vez que ya somos capaces de escribir en un archivo, a continuación queremos leer su contenido.

Generalmente, en cualquier lenguajes de programación, leer un archivo de texto se basa en los siguientes pasos:

En primer lugar, abrimos el recurso y, opcionalmente, indicamos que la apertura es el modo de lectura.

A continuación, generalmente, las librerías de lectura de archivos trabajan línea a línea.

Esto quiere decir que tenemos que apoyarnos en una estructura de tipo guay que vaya recorriendo el archivo línea a línea, permitiéndonos realizar una operación sobre cada una de las líneas leídas.

En el ejemplo que ponemos a continuación, la operación consiste simplemente en devolver en la pantalla el contenido del archivo, aunque por supuesto, la operación podría consistir en introducir la línea en la memoria, trabajar con ella, etc.

main.c
#include <stdio.h>
int main(int argc, char** argv) {    char cadena[100];    FILE *archivo;    archivo = fopen(«prueba.txt»,»r»);    fprintf(archivo,»Esto es una prueba \n»);    while( fgets (cadena, 60, archivo)!=NULL ){        puts(cadena);    }    fclose(archivo);    return 0;}

Ejercicio del curso

agenda.c
/* Programa agendapor Jose Vicente Carratala */#define NOMBREPROGRAMA «Programa agenda»#define VERSION «1.0»#define AUTOR «Jose Vicente Carratala»#include <stdio.h>#include <string.h>#include «libAgenda/datos.c»#include «libAgenda/listadoRegistros.c»#include «libAgenda/introducirRegistro.c»#include «libAgenda/eliminarRegistro.c»#include «libAgenda/buscarRegistro.c»#include «libAgenda/actualizarRegistro.c»#include «libAgenda/guardarDatos.c»#include «libAgenda/recuperarDatos.c»#include «libAgenda/menuPrincipal.c»
int main(int argc, char *argv[]) {
    // Primer registro    printf(«\033[2J»);    strcpy(agenda[1].nombre,»Jose Vicente»);    strcpy(agenda[1].telefono,»12345678″);    strcpy(agenda[1].email,»info@josevicentecarratala.com»);        // Segundo registro    strcpy(agenda[2].nombre,»Juan»);    strcpy(agenda[2].telefono,»53254″);    strcpy(agenda[2].email,»juan@josevicentecarratala.com»);    // Tercer registro    strcpy(agenda[3].nombre,»Jaime»);    strcpy(agenda[3].telefono,»64566″);    strcpy(agenda[3].email,»jaime@josevicentecarratala.com»); printf(«\033[2J»);    menuPrincipal(); return 0;}

menuPrincipal.c
void menuPrincipal(){ printf(«\033[2J»);     // Mensaje de bienvenida printf(«%s v%s \n»,NOMBREPROGRAMA,VERSION); printf(«%s \n»,AUTOR); printf(«\t 1 – Listado de registros \n»); printf(«\t 2 – Introducir un registro \n»); printf(«\t 3 – Eliminar un registro \n»); printf(«\t 4 – Buscar un registro \n»); printf(«\t 5 – Actualizar un registro \n»); printf(«\t 6 – Guardar datos en un archivo \n»); printf(«\t 7 – Recuperar datos desde un archivo \n»); printf(«Tu opcion: «); char opcion = getchar(); printf(«La opción que has seleccionado es: %c \n»,opcion); switch(opcion){     case ‘1’:         listadoRegistros();         break;        case ‘2’:         introducirRegistro();         break;        case ‘3’:         eliminarRegistro();         break;        case ‘4’:         buscarRegistro();         break;     case ‘5’:         actualizarRegistro();         break;       case ‘6’:         guardarDatos();         break;       case ‘7’:         recuperarDatos();         break;        default:            printf(«La opción que has introducido no es válida»);             printf(«Pulsa Enter para volver al menú principal \n»);     getchar();     getchar();     printf(«\033[2J»);     menuPrincipal();                        break; }}

guardarDatos.c
void guardarDatos(){    printf(«\033[2J»);    // Creamos un archivo    FILE *archivo;    archivo = fopen(«agenda.txt»,»w»);    // Recorremos los registros uno a uno, los mostramos por pantalla    for(int i = 1; i<=longitudDatos;i++){        fprintf(archivo,»%s|%s|%s \n»,agenda[i].nombre,agenda[i].telefono,agenda[i].email);    }    fclose(archivo);    // Volvemos al menu principal    printf(«Pulsa Enter para volver al menú principal \n»);    getchar();    getchar();    printf(«\033[2J»);    menuPrincipal();}

recuperarDatos.c
void recuperarDatos(){        printf(«\033[2J»);    // Declaraciones iniciales        char cadena[80];       const char delimitador[2] = «|»;       char *partido;       FILE *archivo;   // Abrimos un archivo    archivo = fopen(«agenda.txt»,»r»);   // Leemos el archivo linea a linea        while( fgets (cadena, 60, archivo)!=NULL ){            // Partimos lineas a structs                partido = strtok(cadena, delimitador);                int contador = 0;                longitudDatos++;                while( partido != NULL ) {                  if(contador == 0){strcpy(agenda[longitudDatos].nombre,partido);}                  if(contador == 1){strcpy(agenda[longitudDatos].telefono,partido);}                  if(contador == 2){strcpy(agenda[longitudDatos].email,partido);}                  partido = strtok(NULL, delimitador);                  contador++;               }        }   // Feedback al usuario        printf(«Registros cargados, pulsa una tecla para volver al menu inicial \n»);        getchar();        getchar();    // Volvemos al menu principal        printf(«\033[2J»);        menuPrincipal();   }

Sobre la instruccion de partir cadenas a mtriz

main.c
#include <stdio.h>#include <string.h>
int main(int argc, char** argv) {    char cadena[80] = «primero|segundo|tercero»;   const char delimitador[2] = «|»;   char *partido;      partido = strtok(cadena, delimitador);      while( partido != NULL ) {      printf( » %s\n», partido );          partido = strtok(NULL, delimitador);   }      return(0);}

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *