SoloCodigo

Programación General => C/C++ => Mensaje iniciado por: nicksynm en Viernes 27 de Noviembre de 2009, 18:13

Título: Como guardo en archivo de texto
Publicado por: nicksynm en Viernes 27 de Noviembre de 2009, 18:13
Holas,

Estoy elaborando un tp sobre una clinica de animales. El cual lo tengo casi todo completo menos la funcion consultas:
 
En la cual tengo que crear varios archivos de texto , por cada consulta que tenga cada animal, es decir, si un mismo animal hace tres consultas creo 3 archivos de texto con los datos de la consulta. el nombre del archivo tiene que ser asi "xxxx1co"hora""   (xxxx1 Identificador del animal, co consultas, hora de hora), esto no es mi problema lo hago con cadena=sprintf, mi problema es que no se como se guarda una estructura en un archivo de texto, la verdad no tengo la menor idea, me gustaria saber si me podrian ayudar, o por lo menos darme una idea de comandos utilizar.

Código: C
  1. Esta es la estructura que debo guardar en el archivo:
  2.  
  3. typedef struct {
  4.       char motivo[MIX];
  5.       char diagnostico[MAX];
  6.       char tratamiento[MAX];
  7.       char veterinario[MIX];
  8.       struct{
  9.           int aa, mm, dd;
  10.       }fechacontrol;
  11.   }sconsulta;
  12.  
Título: Re: Como guardo en archivo de texto
Publicado por: ProfesorX en Viernes 27 de Noviembre de 2009, 19:43
Puedes usar las funciones de C fopen(), fclose() y fprintf(), abre el archivo como texto con fopen(), y en la funcion fprintf separa tus argumentos con comas, y agrega un n al final de fprintf para que cada registro te quede en una linea algo mas o menos asi:

Código: C
  1.  
  2.     fprintf(miarchivo, "%s,%s,%,%s,%s,%d,%d,%dn",
  3.         consulta.motivo, consulta.diagnostico, consulta.tratamiento,
  4.         consulta.veterinario, consulta.fechacontrol.aa,
  5.         consulta.fechacontrol.mm, consulta.fechacontrol.dd);
  6.  
  7.  

Cuando termines usas fclose() para cerrar tu archivo.

Saludos y suerte :)
Título: Re: Como guardo en archivo de texto
Publicado por: nicksynm en Viernes 27 de Noviembre de 2009, 20:08
Se abrir el archivo y tambien cerrarlo, pensaba usar el sprintf para asignarle el nombre al archivo. Tambien lo puedo usar para guardar datos en el mismo?.
Título: Re: Como guardo en archivo de texto
Publicado por: ProfesorX en Sábado 28 de Noviembre de 2009, 02:07
Cita de: "nicksynm"
Se abrir el archivo y tambien cerrarlo, pensaba usar el sprintf para asignarle el nombre al archivo. Tambien lo puedo usar para guardar datos en el mismo?.

No, para guardar datos usa  fprintf como te mencione arriba, no sprintf. Es casi igual que todos los printf, pero en lugar de enviar los resultados a pantalla (printf) o a una cadena, (sprintf) te los manda a un archivo.
Saludos :)
Título: Re: Como guardo en archivo de texto
Publicado por: nicksynm en Sábado 28 de Noviembre de 2009, 03:28
Tenes razon, habia leido mal, gracias. Pruebo y te comento.
Título: Re: Como guardo en archivo de texto
Publicado por: nicksynm en Sábado 28 de Noviembre de 2009, 18:57
Listo ya resolví este tema,

Además de la funcion consultas yo cree otro par de funciones alergias y vacunaciones, las cuales todas hacen los mismo. Pero me piden que después imprima todo el historial clínico del animal, es decir, que ingreso el id del animal verifico si es correcto entonces veo si tiene archivos e imprimo todos los archivos de consultas, vacunación, y alergias del animal.

el formato de los nombres de mis archivos es este    idCfechahora, la letra "c" es por consulta la "v" por vacunacion y la "a" por alergias va variando. Yo supongo que si realizo un archivo=fopen("idc*","rt") debería en teoría abrir todos los archivos de consulta no?, pero la verdad que no se como leer los archivos ni como concatenarlos.

tengo entendido que puedo usar la funcion "cat" de bach para concatenar, pero no se como aplicarla.

Saludos


Edito: aca pego el codigo de mi programa completo, aunque no es realmente necesario.


