• Lunes 29 de Abril de 2024, 02:15
« anterior próximo »
Páginas: [1]

Autor Tema:  archivos  (Leído 1468 veces)

faio

  • Nuevo Miembro
  • *
  • Mensajes: 5
    • Ver Perfil
archivos
« en: Miércoles 2 de Junio de 2010, 19:29 »
0
me falta la parte de archivos que no funciona, hace tiempo que no programo en c y olvide algunas cosas

Código: C
  1.  
  2.  
  3. typedef struct nodoagenda{
  4.         int dni;
  5.         char nombre[15];
  6.         char apellidos[25];
  7.         char direccion[30];
  8.         struct nodoagenda *ant;
  9.         struct nodoagenda *sig;
  10.         }nodoagenda;
  11.  
  12.        
  13. void CrearAgenda(nodoagenda *(&));
  14.  
  15. int AgendaVacia(nodoagenda *);
  16.  
  17. int AgendaLlena(nodoagenda *);
  18.  
  19. int EstaElementoAgenda(nodoagenda *,int);
  20.  
  21. void InsertarAgenda(nodoagenda *(&));
  22.  
  23. void EliminarElementoAgenda(nodoagenda *(&));
  24.  
  25. void MostrarInversoAgenda(nodoagenda *);
  26.  
  27. void BorrarAgenda(nodoagenda *(&));
  28.  
  29. void GuardarAgenda(nodoagenda *);
  30.  
  31. void LeerAgenda(nodoagenda *listad);
  32.  
  33.  
  34.  
  35. //
  36. void CrearAgenda(nodoagenda *(&listad))
  37. {
  38.      listad = NULL;
  39. }
  40. /*****************************************************************************************/
  41. int AgendaVacia(nodoagenda *listad)
  42. {
  43.     int dev = 0;
  44.    
  45.     if (listad==NULL)
  46.        dev = -1;
  47.    
  48.     return dev;
  49. }
  50. /*****************************************************************************************/
  51. // Controlaremos la memoria en la insercion de elementos en la lista
  52. int AgendaLlena(nodoagenda *)
  53. {
  54.     return 0;
  55. }
  56. /*****************************************************************************************/
  57. // Devuelve -1 si el elemento esta en la lista. 0 en caso contrario
  58. int EstaElementoAgenda(nodoagenda *listad,int dni)
  59. {
  60.       nodoagenda *Paux;
  61.       int res;
  62.      
  63.       Paux = listad;
  64.       while ((Paux != NULL)&&(Paux->dni != dni))
  65.             Paux = Paux->sig;
  66.      
  67.       if (Paux == NULL)
  68.          res = 0;
  69.       else
  70.           res = -1;
  71.      
  72.       return res;
  73. }
  74. /*****************************************************************************************/
  75. void InsertarAgenda(nodoagenda *(&listad))
  76. {
  77.      nodoagenda *Nuevonodo, *Paux;
  78.      int dni;
  79.      char nombre[15],apellidos[25];
  80.      
  81.      Nuevonodo = (nodoagenda *)malloc(sizeof(nodoagenda));
  82.      if (Nuevonodo == NULL)
  83.         printf("nSe produjo un error en la creación del elemento.");
  84.      else
  85.      {
  86.          do{
  87.             printf("Introduce el dni: ");
  88.             scanf("%d",&dni);
  89.          }while((dni < 1)||(EstaElementoAgenda(listad,dni)));
  90.          Nuevonodo->dni = dni;
  91.          fflush(stdin);    //Borra el buffer de teclado
  92.          printf("Introduce el nombre: ");
  93.          gets(Nuevonodo->nombre);
  94.          printf("Introduce los apellidos: ");
  95.          gets(Nuevonodo->apellidos);
  96.          printf("Introduce la direccion: ");
  97.          gets(Nuevonodo->direccion);
  98.          Nuevonodo->sig = NULL;
  99.          Nuevonodo->ant = NULL;
  100.          
  101.          if (AgendaVacia(listad))
  102.             listad = Nuevonodo;
  103.          else
  104.          {
  105.              if (dni > listad->dni)
  106.              {
  107.                 Nuevonodo->sig = listad;
  108.                 listad->ant=Nuevonodo;
  109.                 listad = Nuevonodo;
  110.              }
  111.              else
  112.              {
  113.                  Paux = listad;
  114.                  while (((Paux->sig)!=NULL)&&((dni < Paux->sig->dni)))
  115.                        Paux = Paux->sig;
  116.                  
  117.                  if (Paux->sig != NULL)  //Si no es el ultimo nodo
  118.                     Paux->sig->ant=Nuevonodo;
  119.                    
  120.                  Nuevonodo->sig = Paux->sig;
  121.                  Nuevonodo->ant = Paux;
  122.                  Paux->sig = Nuevonodo;
  123.                      
  124.              }
  125.          }
  126.      }        
  127. }
  128.  
  129. /*****************************************************************************************/
  130. void EliminarElementoAgenda(nodoagenda *(&listad),int dni)
  131. {
  132.    nodoagenda *actual = listad;
  133.    
  134.    while (actual->dni != dni)
  135.          actual = actual->sig;
  136.    
  137.    if (actual->ant == NULL)    // Es el primer nodo de la lista
  138.    {
  139.       if (actual->sig!=NULL)           // Hay mas de un nodo en la lista
  140.           actual->sig->ant=NULL;
  141.          
  142.       listad=actual->sig;
  143.    }
  144.    else
  145.    {
  146.        if (actual->sig!=NULL)           // Es el ultimo nodo de la lista
  147.           actual->sig->ant=actual->ant;
  148.    
  149.        actual->ant->sig=actual->sig;
  150.    }    
  151.    
  152.    free(actual);
  153. }
  154. /*****************************************************************************************/
  155. void MostrarInversoAgenda(nodoagenda *listad)
  156. {
  157.      nodoagenda *paux=listad;
  158.      
  159.      if (paux != NULL)
  160.      {
  161.         // Recorremos toda la lista hasta el final      
  162.         while (paux->sig != NULL)
  163.            paux=paux->sig;
  164.        
  165.         // Recorremos toda la lista en orden inverso hasta el primer nodo
  166.         while (paux != NULL)
  167.         {
  168.               printf("nnDNI: %d",paux->dni);
  169.               printf("nNombre: %s",paux->nombre);
  170.               printf("nApellidos: %s",paux->apellidos);
  171.               printf("nDireccion: %s",paux->direccion);
  172.               paux=paux->ant;
  173.         }
  174.      }
  175. }
  176. /*****************************************************************************************/
  177. void BorrarAgenda(nodoagenda *(&listad))
  178. {
  179.      nodoagenda *paux;
  180.      
  181.      while (listad != NULL)
  182.      {
  183.         paux=listad;
  184.         listad=listad->sig;
  185.         free(paux);
  186.      }
  187. }
  188. /*****************************************************************************************/
  189. void GuardarAgenda(nodoagenda *listad)
  190. {
  191.      nodoagenda *paux=listad;
  192.      FILE*pFile;
  193.      
  194.      if (paux != NULL)
  195.      {
  196.         // Recorremos toda la lista hasta el final      
  197.         while (paux->sig != NULL)
  198.            paux=paux->sig;
  199.        
  200.    
  201.  
  202.         pFile = fopen ( "amigos.txt" , "wb" );//abrir fichero
  203.          
  204.          if(pFile== NULL)
  205.              puts ("nError guardando el fichero.");
  206.           else
  207.          {
  208.        
  209.        
  210.         // Recorremos toda la lista en orden inverso hasta el primer nodo
  211.                       while (paux != NULL)
  212.                       {
  213.              
  214.                        
  215.                       fwrite(&paux, sizeof paux, 1, pFile);
  216.                        printf("nnDNI: %d",paux->dni);
  217.                        printf("nNombre: %s",paux->nombre);
  218.                        printf("nApellidos: %s",paux->apellidos);
  219.                        printf("nDireccion: %s",paux->direccion);
  220.                        paux=paux->ant;
  221.                        }
  222.                        
  223.                                   if( !fclose(pFile) )
  224.                                       printf( "Fichero Guardadon" );
  225.                                   else
  226.                                       printf( "Error: Fichero NO Guardadon" );
  227.          }
  228.      }
  229. }
  230. /*****************************************************************************************/
  231. void LeerAgenda(nodoagenda *listad)
  232. {
  233.      nodoagenda *Nuevonodo;
  234.      
  235.    FILE *file = fopen("amigo.txt", "rb");
  236.  
  237.    if ( file != NULL )
  238.    {
  239.  
  240.  
  241.       fclose(file);
  242.    }
  243.  
  244. }
  245.  
  246.  
  247.  