Código: C
  1. Sistema centralizado de historia clínica de animales
  2.  
  3.  
  4. /* ***************  A R C H I V O S  D E  C A B E C E R A  ************* */
  5. #include <stdio.h>
  6. #include <conio.h>
  7. #include <string.h>
  8. #include <stdlib.h>
  9. #include <time.h>
  10.  
  11. /* *******  D E C L A R A C I O N E S  ******* */
  12. #pragma warning (disable:4996)
  13. #pragma warning (disable:4101)
  14. #define ruta " "
  15. #define LARCHFOTO  60  /* Path/nombre archivo foto */
  16. #define LESP      50             /* Especie */
  17. #define LRAZA  50      
  18. #define MIX 100
  19. #define MAX 500
  20. #define CANT 100
  21.  
  22. /* *******  D E C L A R A C I O N E S  M E N U******* */
  23.  
  24. #define ALTA 1
  25. #define MODIF 2
  26. #define CONSULTA 3
  27. #define VACUNAS 4
  28. #define ALERGIAS 5
  29. #define HISTORIAL 6
  30. #define FOTO 7
  31. #define SALIR 8
  32. #define ESPECIE 9
  33. #define RAZA 10
  34. #define FECH 11
  35. #define SEXO 12
  36. #define PATHFOTO 13
  37. #define SALIRMOD 14
  38.  
  39.  
  40.  
  41.  
  42.  
  43. /* ***  D E C L A R A C I O N E S  D E  T I P O S  D E  D A T O S  *** */
  44.  
  45.    typedef struct {
  46.        int identificador; /* 4 dígitos*/
  47.        char especie[LESP];
  48.        char raza [LRAZA];
  49.             struct {
  50.                 int aa, mm, dd;
  51.             } fechaNac;
  52.        char sexo;
  53.        char archFoto [LARCHFOTO];
  54.    } sanimal;
  55.  
  56.    typedef struct n
  57.    {
  58.        sanimal animal;
  59.        struct n *sig;
  60.    }nodo, *pNodo;
  61.  
  62.    typedef struct {
  63.        char motivo[MIX];
  64.        char diagnostico[MAX];
  65.        char tratamiento[MAX];
  66.        char veterinario[MIX];
  67.        struct{
  68.            int aa, mm, dd;
  69.        }fechacontrol;
  70.        
  71.    }sconsulta;
  72.  
  73.    typedef struct {
  74.        char vacuna[MIX];
  75.        char plansatinario[MIX];
  76.        char planaplicacion[MIX];
  77.        struct{
  78.            int aa, mm, dd;
  79.        }fechavenc;
  80.        char observaciones[MAX];
  81.        
  82.    }svacuna;
  83.  
  84.    typedef struct {
  85.        struct{
  86.            int aa, mm, dd;
  87.        }fecha;
  88.        char alergia [MIX];
  89.        char trata[MAX];    /*tratamiento*/
  90.        char observ [MAX];  /*observaciones*/
  91.        
  92.    }salergia;
  93.  
  94.    /*la identificacion de consulta, vacunas y alergias, es la misma si hablamos del mismo animal, creo que es asi*/
  95. /* ********  D E C L A R A C I O N E S  D E  F U N C I O N E S  ******* */
  96.  
  97. int menu(void);
  98. void cargarlista(pNodo *cabeza);
  99. void alta(pNodo *cabeza);
  100. int menumod (void);
  101. void modificar(pNodo *cabeza);
  102. void infconsultas(pNodo cabeza);
  103. void infalergias(pNodo cabeza);
  104. void infvacunacion(pNodo cabeza);
  105. void hiscomp(pNodo cabeza);
  106. void fotoanimal(pNodo cabeza);
  107. void guardararchivo(pNodo *cabeza);
  108.  
  109.  
  110.  
  111.  
  112. /* *********  M A I N  ******** */
  113. int main (){
  114.  
  115.     pNodo cabeza;
  116.     int opc=0;
  117.     int idanimal=0;
  118.     cabeza=NULL;
  119.     printf("Bienvenido al sistema de gestion de clinicas veterinariasnna");
  120.    
  121.     while((opc=menu())!=SALIR)
  122.     {
  123.  
  124.         switch(opc)
  125.         {
  126.         case ALTA:
  127.             alta(&cabeza);
  128.             break;
  129.         case MODIF:
  130.             modificar(&cabeza);
  131.             break;
  132.         case CONSULTA:
  133.             infconsultas(cabeza);
  134.             break;
  135.         case VACUNAS:
  136.             infvacunacion(cabeza);
  137.             break;
  138.         case ALERGIAS:
  139.             infalergias(cabeza);
  140.             break;
  141.         case HISTORIAL:
  142.             hiscomp(cabeza);
  143.             break;
  144.         case FOTO:
  145.             fotoanimal(cabeza);
  146.             break;
  147.         }
  148.     };
  149.     guardararchivo(&cabeza);
  150.  
  151.     return 0;
  152. }
  153.  
  154. /* *********  D E F I N I C I O N E S  D E  F U N C I O N E S  ******** */
  155.  
  156. int menu (void){
  157.     int opc, rc;
  158.     do{
  159.         printf("Ingrese la opcion deseadann");
  160.         printf("1- Alta animaln");
  161.         printf("2- Modificar Animaln");
  162.         printf("3- Agregar consultan");
  163.         printf("4- Agregar infomacion vacunasn");
  164.         printf("5- Agregar informacion alergiasn");
  165.         printf("6- Mostrar historial animaln");
  166.         printf("7- Ver foto animaln");
  167.         printf("8- SalirnnOpcion:n");
  168.         rc=scanf("%d",&opc);
  169.         printf("a");
  170.         fgetc(stdin);
  171.     }while(rc!=1 || opc<ALTA || opc>SALIR);
  172.     return opc;
  173.     scanf("%d",&opc);
  174.     return opc;
  175. }
  176. /*COMPLETA*/
  177. void cargarlista(pNodo *cabeza){
  178.     pNodo nuevo;
  179.     FILE *animales;
  180.     char aux[100];
  181.     char aux2[100];
  182.     strcpy(aux,ruta);
  183.     strcpy(aux2,"veterinaria.dat");
  184.     strcat(aux,aux2);
  185.     printf("%s",aux2);
  186.     animales=fopen("aux","rb");
  187.     if(animales==NULL)
  188.     {
  189.         printf("Se crea archivo nuevo");
  190.         animales=fopen("veterinaria.dat","wb");
  191.     return;
  192.     }
  193.     while(!feof(animales))
  194.     {
  195.         nuevo= malloc(sizeof(nodo));
  196.         fwrite(&nuevo,sizeof(nodo),1,animales);
  197.         *cabeza=nuevo;
  198.         nuevo->sig=NULL;
  199.         fwrite(&nuevo,sizeof(nodo),1,animales);
  200.     }
  201.  
  202.     fclose(animales);
  203. }
  204. /*completo*/
  205.        
  206. void alta(pNodo *cabeza)
  207. {
  208.     pNodo anterior;
  209.     pNodo actual;
  210.     pNodo nuevo;
  211.     pNodo indice;
  212.  
  213.     indice=*cabeza;
  214.     if(*cabeza==NULL)
  215.     {
  216.         nuevo=malloc(sizeof(nodo));
  217.         *cabeza=nuevo;
  218.         nuevo->sig=NULL;
  219.         nuevo->animal.identificador=1000;
  220.         }
  221.     else
  222.     {
  223.         nuevo=malloc(sizeof(nodo));
  224.         anterior=NULL;
  225.         actual=*cabeza;
  226.         while(actual!=NULL)
  227.         {
  228.             anterior=actual;
  229.             actual=actual->sig;
  230.         }
  231.         anterior->sig=nuevo;
  232.         nuevo->sig=NULL;
  233.     }
  234. printf("Ingrese datos del animaln");
  235. printf("Ingrese especie:");
  236. gets(nuevo->animal.especie);
  237. printf("Ingrese raza:");
  238. gets(nuevo->animal.raza);
  239. printf("Ingrese fecha de nacimiento:n");
  240. printf("Dia:");
  241. scanf("%d",&nuevo->animal.fechaNac.dd);
  242. while(nuevo->animal.fechaNac.dd > 31 || nuevo->animal.fechaNac.dd < 1){
  243.     printf("Dia:");
  244.     scanf("%d",&nuevo->animal.fechaNac.dd);
  245. }
  246. printf("Mes:");
  247. scanf("%d",&nuevo->animal.fechaNac.mm);
  248. while(nuevo->animal.fechaNac.mm > 12 || nuevo->animal.fechaNac.mm < 1){
  249.     printf("Mes:");
  250.     scanf("%d",&nuevo->animal.fechaNac.mm);
  251. }
  252. printf("Anio:");
  253. scanf("%d",&nuevo->animal.fechaNac.aa);
  254. while(nuevo->animal.fechaNac.aa > 3000 || nuevo->animal.fechaNac.aa < 1900){
  255.     printf("Anio:");
  256.     scanf("%d",&nuevo->animal.fechaNac.aa);
  257.  
  258. }
  259. fflush(stdin);  /*fflush cuando paso de entero a caracter para quitar el enter*/
  260. printf("Ingrese sexo: (M o F)");
  261. scanf("%c",&nuevo->animal.sexo); /*Nota: S cadena C caracter y lleva apersan)*/
  262. printf("Ingrese ruta de la foto: (Ej: C://animal.jpg)");
  263. scanf("%s",nuevo->animal.archFoto);
  264. if(nuevo->animal.identificador==1000){
  265. }
  266. else{
  267.     while(nuevo->animal.identificador!=1000){
  268.         indice=indice->sig;
  269.  
  270.         if(indice->sig==NULL){
  271.             nuevo->animal.identificador=indice->animal.identificador+1;
  272.  
  273.         }
  274.     }
  275. }
  276. }
  277. /*revisar*/
  278. int menumod (void){
  279.     int opc, rc;
  280.     opc=0;
  281.     do{
  282.         printf("Ingrese la opcion deseadann");
  283.         printf("9- Modificar especien");
  284.         printf("10- Modificar razan");
  285.         printf("11- Modificar fecha de nacimientosn");
  286.         printf("12- Modificar sexon");
  287.         printf("13- Modificar path de la foton");
  288.         printf("14- Salir de modificarn");
  289.         rc=scanf("%d",&opc);
  290.         printf("a");
  291.         fgetc(stdin);
  292.     }while(rc!=1 || opc<RAZA || opc>SALIRMOD);
  293.     return opc;
  294.     scanf("%d",&opc);
  295.     return opc;
  296. }
  297. /*completa*/
  298.  
  299.  
  300. void modificar(pNodo *cabeza){
  301.     pNodo aux;
  302.     int id=0, opc=0;
  303.     scanf("%d",&id);
  304.     aux=*cabeza;
  305.     printf("Ingrese el id del animal a modificarn");
  306.     scanf("%d",&id);
  307.     while(aux!=NULL){
  308.         if(aux->animal.identificador==id){
  309.             while((opc=menumod())!=SALIRMOD)
  310.             {
  311.                 switch(opc)
  312.                 {
  313.                 case ESPECIE:
  314.                     printf("Ingrese nueva especien");
  315.                     scanf("%s",aux->animal.especie);
  316.                     break;
  317.                 case RAZA:
  318.                     printf("Ingrese nueva razan");
  319.                     scanf("%s",aux->animal.raza);
  320.                     break;
  321.                 case FECH:
  322.                     printf("Ingrese nueva fecha de nacimienton");
  323.                     printf("Dia:");
  324.                     scanf("%d",&aux->animal.fechaNac.dd);
  325.                     while(aux->animal.fechaNac.dd > 31 || aux->animal.fechaNac.dd < 1){
  326.                         printf("Dia:");
  327.                         scanf("%d",&aux->animal.fechaNac.dd);
  328.                     }
  329.                     printf("Mes:");
  330.                     scanf("%d",&aux->animal.fechaNac.mm);
  331.                     while(aux->animal.fechaNac.mm > 12 || aux->animal.fechaNac.mm < 1){
  332.                         printf("Mes:");
  333.                         scanf("%d",&aux->animal.fechaNac.mm);
  334.                     }
  335.                     printf("Anio:");
  336.                     scanf("%d",&aux->animal.fechaNac.aa);
  337.                     while(aux->animal.fechaNac.aa > 3000 || aux->animal.fechaNac.aa < 1900){
  338.                         printf("Anio:");
  339.                         scanf("%d",&aux->animal.fechaNac.aa);
  340.                     }
  341.                     break;
  342.                 case SEXO:
  343.                     printf("Ingrese nuevo sexo: (M o F)");
  344.                     scanf("%c",&aux->animal.sexo);
  345.                     break;
  346.                 case PATHFOTO:
  347.                     printf("Ingrese la nueva ruta de la foto: (Ej: C://animal.jpg)");
  348.                     scanf("%s",aux->animal.archFoto);
  349.                     break;
  350.                 }
  351.            
  352.             };
  353.             return;
  354.         }
  355.         else{
  356.             aux=aux->sig;
  357.             if(aux==NULL){
  358.                 printf("El Id ingresado no es validon");
  359.  
  360.             }
  361.  
  362.         }
  363.  
  364.     }
  365. }
  366.  
  367.  
  368. /*completa*/
  369.  
  370.  
  371.  
  372. void fotoanimal (pNodo cabeza){
  373.     int id=0;
  374.     char start[MAX]={"start "};
  375.     printf("Ingrese el id del animal a mostrarn");
  376.     scanf("%d",&id);
  377.     while(cabeza!=NULL){
  378.         if(cabeza->animal.identificador==id){
  379.             system(strcat(start,cabeza->animal.archFoto));
  380.             cabeza=NULL;
  381.         }
  382.         else{
  383.             cabeza=cabeza->sig;
  384.             if(cabeza==NULL){
  385.                 printf("El Id ingresado no es validon");
  386.  
  387.             }
  388.  
  389.         }
  390.  
  391.     }
  392.  
  393. }
  394. /*completa*/
  395.  
  396.  
  397. void infconsultas(pNodo cabeza){
  398.     FILE *consultas;
  399.     sconsulta consulta;
  400.     struct tm *OurT=NULL;
  401.     int id=0;
  402.     char c[MIX]={"c"};
  403.     char txt[MIX]= {".txt"};
  404.     char nombre[MAX];
  405.     printf("ingrese id animal que realizo la consulta:n");
  406.     scanf("%d",&id);
  407.  
  408.     while(cabeza!=NULL){
  409.         if(cabeza->animal.identificador==id){
  410.             printf("Ingrese datos de la consulta");
  411.            
  412.             printf("Ingrese motivo de la consulta:n");
  413.             gets(consulta.motivo);
  414.             printf("Ingrese diagnostico:n");
  415.             gets(consulta.diagnostico);
  416.             printf("Ingrese tratamiento:n");
  417.             gets(consulta.tratamiento);
  418.             printf("Ingrese veterinario que los reviso:n");
  419.             gets(consulta.veterinario);
  420.             consulta.fechacontrol.dd=OurT->tm_yday;
  421.             consulta.fechacontrol.mm=OurT->tm_mon;
  422.             consulta.fechacontrol.aa=OurT->tm_year;
  423.             sprintf(nombre,"%d%s%d%d%d%d%d%s",id,c,OurT->tm_yday,OurT->tm_mon,OurT->tm_year,OurT->tm_hour,OurT->tm_min,txt);
  424.             consultas=fopen("nombre","wt");
  425.             fprintf(consultas,"%s%s%s%s%d%d%d",consulta.motivo,consulta.diagnostico,consulta.tratamiento,consulta.veterinario,consulta.fechacontrol.dd,consulta.fechacontrol.mm,consulta.fechacontrol.aa);
  426.             return;
  427.  
  428.  
  429.         }
  430.         else{
  431.             cabeza=cabeza->sig;
  432.             if(cabeza==NULL){
  433.                 printf("El Id ingresado no es validon");
  434.  
  435.             }
  436.  
  437.         }
  438.     }
  439. }
  440. /*completa*/
  441. void infalergias(pNodo cabeza){
  442.     FILE *alergias;
  443.     salergia alergia;
  444.     struct tm *OurT=NULL;
  445.     int id=0;
  446.     char c[MIX]={"a"};
  447.     char txt[MIX]= {".txt"};
  448.     char nombre[MAX];
  449.     printf("ingrese id animal con alergias:n");
  450.     scanf("%d",&id);
  451.  
  452.     while(cabeza!=NULL){
  453.         if(cabeza->animal.identificador==id){
  454.             printf("Ingrese datos de la alergia");
  455.            
  456.             printf("Ingrese nombre de la alergia:n");
  457.             gets(alergia.alergia);
  458.             printf("Ingrese tratamiento:n");
  459.             gets(alergia.trata);
  460.             printf("Ingrese observaciones:n");
  461.             gets(alergia.observ);
  462.             alergia.fecha.dd=OurT->tm_yday;
  463.             alergia.fecha.mm=OurT->tm_mon;
  464.             alergia.fecha.aa=OurT->tm_year;
  465.             sprintf(nombre,"%d%s%d%d%d%d%d%s",id,c,OurT->tm_yday,OurT->tm_mon,OurT->tm_year,OurT->tm_hour,OurT->tm_min,txt);
  466.             alergias=fopen("nombre","wt");
  467.             fprintf(alergias,"%s%s%s%d%d%d",alergia.alergia,alergia.trata,alergia.observ,alergia.fecha.dd,alergia.fecha.mm,alergia.fecha.aa);
  468.             return;
  469.         }
  470.         else{
  471.             cabeza=cabeza->sig;
  472.             if(cabeza==NULL){
  473.                 printf("El Id ingresado no es validon");
  474.  
  475.             }
  476.  
  477.         }
  478.     }
  479. }
  480. /*completa*/
  481. void infvacunacion(pNodo cabeza){
  482.     FILE *vacunas;
  483.     svacuna vacuna;
  484.     struct tm *OurT=NULL;
  485.     int id=0;
  486.     char c[MIX]={"v"};
  487.     char txt[MIX]= {".txt"};
  488.     char nombre[MAX];
  489.     printf("ingrese id animal que recibio vacunas:n");
  490.     scanf("%d",&id);
  491.  
  492.     while(cabeza!=NULL){
  493.         if(cabeza->animal.identificador==id){
  494.             printf("Ingrese datos de la vacuna");
  495.            
  496.             printf("Ingrese nombre de la vacuna:n");
  497.             gets(vacuna.vacuna);
  498.             printf("Ingrese plan sanitario:n");
  499.             gets(vacuna.plansatinario);
  500.             printf("Ingrese plan de aplicacion:n");
  501.             gets(vacuna.planaplicacion);
  502.             printf("Ingrese observacions:n");
  503.             gets(vacuna.observaciones);
  504.             vacuna.fechavenc.dd=OurT->tm_yday;
  505.             vacuna.fechavenc.mm=OurT->tm_mon;
  506.             vacuna.fechavenc.aa=OurT->tm_year;
  507.             sprintf(nombre,"%d%s%d%d%d%d%d%s",id,c,OurT->tm_yday,OurT->tm_mon,OurT->tm_year,OurT->tm_hour,OurT->tm_min,txt);
  508.             vacunas=fopen("nombre","wt");
  509.             fprintf(vacunas,"%s%s%s%s%d%d%d",vacuna.vacuna,vacuna.plansatinario,vacuna.planaplicacion,vacuna.observaciones,vacuna.fechavenc.dd,vacuna.fechavenc.mm,vacuna.fechavenc.aa);
  510.             return;
  511.         }
  512.         else{
  513.             cabeza=cabeza->sig;
  514.             if(cabeza==NULL){
  515.                 printf("El Id ingresado no es validon");
  516.  
  517.             }
  518.  
  519.         }
  520.     }
  521.    
  522. }
  523. /*completa*/
  524.  
  525. void hiscomp(pNodo cabeza){
  526.  
  527. }
  528.  
  529. void guardararchivo(pNodo *cabeza){
  530.     FILE *animales;
  531.     pNodo auxiliar;
  532.     char aux[100];
  533.     char aux2[100];
  534.     auxiliar=*cabeza;
  535.     strcpy(aux,ruta);
  536.     strcpy(aux2,"veterinaria.dat");
  537.     strcat(aux,aux2);
  538.     printf("%s",aux2);
  539.     animales=fopen("aux","wb");
  540.     while(auxiliar!=NULL){
  541.         fwrite(&auxiliar,sizeof(nodo),1,animales);
  542.         auxiliar=auxiliar->sig;
  543.     }
  544. }
  545. /*completa*/
  546.  