Gracias de antemano.

czealt

  • Miembro activo
  • **
  • Mensajes: 28
    • Ver Perfil
Re: archivos
« Respuesta #1 en: Martes 8 de Junio de 2010, 08:04 »
0
Debes reemplazar la linea:
   fwrite(&paux, sizeof paux, 1, pFile);

por la siguiente:
   fwrite(paux, sizeof(nodoagenda), 1, pFile);

Saludos :good:

faio

  • Nuevo Miembro
  • *
  • Mensajes: 5
    • Ver Perfil
Re: archivos
« Respuesta #2 en: Martes 8 de Junio de 2010, 09:30 »
0
Muchas gracias
 y la condición para leer la sabrías

czealt

  • Miembro activo
  • **
  • Mensajes: 28
    • Ver Perfil
Re: archivos
« Respuesta #3 en: Jueves 10 de Junio de 2010, 04:14 »
0
Bueno, para leer datos de un archivo binario se usa la funcion fread() que acepta los mismos 4 parametros que la funcion fwrite() solo que en lugar de escribir del buffer al disco se lee del disco al buffer.

Ejemplo:
Código: C
  1.  
  2. void LeerAgenda()
  3. {
  4.   nodoagenda nodo;
  5.  
  6.   FILE *file = fopen("amigos.txt", "rb");
  7.  
  8.   while(fread(&nodo,sizeof(nodoagenda),1,file)) /* fread() devuelve la cantidad de registros leidos, cuando se llega al final del archivo este valor es 0 y el bucle termina. */
  9.   {
  10.     printf("DNI: %dn",nodo.dni);
  11.     printf("Nombre: %sn",nodo.nombre);
  12.     printf("Apellidos: %sn",nodo.apellidos);
  13.     printf("Direccion: %sn",nodo.direccion);
  14.   }
  15.  
  16.   fclose(file);
  17. }
  18.  
  19.  
  20.  