Título: Re: Como guardo en archivo de texto
Publicado por: ProfesorX en Sábado 28 de Noviembre de 2009, 23:53
Hola nicksynm, por lo poco que pude leer de la descripcion de tu problema, me parece que estas enfocando mal la manera en que lo debes de resolver, asi que te dare algunos consejos de lo que deberias hacer, a menos claro, que especificamente te dijeron que lo tienes que hacer como lo estas haciendo.

Para empezar, te dire que no es posible abrir varios archivos con un mismo fopen(), no sirve de nada usar comodines (* o ?), los comodines solo sirven PARA LISTAR LOS ARCHIVOS QUE CONTIENE UN DIRECTORIO, MAS NO PARA ABRIRLOS. Por lo tanto la sentencia que pones archivo=fopen("idc*","rt") no es valida. Cada archivo que abres necesita un apuntador de archivo (FILE*), o sea que para abrir 10 archivos simultaneamente, necesitarias 10 apuntadores de archivo. Pero ademas tienes un detalle, supon que tienes 50 mascotas, y que cada mascota tiene 20 consultas, eso haria un total de 100 archivos que tienes que abrir. algo muy dificl de manejar. Ademas en tu disco tendrias 100 archivos, cada archivo con solo una linea de texto, lo que no es nada practico.

En lugar de eso, yo diria que manejaras solo 4 archivos:

Archivo 1. Todos los datos de todos los perros. (id, nombre, raza, dueño, etc)
Archivo 2. Consultas de todos los perros (id, datos de la consulta)
Archivo 3. Vacunaciones de todos los perros (id, datos de las vacunaciones)
Archivo 4. Alergias de todos los perros (id, datos de las alergias)

Si te fijas, en el primer archivo irian todos los datos de cada uno de los perros, incluyendo un campo id, que seria unico para cada perro, para saber cuando nos referimos a un perro, y cuando nos referimos a otro diferente.

En los archivos siguientes, ya no repetiriamos los datos, solamente pondriamos el id, que es el que identifica al perro, asi sabemos que "X" datos pertenecen a "X" perro, por el id o clave unica.

Entonces, cuando queremos saber que consultas ha tenido el perro "X", simplemente pedimos su id, y entonces leemos todo el archivo, pero solamente mostramos en pantalla aquellas consultas cuya id del perro sea igual a la id del perro que queremos.

Espero que con estso consejos puedas resolver mejor tu porblema.

Saludos :)
Título: Re: Como guardo en archivo de texto
Publicado por: nicksynm en Domingo 29 de Noviembre de 2009, 00:45
Yo por mi, lo haria como vos decis, lo cual seria mucho muchisimo más facil. Pero me dijieron que  cada animal deberia tener una archivo por cada consulta, cada vacuna y cada alergia. Por eso, sino ya tendria  resuelto todo.  

Lo peor es cuando creo los archivos los nombres son generados con fecha y hora, por lo tanto aunque quisiera no se los nombras de los archivos. Asi que supongo que tiene que haber una manera con sprintf, o algo parecido, pero no se me ocurre nada.
Título: Re: Como guardo en archivo de texto
Publicado por: nicksynm en Domingo 29 de Noviembre de 2009, 01:17
Creo que se me ocurrio una manera. Como veras yo uso el sprintf para asignarle el nombre a los archivos de consulta vacunas alergias. No podria yo agregarle el comodin a la cadena que creo con el sprintf y despues usar el fopen con esa cadena?.
Título: Re: Como guardo en archivo de texto
Publicado por: ProfesorX en Domingo 29 de Noviembre de 2009, 03:18
Citar
No podria yo agregarle el comodin a la cadena que creo con el sprintf y despues usar el fopen con esa cadena?.

Ya te dije que no se puede, no importa como lo hagas, fopen() no admite comodines, solo permite abrir un archivo a la vez por cada apuntador.

En ese caso, lo que podrias hacer, es leer el directorio en base a comodines, (eso si se puede hacer, ya que solo lees los nombres de archivo, no estas abriendo los archivos en si) y entonces por cada nombre de archivo que encuentres que coincida con tu busqueda, lo abres, lees la informacion, lo cierras y lees el siguiente archivo que coincida.

El problema es que la manera de leer los nombres de archivo que contiene un directorio, es dependendiente de la plataforma, es decir, del sistema operativo que estas utilizando.

Desconozco que plataforma y compilador utilizas, pero, suponiendo que usas Visual C++ y windows  :P, te muestro un codigo que lee un directorio determinado, utiliza las funciones FindFirstFile, FindNextFile, y FindClose de aqui podrias tomar la base para obtener los nombres de archivo. Esta tomado de la siguiente direccion:
http://msdn.microsoft.com/en-us/library/aa365200%28VS.85%29.aspx

Código: C
  1. #include <windows.h>
  2. #include <tchar.h>
  3. #include <stdio.h>
  4. #include <strsafe.h>
  5.  
  6. void DisplayErrorBox(LPTSTR lpszFunction);
  7.  
  8. int _tmain(int argc, TCHAR *argv[])
  9. {
  10.    WIN32_FIND_DATA ffd;
  11.    LARGE_INTEGER filesize;
  12.    TCHAR szDir[MAX_PATH];
  13.    size_t length_of_arg;
  14.    HANDLE hFind = INVALID_HANDLE_VALUE;
  15.    DWORD dwError=0;
  16.    
  17.    // If the directory is not specified as a command-line argument,
  18.    // print usage.
  19.  
  20.    if(argc != 2)
  21.    {
  22.       _tprintf(TEXT("nUsage: %s <directory name>n"), argv[0]);
  23.       return (-1);
  24.    }
  25.  
  26.    // Check that the input path plus 3 is not longer than MAX_PATH.
  27.    // Three characters are for the "*" plus NULL appended below.
  28.  
  29.    StringCchLength(argv[1], MAX_PATH, &length_of_arg);
  30.  
  31.    if (length_of_arg > (MAX_PATH - 3))
  32.    {
  33.       _tprintf(TEXT("nDirectory path is too long.n"));
  34.       return (-1);
  35.    }
  36.  
  37.    _tprintf(TEXT("nTarget directory is %snn"), argv[1]);
  38.  
  39.    // Prepare string for use with FindFile functions.  First, copy the
  40.    // string to a buffer, then append '*' to the directory name.
  41.  
  42.    StringCchCopy(szDir, MAX_PATH, argv[1]);
  43.    StringCchCat(szDir, MAX_PATH, TEXT("\*"));
  44.  
  45.    // Esta seria una de las partes clave, encuentra el primer archivo
  46.    // que coincida con el nombre y comodin especificado (szDir).
  47.    // Find the first file in the directory.
  48.  
  49.    hFind = FindFirstFile(szDir, &ffd);
  50.  
  51.    if (INVALID_HANDLE_VALUE == hFind)
  52.    {
  53.       DisplayErrorBox(TEXT("FindFirstFile"));
  54.       return dwError;
  55.    }
  56.    
  57.    // Esta es la otra parte clave, el ciclo que impirme el nombre del archivo
  58.    // y sigue buscando el nombre del siguiente archivo que coincida con el
  59.    // comodin por medio de FindNextFile
  60.    // List all the files in the directory with some info about them.
  61.  
  62.    do
  63.    {
  64.       if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
  65.       {
  66.          _tprintf(TEXT("  %s   <DIR>n"), ffd.cFileName);
  67.       }
  68.       else
  69.       {
  70.          filesize.LowPart = ffd.nFileSizeLow;
  71.          filesize.HighPart = ffd.nFileSizeHigh;
  72.          _tprintf(TEXT("  %s   %ld bytesn"), ffd.cFileName, filesize.QuadPart);
  73.       }
  74.    }
  75.    while (FindNextFile(hFind, &ffd) != 0);
  76.  
  77.    dwError = GetLastError();
  78.    if (dwError != ERROR_NO_MORE_FILES)
  79.    {
  80.       DisplayErrorBox(TEXT("FindFirstFile"));
  81.    }
  82.  
  83.    FindClose(hFind);
  84.    return dwError;
  85. }
  86.  
  87.  
  88. void DisplayErrorBox(LPTSTR lpszFunction)
  89. {
  90.     // Retrieve the system error message for the last-error code
  91.  
  92.     LPVOID lpMsgBuf;
  93.     LPVOID lpDisplayBuf;
  94.     DWORD dw = GetLastError();
  95.  
  96.     FormatMessage(
  97.         FORMAT_MESSAGE_ALLOCATE_BUFFER |
  98.         FORMAT_MESSAGE_FROM_SYSTEM |
  99.         FORMAT_MESSAGE_IGNORE_INSERTS,
  100.         NULL,
  101.         dw,
  102.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  103.         (LPTSTR) &lpMsgBuf,
  104.         0, NULL );
  105.  
  106.     // Display the error message and clean up
  107.  
  108.     lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT,
  109.         (lstrlen((LPCTSTR)lpMsgBuf)+lstrlen((LPCTSTR)lpszFunction)+40)*sizeof(TCHAR));
  110.     StringCchPrintf((LPTSTR)lpDisplayBuf,
  111.         LocalSize(lpDisplayBuf) / sizeof(TCHAR),
  112.         TEXT("%s failed with error %d: %s"),
  113.         lpszFunction, dw, lpMsgBuf);
  114.     MessageBox(NULL, (LPCTSTR)lpDisplayBuf, TEXT("Error"), MB_OK);
  115.  
  116.     LocalFree(lpMsgBuf);
  117.     LocalFree(lpDisplayBuf);
  118. }
  119.  
  120.  

Si te fijas, el nombre de archivo esta contenido en ffd.cFileName, entonces con eso simplemente harias un fopen(ffd.cFileName) para abrir el archivo. Si te fijas, hay un ciclo que utiliza FindFirstFile y FindNextFile para leer todos los nombres de archivo que coincidan con el comodin especificado. Entonces la apertura/lectura/cerrado de cada archivo tendrias que hacerla en un ciclo :P

Busca mas informacion en MSDN sobre FindFirstFile, FindNextFile, y FindClose si utilizas windows.

Ahora, si utilizas otro sistema operativo y otro compilador, tendiras que buscar la informacion por tu cuenta, ya que yo solo trabajo bajo windows :P.