faio

  • Nuevo Miembro
  • *
  • Mensajes: 5
    • Ver Perfil
Re: archivos
« Respuesta #4 en: Jueves 10 de Junio de 2010, 15:14 »
0
Gestoragenda.c
Código: C
  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <iostream.h>
  5. #include <conio.h>
  6. #include "agenda.h"
  7.  
  8. char Menu(void);
  9.  
  10. int main(void)
  11. {
  12.     nodoagenda *lista;
  13.     int num;
  14.     char op;
  15.    
  16.     CrearAgenda(lista);
  17.    
  18.     do{
  19.        op = Menu();
  20.    
  21.        switch(op)
  22.        {
  23.           //***********************************
  24.           case 'A':
  25.           {
  26.              if (!AgendaLlena(lista))
  27.                 InsertarAgenda(lista);
  28.              else
  29.                  printf("nNo se puede insertar debido a que la lista esta llena.");
  30.                  
  31.              break;
  32.           }
  33.           //***********************************
  34.           case 'B':
  35.           {
  36.              do{
  37.                  printf("Introduce el dni de la persona a eliminar: ");
  38.                  scanf("%d",&num);
  39.              }while (num<1);
  40.              
  41.              if (EstaElementoAgenda(lista,num))
  42.                 EliminarElementoAgenda(lista,num);
  43.              else
  44.                 printf("nEsa persona no se encuentra en la lista.");
  45.                
  46.              break;
  47.           }
  48.           //***********************************
  49.           case 'C':
  50.           {
  51.             printf("n");
  52.             MostrarInversoAgenda(lista);
  53.             getch();
  54.            
  55.             break;
  56.           }
  57.           //***********************************
  58.           case 'D'://guardar en fichero
  59.           {
  60.                            printf("n");
  61.             GuardarAgenda(lista);
  62.             getch();
  63.              
  64.              break;
  65.           }
  66.           //***********************************
  67.           case 'E'://leer de fichero
  68.           {
  69.           printf("n");
  70.              LeerAgenda();
  71.              getch();
  72.              
  73.              break;
  74.           }
  75.           //***********************************
  76.           case 'F'://borrar y salir
  77.           {
  78.              BorrarAgenda(lista);
  79.              
  80.              break;
  81.           }
  82.        }
  83.     }while (op!='F');
  84.  
  85.     printf("nn");
  86.     system("pause");
  87. }
  88.  
  89. char Menu(void)
  90. {
  91.      char opcion;
  92.      
  93.      do{
  94.           fflush(stdin);
  95.           system("cls");
  96.           printf("n***************************************************************** ");
  97.           printf("n                 A - Insertar en Agenda");
  98.           printf("n                 B - Eliminar de Agenda");
  99.           printf("n                 C - Mostrar Agenda Orden Creciente");
  100.           printf("n                 D - Guardar Agenda");
  101.           printf("n                 E - Leer de Fichero");
  102.           printf("n                 F - Borrar agenda y Salir");
  103.           printf("n***************************************************************** ");
  104.           printf("nIntroduce una opcion: ");
  105.           scanf("%c",&opcion);
  106.           system("cls");
  107.           opcion = toupper(opcion);    //tolower
  108.      }while ((opcion<'A')||(opcion>'F'));
  109.      
  110.      return opcion;
  111. }
  112.  
  113.  

agenda.h
Código: C
  1.  
  2. typedef struct nodoagenda{
  3.         int dni;
  4.         char nombre[15];
  5.         char apellidos[25];
  6.         char direccion[30];
  7.         struct nodoagenda *ant;
  8.         struct nodoagenda *sig;
  9.         }nodoagenda;
  10.  
  11.        
  12. void CrearAgenda(nodoagenda *(&));
  13.  
  14. int AgendaVacia(nodoagenda *);
  15.  
  16. int AgendaLlena(nodoagenda *);
  17.  
  18. int EstaElementoAgenda(nodoagenda *,int);
  19.  
  20. void InsertarAgenda(nodoagenda *(&));
  21.  
  22. void EliminarElementoAgenda(nodoagenda *(&));
  23.  
  24. void MostrarInversoAgenda(nodoagenda *);
  25.  
  26. void BorrarAgenda(nodoagenda *(&));
  27.  
  28. void GuardarAgenda(nodoagenda *);
  29.  
  30. void LeerAgenda();
  31.  
  32.  
  33.  
  34. //
  35. void CrearAgenda(nodoagenda *(&listad))
  36. {
  37.      listad = NULL;
  38. }
  39. /*****************************************************************************************/
  40. int AgendaVacia(nodoagenda *listad)
  41. {
  42.     int dev = 0;
  43.    
  44.     if (listad==NULL)
  45.        dev = -1;
  46.    
  47.     return dev;
  48. }
  49. /*****************************************************************************************/
  50. // Controlaremos la memoria en la insercion de elementos en la lista
  51. int AgendaLlena(nodoagenda *)
  52. {
  53.     return 0;
  54. }
  55. /*****************************************************************************************/
  56. // Devuelve -1 si el elemento esta en la lista. 0 en caso contrario
  57. int EstaElementoAgenda(nodoagenda *listad,int dni)
  58. {
  59.       nodoagenda *Paux;
  60.       int res;
  61.      
  62.       Paux = listad;
  63.       while ((Paux != NULL)&&(Paux->dni != dni))
  64.             Paux = Paux->sig;
  65.      
  66.       if (Paux == NULL)
  67.          res = 0;
  68.       else
  69.           res = -1;
  70.      
  71.       return res;
  72. }
  73. /*****************************************************************************************/
  74. void InsertarAgenda(nodoagenda *(&listad))
  75. {
  76.      nodoagenda *Nuevonodo, *Paux;
  77.      int dni;
  78.      char nombre[15],apellidos[25];
  79.      
  80.      Nuevonodo = (nodoagenda *)malloc(sizeof(nodoagenda));
  81.      if (Nuevonodo == NULL)
  82.         printf("nSe produjo un error en la creación del elemento.");
  83.      else
  84.      {
  85.          do{
  86.             printf("Introduce el dni sin letra: ");
  87.             scanf("%d",&dni);
  88.          }while((dni < 1)||(EstaElementoAgenda(listad,dni)));
  89.          Nuevonodo->dni = dni;
  90.          fflush(stdin);    //Borra el buffer de teclado
  91.          printf("Introduce el nombre: ");
  92.          gets(Nuevonodo->nombre);
  93.          printf("Introduce los apellidos: ");
  94.          gets(Nuevonodo->apellidos);
  95.          printf("Introduce la direccion: ");
  96.          gets(Nuevonodo->direccion);
  97.          Nuevonodo->sig = NULL;
  98.          Nuevonodo->ant = NULL;
  99.          
  100.          if (AgendaVacia(listad))
  101.             listad = Nuevonodo;
  102.          else
  103.          {
  104.              if (dni > listad->dni)
  105.              {
  106.                 Nuevonodo->sig = listad;
  107.                 listad->ant=Nuevonodo;
  108.                 listad = Nuevonodo;
  109.              }
  110.              else
  111.              {
  112.                  Paux = listad;
  113.                  while (((Paux->sig)!=NULL)&&((dni < Paux->sig->dni)))
  114.                        Paux = Paux->sig;
  115.                  
  116.                  if (Paux->sig != NULL)  //Si no es el ultimo nodo
  117.                     Paux->sig->ant=Nuevonodo;
  118.                    
  119.                  Nuevonodo->sig = Paux->sig;
  120.                  Nuevonodo->ant = Paux;
  121.                  Paux->sig = Nuevonodo;
  122.                      
  123.              }
  124.          }
  125.      }        
  126. }
  127.  
  128. /*****************************************************************************************/
  129. void EliminarElementoAgenda(nodoagenda *(&listad),int dni)
  130. {
  131.    nodoagenda *actual = listad;
  132.    
  133.    while (actual->dni != dni)
  134.          actual = actual->sig;
  135.    
  136.    if (actual->ant == NULL)    // Es el primer nodo de la lista
  137.    {
  138.       if (actual->sig!=NULL)           // Hay mas de un nodo en la lista
  139.           actual->sig->ant=NULL;
  140.          
  141.       listad=actual->sig;
  142.    }
  143.    else
  144.    {
  145.        if (actual->sig!=NULL)           // Es el ultimo nodo de la lista
  146.           actual->sig->ant=actual->ant;
  147.    
  148.        actual->ant->sig=actual->sig;
  149.    }    
  150.    
  151.    free(actual);
  152. }
  153. /*****************************************************************************************/
  154. void MostrarInversoAgenda(nodoagenda *listad)
  155. {
  156.      nodoagenda *paux=listad;
  157.      
  158.      if (paux != NULL)
  159.      {
  160.         // Recorremos toda la lista hasta el final      
  161.         while (paux->sig != NULL)
  162.            paux=paux->sig;
  163.        
  164.         // Recorremos toda la lista en orden inverso hasta el primer nodo
  165.         while (paux != NULL)
  166.         {
  167.               printf("nnDNI: %d",paux->dni);
  168.               printf("nNombre: %s",paux->nombre);
  169.               printf("nApellidos: %s",paux->apellidos);
  170.               printf("nDireccion: %s",paux->direccion);
  171.               paux=paux->ant;
  172.         }
  173.      }
  174. }
  175. /*****************************************************************************************/
  176. void BorrarAgenda(nodoagenda *(&listad))
  177. {
  178.      nodoagenda *paux;
  179.      
  180.      while (listad != NULL)
  181.      {
  182.         paux=listad;
  183.         listad=listad->sig;
  184.         free(paux);
  185.      }
  186. }
  187. /*****************************************************************************************/
  188. void GuardarAgenda(nodoagenda *listad)
  189. {
  190.      nodoagenda *paux=listad;
  191.      FILE*pFile;
  192.      int i=0;
  193.      
  194.      if (paux != NULL)
  195.      {
  196.         // Recorremos toda la lista hasta el final      
  197.         while (paux->sig != NULL)
  198.            paux=paux->sig;
  199.        
  200.    
  201.  
  202.         pFile = fopen ( "amigos.dat" , "wb" );//abrir fichero
  203.          
  204.          if(pFile== NULL)
  205.              puts ("nError guardando el fichero.");
  206.           else
  207.          {
  208.        
  209.        
  210.         // Recorremos toda la lista en orden inverso hasta el primer nodo
  211.                       while (paux != NULL)
  212.                       {
  213.                       fwrite(paux, sizeof(nodoagenda), 1, pFile);
  214.                        paux=paux->ant;
  215.                        }
  216.                        
  217.                                   if( !fclose(pFile) )
  218.                                       printf( "Fichero Guardadon" );
  219.                                   else
  220.                                       printf( "Error: Fichero NO Guardadon" );
  221.          }
  222.      }
  223. }
  224. /*****************************************************************************************/
  225. void LeerAgenda()
  226. {
  227.    nodoagenda nodo;
  228.  
  229.    FILE*pFile = fopen("amigos.dat", "rb");
  230.  
  231.    while(fread(&nodo,sizeof(nodoagenda),1,pFile)) /* fread() devuelve la cantidad de registros leidos, cuando se llega al final del archivo este valor es 0 y el bucle termina. */
  232.    {
  233.      printf("DNI: %dn",nodo.dni);
  234.      printf("Nombre: %sn",nodo.nombre);
  235.      printf("Apellidos: %sn",nodo.apellidos);
  236.      printf("Direccion: %sn",nodo.direccion);
  237.    }
  238.  
  239.    fclose(pFile);
  240.  
  241. }
  242.  
  243.  

Muchisimas gracias, Ahora va perfecto.
Páginas: [1]
« anterior próximo »