Saludos :)
Título: Re: Como guardo en archivo de texto
Publicado por: nicksynm en Domingo 29 de Noviembre de 2009, 17:27
Gracias, encontré esta pagina http://www.adrianxw.dk/SoftwareSite/Fin ... file1.html (http://www.adrianxw.dk/SoftwareSite/FindFirstFile/findfirstfile1.html" onclick="window.open(this.href);return false;) sobre el tema que me resulto muy util. Pero me salto un pequeño problema.

Cuando a FindFirstFile le pongo la ruta osea el nombre generico, yo no se el id del animal, por eso uso un sprintf para generar el nombre generico del archivo y que quede algo asi xxxxxc*.txt, el problema que esta funcion no usa un char sino lpcwstr, y no se como convertir de eso a char. Estuve buscando por google y encontre en otros legunajes o en formas muy molestas que no entiendo realmente.

Salud
Título: Re: Como guardo en archivo de texto
Publicado por: ProfesorX en Lunes 30 de Noviembre de 2009, 01:47
Tengo una solucion "Facil", pero eso depende de si estas utilizando  Visual Studio o no.

Solo ve a Propiedades de Proyecto/General/Juego de caracteres, y descativa el juego de caracteres Unicode, ponlo en "Sin establecer".

De esa formas podra utilizar un char* en lugar de un LPCSTR como parametro de FindFirstFile().

Saludos.
Título: Re: Como guardo en archivo de texto
Publicado por: nicksynm en Lunes 30 de Noviembre de 2009, 02:03
Gracias otra vez, estuve toda la tarde buscando la solucion y en http://social.msdn.microsoft.com/Forums ... 6775346040 (http://social.msdn.microsoft.com/Forums/en-US/vcgeneral/thread/507b7f95-1aa7-428d-bb30-b36775346040" onclick="window.open(this.href);return false;). Me dieron varias opciones, una por el ejemplo es que ponga L"cad" en donde cad seria la cadena, estaba entre eso y hacer lo que me acabas de decir.

Con esto ya pude terminar el programa. Te agradezco el tiempo  que te tomaste para ayudarme, sino no iba a terminar nunca más.

Salud2!




Pd: Pego todos los links no por el hecho de hacer spam, sino por si alguien le resulta útil mi código o lo que encontré. Ahora cuando termine de tipear voy a agregar el código completo.

Lo pegue en 2 partes, por que no me los queria tomar. Salud


T
Código: C
  1. rabajo practico obligatorio: Sistema centralizado de historia clínica de animales */
  2.    
  3.  
  4.  
  5.  
  6. /* ***************  A R C H I V O S  D E  C A B E C E R A  ************* */
  7. #include <stdio.h>
  8. #include <conio.h>
  9. #include <string.h>
  10. #include <stdlib.h>
  11. #include <time.h>
  12. #include <windows.h>
  13.  
  14.  
  15.  
  16.  
  17. /* *******  D E C L A R A C I O N E S  ******* */
  18. #pragma warning (disable:4996)
  19. #pragma warning (disable:4101)
  20. #define ruta " "
  21. #define LARCHFOTO  60  /* Path/nombre archivo foto */
  22. #define LESP      50             /* Especie */
  23. #define LRAZA  50      
  24. #define MIX 100
  25. #define MAX 260
  26. #define CANT 100
  27.  
  28. /* *******  D E C L A R A C I O N E S  M E N U******* */
  29.  
  30. #define ALTA 1
  31. #define MODIF 2
  32. #define CONSULTA 3
  33. #define VACUNAS 4
  34. #define ALERGIAS 5
  35. #define HISTORIAL 6
  36. #define FOTO 7
  37. #define SALIR 8
  38. #define ESPECIE 9
  39. #define RAZA 10
  40. #define FECH 11
  41. #define SEXO 12
  42. #define PATHFOTO 13
  43. #define SALIRMOD 14
  44.  
  45.  
  46.  
  47.  
  48.  
  49. /* ***  D E C L A R A C I O N E S  D E  T I P O S  D E  D A T O S  *** */
  50.  
  51.    typedef struct {
  52.        int identificador; /* 4 dígitos*/
  53.        char especie[LESP];
  54.        char raza [LRAZA];
  55.             struct {
  56.                 int aa, mm, dd;
  57.             } fechaNac;
  58.        char sexo;
  59.        char archFoto [LARCHFOTO];
  60.    } sanimal;
  61.  
  62.    typedef struct n
  63.    {
  64.        sanimal animal;
  65.        struct n *sig;
  66.    }nodo, *pNodo;
  67.  
  68.    typedef struct {
  69.        char motivo[MIX];
  70.        char diagnostico[MAX];
  71.        char tratamiento[MAX];
  72.        char veterinario[MIX];
  73.        struct{
  74.            int aa, mm, dd;
  75.        }fechacontrol;
  76.        
  77.    }sconsulta;
  78.  
  79.    typedef struct {
  80.        char vacuna[MIX];
  81.        char plansatinario[MIX];
  82.        char planaplicacion[MIX];
  83.        struct{
  84.            int aa, mm, dd;
  85.        }fechavenc;
  86.        char observaciones[MAX];
  87.        
  88.    }svacuna;
  89.  
  90.    typedef struct {
  91.        struct{
  92.            int aa, mm, dd;
  93.        }fecha;
  94.        char alergia [MIX];
  95.        char trata[MAX];    /*tratamiento*/
  96.        char observ [MAX];  /*observaciones*/
  97.        
  98.    }salergia;
  99.  
  100.   /* typedef struct {
  101.        DWORD dwFileAttributes;
  102.        FILETIME ftCreationTime;
  103.        FILETIME ftLastAccessTime;
  104.        FILETIME ftLastWriteTime;
  105.        DWORD    nFileSizeHigh;
  106.        DWORD    nFileSizeLow;
  107.        DWORD    dwReserved0;
  108.        DWORD    dwReserved1;
  109.        TCHAR    cFileName[ MAX_PATH ];
  110.        TCHAR    cAlternateFileName[ 14 ];
  111.    }WIN32_FIND_DATA;*/
  112.  
  113.  
  114.    /*la identificacion de consulta, vacunas y alergias, es la misma si hablamos del mismo animal, creo que es asi*/
  115. /* ********  D E C L A R A C I O N E S  D E  F U N C I O N E S  ******* */
  116.  
  117. int menu(void);
  118. void cargarlista(pNodo *cabeza);
  119. void alta(pNodo *cabeza);
  120. int menumod (void);
  121. void modificar(pNodo *cabeza);
  122. void infconsultas(pNodo cabeza);
  123. void infalergias(pNodo cabeza);
  124. void infvacunacion(pNodo cabeza);
  125. void hiscomp(pNodo cabeza);
  126. void fotoanimal(pNodo cabeza);
  127. void guardararchivo(pNodo *cabeza);
  128. void imprimirvacunas(pNodo cabeza);
  129. void imprimiralergias(pNodo cabeza);
  130. void imprimirconsultas(pNodo cabeza);
  131.  
  132.  
  133.  
  134.  
  135.  
  136. /* *********  M A I N  ******** */
  137. int main (){
  138.  
  139.     pNodo cabeza;
  140.     int opc=0;
  141.     int idanimal=0;
  142.     cabeza=NULL;
  143.     printf("Bienvenido al sistema de gestion de clinicas veterinariasnna");
  144.    
  145.     while((opc=menu())!=SALIR)
  146.     {
  147.  
  148.         switch(opc)
  149.         {
  150.         case ALTA:
  151.             alta(&cabeza);
  152.             break;
  153.         case MODIF:
  154.             modificar(&cabeza);
  155.             break;
  156.         case CONSULTA:
  157.             infconsultas(cabeza);
  158.             break;
  159.         case VACUNAS:
  160.             infvacunacion(cabeza);
  161.             break;
  162.         case ALERGIAS:
  163.             infalergias(cabeza);
  164.             break;
  165.         case HISTORIAL:
  166.             hiscomp(cabeza);
  167.             break;
  168.         case FOTO:
  169.             fotoanimal(cabeza);
  170.             break;
  171.         }
  172.     };
  173.     guardararchivo(&cabeza);
  174.  
  175.     return 0;
  176. }
  177.  
  178. /* *********  D E F I N I C I O N E S  D E  F U N C I O N E S  ******** */
  179.  
  180. int menu (void){
  181.     int opc, rc;
  182.     do{
  183.         printf("Ingrese la opcion deseadann");
  184.         printf("1- Alta animaln");
  185.         printf("2- Modificar Animaln");
  186.         printf("3- Agregar consultan");
  187.         printf("4- Agregar infomacion vacunasn");
  188.         printf("5- Agregar informacion alergiasn");
  189.         printf("6- Mostrar historial animaln");
  190.         printf("7- Ver foto animaln");
  191.         printf("8- SalirnnOpcion:n");
  192.         rc=scanf("%d",&opc);
  193.         printf("a");
  194.         fgetc(stdin);
  195.     }while(rc!=1 || opc<ALTA || opc>SALIR);
  196.     return opc;
  197.     scanf("%d",&opc);
  198.     return opc;
  199. }
  200. /*menu de opciones*/
  201. void cargarlista(pNodo *cabeza){
  202.     pNodo nuevo;
  203.     FILE *animales;
  204.     char aux[100];
  205.     char aux2[100];
  206.     strcpy(aux,ruta);
  207.     strcpy(aux2,"veterinaria.dat");
  208.     strcat(aux,aux2);
  209.     printf("%s",aux2);
  210.     animales=fopen("aux","rb");
  211.     if(animales==NULL)
  212.     {
  213.         printf("Se crea archivo nuevo");
  214.         animales=fopen("veterinaria.dat","wb");
  215.     return;
  216.     }
  217.     while(!feof(animales))
  218.     {
  219.         nuevo= malloc(sizeof(nodo));
  220.         fwrite(&nuevo,sizeof(nodo),1,animales);
  221.         *cabeza=nuevo;
  222.         nuevo->sig=NULL;
  223.         fwrite(&nuevo,sizeof(nodo),1,animales);
  224.     }
  225.  
  226.     fclose(animales);
  227. }
  228. /*carga del archivo binario a la lista*/
  229.        
  230. void alta(pNodo *cabeza)
  231. {
  232.     pNodo anterior;
  233.     pNodo actual;
  234.     pNodo nuevo;
  235.     pNodo indice;
  236.  
  237.     indice=*cabeza;
  238.     if(*cabeza==NULL)
  239.     {
  240.         nuevo=malloc(sizeof(nodo));
  241.         *cabeza=nuevo;
  242.         nuevo->sig=NULL;
  243.         nuevo->animal.identificador=1000;
  244.         }
  245.     else
  246.     {
  247.         nuevo=malloc(sizeof(nodo));
  248.         anterior=NULL;
  249.         actual=*cabeza;
  250.         while(actual!=NULL)
  251.         {
  252.             anterior=actual;
  253.             actual=actual->sig;
  254.         }
  255.         anterior->sig=nuevo;
  256.         nuevo->sig=NULL;
  257.     }
  258. printf("Ingrese datos del animaln");
  259. printf("Ingrese especie:");
  260. gets(nuevo->animal.especie);
  261. printf("Ingrese raza:");
  262. gets(nuevo->animal.raza);
  263. printf("Ingrese fecha de nacimiento:n");
  264. printf("Dia:");
  265. scanf("%d",&nuevo->animal.fechaNac.dd);
  266. while(nuevo->animal.fechaNac.dd > 31 || nuevo->animal.fechaNac.dd < 1){
  267.     printf("Dia:");
  268.     scanf("%d",&nuevo->animal.fechaNac.dd);
  269. }
  270. printf("Mes:");
  271. scanf("%d",&nuevo->animal.fechaNac.mm);
  272. while(nuevo->animal.fechaNac.mm > 12 || nuevo->animal.fechaNac.mm < 1){
  273.     printf("Mes:");
  274.     scanf("%d",&nuevo->animal.fechaNac.mm);
  275. }
  276. printf("Anio:");
  277. scanf("%d",&nuevo->animal.fechaNac.aa);
  278. while(nuevo->animal.fechaNac.aa > 3000 || nuevo->animal.fechaNac.aa < 1900){
  279.     printf("Anio:");
  280.     scanf("%d",&nuevo->animal.fechaNac.aa);
  281.  
  282. }
  283. fflush(stdin);  /*fflush cuando paso de entero a caracter para quitar el enter*/
  284. printf("Ingrese sexo: (M o F)");
  285. scanf("%c",&nuevo->animal.sexo); /*Nota: S cadena C caracter y lleva apersan)*/
  286. printf("Ingrese ruta de la foto: (Ej: C://animal.jpg)");
  287. scanf("%s",nuevo->animal.archFoto);
  288. if(nuevo->animal.identificador==1000){
  289. }
  290. else{
  291.     while(nuevo->animal.identificador!=1000){
  292.         indice=indice->sig;
  293.  
  294.         if(indice->sig==NULL){
  295.             nuevo->animal.identificador=indice->animal.identificador+1;
  296.  
  297.         }
  298.     }
  299. }
  300. }
  301. /*funcion alta, cargar datos a la lista*/
  302. int menumod (void){
  303.     int opc, rc;
  304.     opc=0;
  305.     do{
  306.         printf("Ingrese la opcion deseadann");
  307.         printf("9- Modificar especien");
  308.         printf("10- Modificar razan");
  309.         printf("11- Modificar fecha de nacimientosn");
  310.         printf("12- Modificar sexon");
  311.         printf("13- Modificar path de la foton");
  312.         printf("14- Salir de modificarn");
  313.         rc=scanf("%d",&opc);
  314.         printf("a");
  315.         fgetc(stdin);
  316.     }while(rc!=1 || opc<RAZA || opc>SALIRMOD);
  317.     return opc;
  318.     scanf("%d",&opc);
  319.     return opc;
  320. }
  321. /*menu de la opcion modificar*/
  322.  
  323.  
  324. void modificar(pNodo *cabeza){
  325.     pNodo aux;
  326.     int id=0, opc=0;
  327.     scanf("%d",&id);
  328.     aux=*cabeza;
  329.     printf("Ingrese el id del animal a modificarn");
  330.     scanf("%d",&id);
  331.     while(aux!=NULL){
  332.         if(aux->animal.identificador==id){
  333.             while((opc=menumod())!=SALIRMOD)
  334.             {
  335.                 switch(opc)
  336.                 {
  337.                 case ESPECIE:
  338.                     printf("Ingrese nueva especien");
  339.                     scanf("%s",aux->animal.especie);
  340.                     break;
  341.                 case RAZA:
  342.                     printf("Ingrese nueva razan");
  343.                     scanf("%s",aux->animal.raza);
  344.                     break;
  345.                 case FECH:
  346.                     printf("Ingrese nueva fecha de nacimienton");
  347.                     printf("Dia:");
  348.                     scanf("%d",&aux->animal.fechaNac.dd);
  349.                     while(aux->animal.fechaNac.dd > 31 || aux->animal.fechaNac.dd < 1){
  350.                         printf("Dia:");
  351.                         scanf("%d",&aux->animal.fechaNac.dd);
  352.                     }
  353.                     printf("Mes:");
  354.                     scanf("%d",&aux->animal.fechaNac.mm);
  355.                     while(aux->animal.fechaNac.mm > 12 || aux->animal.fechaNac.mm < 1){
  356.                         printf("Mes:");
  357.                         scanf("%d",&aux->animal.fechaNac.mm);
  358.                     }
  359.                     printf("Anio:");
  360.                     scanf("%d",&aux->animal.fechaNac.aa);
  361.                     while(aux->animal.fechaNac.aa > 3000 || aux->animal.fechaNac.aa < 1900){
  362.                         printf("Anio:");
  363.                         scanf("%d",&aux->animal.fechaNac.aa);
  364.                     }
  365.                     break;
  366.                 case SEXO:
  367.                     printf("Ingrese nuevo sexo: (M o F)");
  368.                     scanf("%c",&aux->animal.sexo);
  369.                     break;
  370.                 case PATHFOTO:
  371.                     printf("Ingrese la nueva ruta de la foto: (Ej: C://animal.jpg)");
  372.                     scanf("%s",aux->animal.archFoto);
  373.                     break;
  374.                 }
  375.            
  376.             };
  377.             return;
  378.         }
  379.         else{
  380.             aux=aux->sig;
  381.             if(aux==NULL){
  382.                 printf("El Id ingresado no es validon");
  383.  
  384.             }
  385.  
  386.         }
  387.  
  388.     }
  389. }
  390.  
  391.  
  392. /*funcion para modificar datos de la lista*/
  393.  
 
 
 
Código: C
  1. void fotoanimal (pNodo cabeza){
  2.     int id=0;
  3.     char start[MAX]={"start "};
  4.     printf("Ingrese el id del animal a mostrarn");
  5.     scanf("%d",&id);
  6.     while(cabeza!=NULL){
  7.         if(cabeza->animal.identificador==id){
  8.             system(strcat(start,cabeza->animal.archFoto));
  9.             cabeza=NULL;
  10.         }
  11.         else{
  12.             cabeza=cabeza->sig;
  13.             if(cabeza==NULL){
  14.                 printf("El Id ingresado no es validon");
  15.  
  16.             }
  17.  
  18.         }
  19.  
  20.     }
  21.  
  22. }
  23. /*muestra la foto del animal*/
  24.  
  25.  
  26. void infconsultas(pNodo cabeza){
  27.     FILE *consultas;
  28.     sconsulta consulta;
  29.     struct tm *OurT=NULL;
  30.     int id=0;
  31.     char c[MIX]={"c"};
  32.     char txt[MIX]= {".txt"};
  33.     char nombre[MAX];
  34.     printf("ingrese id animal que realizo la consulta:n");
  35.     scanf("%d",&id);
  36.  
  37.     while(cabeza!=NULL){
  38.         if(cabeza->animal.identificador==id){
  39.             printf("Ingrese datos de la consulta");
  40.            
  41.             printf("Ingrese motivo de la consulta:n");
  42.             gets(consulta.motivo);
  43.             printf("Ingrese diagnostico:n");
  44.             gets(consulta.diagnostico);
  45.             printf("Ingrese tratamiento:n");
  46.             gets(consulta.tratamiento);
  47.             printf("Ingrese veterinario que los reviso:n");
  48.             gets(consulta.veterinario);
  49.             consulta.fechacontrol.dd=OurT->tm_yday;
  50.             consulta.fechacontrol.mm=OurT->tm_mon;
  51.             consulta.fechacontrol.aa=OurT->tm_year;
  52.             sprintf(nombre,"%d%s%d%d%d%d%d%s",id,c,OurT->tm_yday,OurT->tm_mon,OurT->tm_year,OurT->tm_hour,OurT->tm_min,txt);
  53.             consultas=fopen("nombre","wt");
  54.             fprintf(consultas,"%s,%s,%s,%s,%d,%d,%dn",consulta.motivo,consulta.diagnostico,consulta.tratamiento,consulta.veterinario,consulta.fechacontrol.dd,consulta.fechacontrol.mm,consulta.fechacontrol.aa);
  55.             return;
  56.  
  57.  
  58.         }
  59.         else{
  60.             cabeza=cabeza->sig;
  61.             if(cabeza==NULL){
  62.                 printf("El Id ingresado no es validon");
  63.  
  64.             }
  65.  
  66.         }
  67.     }
  68. }
  69. /*crea archivos de consulta por animal*/
  70. void infalergias(pNodo cabeza){
  71.     FILE *alergias;
  72.     salergia alergia;
  73.     struct tm *OurT=NULL;
  74.     int id=0;
  75.     char c[MIX]={"a"};
  76.     char txt[MIX]= {".txt"};
  77.     char nombre[MAX];
  78.     printf("ingrese id animal con alergias:n");
  79.     scanf("%d",&id);
  80.  
  81.     while(cabeza!=NULL){
  82.         if(cabeza->animal.identificador==id){
  83.             printf("Ingrese datos de la alergia");
  84.            
  85.             printf("Ingrese nombre de la alergia:n");
  86.             gets(alergia.alergia);
  87.             printf("Ingrese tratamiento:n");
  88.             gets(alergia.trata);
  89.             printf("Ingrese observaciones:n");
  90.             gets(alergia.observ);
  91.             alergia.fecha.dd=OurT->tm_yday;
  92.             alergia.fecha.mm=OurT->tm_mon;
  93.             alergia.fecha.aa=OurT->tm_year;
  94.             sprintf(nombre,"%d%s%d%d%d%d%d%s",id,c,OurT->tm_yday,OurT->tm_mon,OurT->tm_year,OurT->tm_hour,OurT->tm_min,txt);
  95.             alergias=fopen("nombre","wt");
  96.             fprintf(alergias,"%s,%s,%s,%d,%d,%dn",alergia.alergia,alergia.trata,alergia.observ,alergia.fecha.dd,alergia.fecha.mm,alergia.fecha.aa);
  97.             return;
  98.         }
  99.         else{
  100.             cabeza=cabeza->sig;
  101.             if(cabeza==NULL){
  102.                 printf("El Id ingresado no es validon");
  103.  
  104.             }
  105.  
  106.         }
  107.     }
  108. }
  109. /*crea archivos de alergias por animal*/
  110. void infvacunacion(pNodo cabeza){
  111.     FILE *vacunas;
  112.     svacuna vacuna;
  113.     struct tm *OurT=NULL;
  114.     int id=0;
  115.     char c[MIX]={"v"};
  116.     char txt[MIX]= {".txt"};
  117.     char nombre[MAX];
  118.     printf("ingrese id animal que recibio vacunas:n");
  119.     scanf("%d",&id);
  120.  
  121.     while(cabeza!=NULL){
  122.         if(cabeza->animal.identificador==id){
  123.             printf("Ingrese datos de la vacuna");
  124.            
  125.             printf("Ingrese nombre de la vacuna:n");
  126.             gets(vacuna.vacuna);
  127.             printf("Ingrese plan sanitario:n");
  128.             gets(vacuna.plansatinario);
  129.             printf("Ingrese plan de aplicacion:n");
  130.             gets(vacuna.planaplicacion);
  131.             printf("Ingrese observacions:n");
  132.             gets(vacuna.observaciones);
  133.             vacuna.fechavenc.dd=OurT->tm_yday;
  134.             vacuna.fechavenc.mm=OurT->tm_mon;
  135.             vacuna.fechavenc.aa=OurT->tm_year;
  136.             sprintf(nombre,"%d%s%d%d%d%d%d%s",id,c,OurT->tm_yday,OurT->tm_mon,OurT->tm_year,OurT->tm_hour,OurT->tm_min,txt);
  137.             vacunas=fopen("nombre","wt");
  138.             fprintf(vacunas,"%s,%s,%s,%s,%d,%d,%dn",vacuna.vacuna,vacuna.plansatinario,vacuna.planaplicacion,vacuna.observaciones,vacuna.fechavenc.dd,vacuna.fechavenc.mm,vacuna.fechavenc.aa);
  139.             return;
  140.         }
  141.         else{
  142.             cabeza=cabeza->sig;
  143.             if(cabeza==NULL){
  144.                 printf("El Id ingresado no es validon");
  145.  
  146.             }
  147.  
  148.         }
  149.     }
  150.    
  151. }
  152. /*crea archivos de vacunacion por animal*/
  153.  
  154. void hiscomp(pNodo cabeza){
  155.  
  156. imprimirvacunas(cabeza);
  157. imprimiralergias(cabeza);
  158. imprimirconsultas(cabeza);
  159.  
  160.  
  161. }
  162. /*imprime el historial completo de un animal*/
  163.  
  164. void guardararchivo(pNodo *cabeza){
  165.     FILE *animales;
  166.     pNodo auxiliar;
  167.     char aux[100];
  168.     char aux2[100];
  169.     auxiliar=*cabeza;
  170.     strcpy(aux,ruta);
  171.     strcpy(aux2,"veterinaria.dat");
  172.     strcat(aux,aux2);
  173.     printf("%s",aux2);
  174.     animales=fopen("aux","wb");
  175.     while(auxiliar!=NULL){
  176.         fwrite(&auxiliar,sizeof(nodo),1,animales);
  177.         auxiliar=auxiliar->sig;
  178.     }
  179. }
  180. /*guarda la lista en un archivo binario*/
  181.  
  182. void imprimirvacunas(pNodo cabeza){
  183.     FILE *vacunas;
  184.     HANDLE hFind;
  185.     WIN32_FIND_DATA FindData;
  186.     svacuna vacuna;
  187.     int ErrorCode;
  188.     int id;
  189.     char generico[MAX];
  190.     char asterisco[MAX]={"v*.txt"};
  191.     char nombre [MAX];
  192.  
  193.     printf("Ingrese id del animaln");
  194.     scanf("%d",&id);
  195.     sprintf(generico,"%d%s",id,asterisco);
  196.    
  197.     while(cabeza!=NULL){
  198.         if(cabeza->animal.identificador==id){
  199.             hFind = FindFirstFile(L"generico", &FindData);
  200.             if(hFind == INVALID_HANDLE_VALUE)
  201.             {
  202.                 ErrorCode = GetLastError();
  203.                 if (ErrorCode == ERROR_FILE_NOT_FOUND)
  204.                 {
  205.                     printf ("No existen vacunasn") ;      
  206.                 }
  207.             }
  208.             else
  209.             {
  210.                 vacunas=fopen("FindData.cFileName","rt");
  211.                 while(!feof(vacunas)){
  212.                     fscanf(vacunas,"%s,%s,%s,%s,%d,%d,%dn",vacuna.vacuna,vacuna.plansatinario,vacuna.planaplicacion,vacuna.observaciones,vacuna.fechavenc.dd,vacuna.fechavenc.mm,vacuna.fechavenc.aa);
  213.                     printf( "%sn,%sn,%sn,%sn,%dn,%dn,%dn", vacuna.vacuna,vacuna.plansatinario,vacuna.planaplicacion,vacuna.observaciones,vacuna.fechavenc.dd,vacuna.fechavenc.mm,vacuna.fechavenc.aa);
  214.  
  215.            
  216.  
  217.                 }
  218.  
  219.                         fclose(vacunas);
  220.  
  221.                 while (FindNextFile(hFind, &FindData)){
  222.                     if(hFind == INVALID_HANDLE_VALUE)
  223.                     {
  224.                         ErrorCode = GetLastError();
  225.                         if (ErrorCode == ERROR_FILE_NOT_FOUND)
  226.                         {
  227.                             printf ("No se encontraron más archivos de vacunasn");        
  228.                         }
  229.                         else{
  230.                             /*Printf("Se encontro un error FindFirstFile() returned error code:%d",ErrorCode);
  231.                         */}
  232.                     }
  233.                     else
  234.                     {
  235.                         vacunas=fopen("FindData.cFileName","rt");
  236.                         while(!feof(vacunas)){
  237.                             fscanf(vacunas,"%s,%s,%s,%s,%d,%d,%dn",vacuna.vacuna,vacuna.plansatinario,vacuna.planaplicacion,vacuna.observaciones,vacuna.fechavenc.dd,vacuna.fechavenc.mm,vacuna.fechavenc.aa);
  238.                             printf( "%sn,%sn,%sn,%sn,%dn,%dn,%dn", vacuna.vacuna,vacuna.plansatinario,vacuna.planaplicacion,vacuna.observaciones,vacuna.fechavenc.dd,vacuna.fechavenc.mm,vacuna.fechavenc.aa);
  239.  
  240.  
  241.                         }
  242.  
  243.                         fclose(vacunas);
  244.                     }
  245.                 }
  246.             }
  247.             FindClose(hFind);
  248.         }
  249.         else{
  250.             cabeza=cabeza->sig;
  251.             if(cabeza==NULL){
  252.                 printf("El Id ingresado no es validon");
  253.             }
  254.  
  255.         }
  256.     }
  257.  
  258. }
  259. /*imprimir todos los archivos de vacunas por animal*/  
  260. void imprimiralergias(pNodo cabeza){
  261.     FILE *alergias;
  262.     HANDLE hFind;
  263.     WIN32_FIND_DATA FindData;
  264.     salergia alergia;
  265.     int ErrorCode;
  266.     int id;
  267.     char generico[MAX];
  268.     char asterisco[MAX]={"a*.txt"};
  269.     char nombre [MAX];
  270.  
  271.     printf("Ingrese id del animaln");
  272.     scanf("%d",&id);
  273.     sprintf(generico,"%d%s",id,asterisco);
  274.    
  275.     while(cabeza!=NULL){
  276.         if(cabeza->animal.identificador==id){
  277.             hFind = FindFirstFile(L"generico", &FindData);
  278.             if(hFind == INVALID_HANDLE_VALUE)
  279.             {
  280.                 ErrorCode = GetLastError();
  281.                 if (ErrorCode == ERROR_FILE_NOT_FOUND)
  282.                 {
  283.                     printf ("No existen alergiasn") ;      
  284.                 }
  285.             }
  286.             else
  287.             {
  288.                 alergias=fopen("FindData.cFileName","rt");
  289.                 while(!feof(alergias)){
  290.                     fscanf(alergias,"%s,%s,%s,%d,%d,%dn",alergia.alergia,alergia.trata,alergia.observ,alergia.fecha.dd,alergia.fecha.mm,alergia.fecha.aa);
  291.                     printf( "%sn,%sn,%sn,%dn,%dn,%dn",alergia.alergia,alergia.trata,alergia.observ,alergia.fecha.dd,alergia.fecha.mm,alergia.fecha.aa);
  292.  
  293.            
  294.  
  295.                 }
  296.  
  297.                         fclose(alergias);
  298.  
  299.                 while (FindNextFile(hFind, &FindData)){
  300.                     if(hFind == INVALID_HANDLE_VALUE)
  301.                     {
  302.                         ErrorCode = GetLastError();
  303.                         if (ErrorCode == ERROR_FILE_NOT_FOUND)
  304.                         {
  305.                             printf ("No se encontraron más archivos de alergiasn");        
  306.                         }
  307.                         else{
  308.                             /*Printf("Se encontro un error FindFirstFile() returned error code:%d",ErrorCode);
  309.                         */}
  310.                     }
  311.                     else
  312.                     {
  313.                         alergias=fopen("FindData.cFileName","rt");
  314.                         while(!feof(alergias)){
  315.                             fscanf(alergias,"%s,%s,%s,%d,%d,%dn",alergia.alergia,alergia.trata,alergia.observ,alergia.fecha.dd,alergia.fecha.mm,alergia.fecha.aa);
  316.                             printf( "%sn,%sn,%sn,%dn,%dn,%dn",alergia.alergia,alergia.trata,alergia.observ,alergia.fecha.dd,alergia.fecha.mm,alergia.fecha.aa);
  317.  
  318.                         }
  319.  
  320.                         fclose(alergias);
  321.                     }
  322.                 }
  323.             }
  324.             FindClose(hFind);
  325.         }
  326.         else{
  327.             cabeza=cabeza->sig;
  328.             if(cabeza==NULL){
  329.                 printf("El Id ingresado no es validon");
  330.             }
  331.  
  332.         }
  333.     }
  334. }
  335. /*imprimir todos los archivos de alergias por animal*/
  336. void imprimirconsultas(pNodo cabeza){
  337.     FILE *consultas;
  338.     HANDLE hFind;
  339.     WIN32_FIND_DATA FindData;
  340.     sconsulta consulta;
  341.     int ErrorCode;
  342.     int id;
  343.     char generico[MAX];
  344.     char asterisco[MAX]={"c*.txt"};
  345.     char nombre [MAX];
  346.  
  347.     printf("Ingrese id del animaln");
  348.     scanf("%d",&id);
  349.     sprintf(generico,"%d%s",id,asterisco);
  350.    
  351.     while(cabeza!=NULL){
  352.         if(cabeza->animal.identificador==id){
  353.             hFind = FindFirstFile(L"generico", &FindData);
  354.             if(hFind == INVALID_HANDLE_VALUE)
  355.             {
  356.                 ErrorCode = GetLastError();
  357.                 if (ErrorCode == ERROR_FILE_NOT_FOUND)
  358.                 {
  359.                     printf ("No existen consultasn") ;      
  360.                 }
  361.             }
  362.             else
  363.             {
  364.                 consultas=fopen("FindData.cFileName","rt");
  365.                 while(!feof(consultas)){
  366.  
  367.                     fscanf(consultas,"%s,%s,%s,%s,%d,%d,%dn",consulta.motivo,consulta.diagnostico,consulta.tratamiento,consulta.veterinario,consulta.fechacontrol.dd,consulta.fechacontrol.mm,consulta.fechacontrol.aa);
  368.                     printf("%sn,%sn,%sn,%sn,%dn,%dn,%dn",consulta.motivo,consulta.diagnostico,consulta.tratamiento,consulta.veterinario,consulta.fechacontrol.dd,consulta.fechacontrol.mm,consulta.fechacontrol.aa);
  369.  
  370.            
  371.  
  372.                 }
  373.  
  374.                         fclose(consultas);
  375.  
  376.                 while (FindNextFile(hFind, &FindData)){
  377.                     if(hFind == INVALID_HANDLE_VALUE)
  378.                     {
  379.                         ErrorCode = GetLastError();
  380.                         if (ErrorCode == ERROR_FILE_NOT_FOUND)
  381.                         {
  382.                             printf ("No se encontraron más archivos de consultasn");        
  383.                         }
  384.                         else{
  385.                             /*Printf("Se encontro un error FindFirstFile() returned error code:%d",ErrorCode);
  386.                         */}
  387.                     }
  388.                     else
  389.                     {
  390.                         consultas=fopen("FindData.cFileName","rt");
  391.                         while(!feof(consultas)){
  392.                            
  393.                             fscanf(consultas,"%s,%s,%s,%s,%d,%d,%dn",consulta.motivo,consulta.diagnostico,consulta.tratamiento,consulta.veterinario,consulta.fechacontrol.dd,consulta.fechacontrol.mm,consulta.fechacontrol.aa);
  394.                             printf("%sn,%sn,%sn,%sn,%dn,%dn,%dn",consulta.motivo,consulta.diagnostico,consulta.tratamiento,consulta.veterinario,consulta.fechacontrol.dd,consulta.fechacontrol.mm,consulta.fechacontrol.aa);
  395.  
  396.  
  397.                         }
  398.  
  399.                         fclose(consultas);
  400.                     }
  401.                 }
  402.             }
  403.             FindClose(hFind);
  404.         }
  405.         else{
  406.             cabeza=cabeza->sig;
  407.             if(cabeza==NULL){
  408.                 printf("El Id ingresado no es validon");
  409.             }
  410.  
  411.         }
  412.     }
  413. }
  414. /*imprimir todos los archivos de consultas por animal*/
  415.  
  416.  
[/code]