elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Únete al Grupo Steam elhacker.NET


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  guardar nodos en txt
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: guardar nodos en txt  (Leído 4,055 veces)
d91

Desconectado Desconectado

Mensajes: 165


Ver Perfil
guardar nodos en txt
« en: 17 Abril 2014, 19:21 pm »

hola a todos, estoy haciendo mi proyecto final con programacion orientado a objetos pero no he encontrado algun tutorial de estructura de datos con archivos, pero he intentado ingeniarmelas, usando una cola dinamica para los pacientes que llegan a una clinica, he trabajado con archivos pero con estructuras no con clases aunque al parecer la diferencia es que las estructuras no tienen metodos, constructores y destructores y como son dinamicas aumenta la dificultad, se muy bien que en este codigo estoy alternando c y c++ pero lo que es archivos se me es mas facil en c. Entonces mi  dificultad es como guardar una cola dinamica en txt y despues volver a cargarla, hice algunos procedimientos para guardar pero no se si esta bien aqui el codigo

Código
  1. #include <iostream.h>
  2. #include <conio.h>
  3. #include <stdio.h>
  4. #include<string.h>
  5.  
  6.  
  7. class nodo {
  8.   public:
  9.    nodo(int num, char name[20], nodo *sig = NULL)
  10.    {
  11.    numero=num;
  12.    strcpy(nombre,name);
  13.    siguiente=sig;
  14.    }//constructor
  15.   private:
  16.    int numero;
  17.    char nombre[20];
  18.    nodo *siguiente;
  19.  
  20.    friend class cola;
  21. };
  22.  
  23. typedef nodo *pnodo; //definimos un tipo de dato personalizaodo. Tipo puntero de la clase NODO
  24.  
  25. class cola {
  26.   public:
  27.       cola() : primero(NULL), ultimo(NULL) { }
  28.    ~cola();
  29.  
  30.    void encolar(int num, char name[]);
  31.    int desencolar();
  32.    void Mostrar();
  33.    void Guardar(int cont);
  34.  // private:
  35.   pnodo primero, ultimo;
  36. };
  37. cola paciente;
  38. cola::~cola()
  39. {
  40.   while(primero) desencolar();
  41. }
  42.  
  43. void cola::encolar(int num, char name[])
  44. {
  45.   pnodo nuevo;
  46.   nuevo = new nodo(num,name);
  47.   if(ultimo) ultimo->siguiente = nuevo;
  48.   ultimo = nuevo;
  49.   if(!primero) primero = nuevo;
  50. }
  51.  
  52. int cola::desencolar()
  53. {
  54.   pnodo nodo; /* variable auxiliar para manipular nodo */
  55.   int v;      /* variable auxiliar para retorno */
  56.  
  57.   nodo = primero;
  58.   if(!nodo) return 0; /* Si no hay nodos en la pila retornamos 0 */
  59.   primero = nodo->siguiente;
  60.   //v = nodo->valor;
  61.   delete nodo;
  62.   if(!primero) ultimo = NULL;
  63.   return 1;
  64. }            /*Procedimiento Mostrar Cola*/
  65. /*--------------------------------------------------------*/
  66. void cola::Mostrar(){                                     //
  67. pnodo aux;                                                //
  68. aux=primero;                                           //
  69.   while(aux!=NULL){                                      //
  70.      cout<<"\n\nnumero de paciente "<<aux->numero;
  71.      cout<<"\nNombre "<<aux->nombre;                              //
  72.      aux=aux->siguiente;                                 //
  73.   }                                                      //
  74. }                                                         //
  75.  
  76. /********************Guarda en txt*************************/
  77.  
  78. void cola::Guardar(int cont){
  79. FILE *ptr=fopen("C:\\SaveStruct.txt","at+"); /*en esta parte no se si lo estoy hacien bien*/
  80.   fwrite(&paciente,sizeof(paciente),1,ptr);    //intento guardar los nodos como una estructura normal
  81.   fclose(ptr);
  82.   cout<<"Operacion exitosa";
  83.   getch();
  84.  
  85. }
  86.  
  87. void IngresoDatos(){
  88.   int no;
  89.   char nombre[15];
  90. clrscr();
  91. cout<<"Ingrese no: ";cin>>no;
  92.   cout<<"Ingrese nombre: ";fgets(nombre,15,stdin);
  93.   if(nombre[strlen(nombre)-1]=='\n')
  94.  
  95.   nombre[strlen(nombre)-1]='\0';
  96.   paciente.encolar(no, nombre);
  97.   getch();
  98. }
  99.  
  100. void CargarTxt(){
  101. clrscr();
  102.   cout<<"en construccion";
  103.   getch();
  104. }
  105. int main()
  106. {
  107.   cola Cola1;
  108.   cola Cola2;
  109.  
  110.   int contador=0;
  111.   int num=0;
  112.   int no;
  113.   char nombre[15];
  114.   cola call;
  115.   do{
  116.   clrscr();
  117.      cout<<"\n1. Ingresar datos \n";
  118.      cout<<"2. Mostrar cola\n";
  119.      cout<<"3. Desencolar\n" ;
  120.      cout<<"4. Guardar en txt\n";
  121.      cout<<"5. Leer txt\n";
  122.      cout<<"6. Salir";
  123.      cout<<"\n Seleccione su opcion: ";
  124.      cin>>num;
  125.      switch(num){
  126.      case 1:
  127.      cout<<"\nIngreso de datos \n";
  128.       IngresoDatos();
  129.         contador=contador+1;
  130.      break;
  131.  
  132.      case 2:
  133.      clrscr();
  134.       cout<<"Mostrar cola\n";
  135. paciente.Mostrar();
  136.       //       barajar(Cola1,Cola2);
  137.       getch();
  138.      break;
  139.  
  140.      case 3:
  141.      cout<<"desencolando";
  142.      paciente.desencolar();
  143.      getch();
  144.      break;
  145.  
  146.      case 4:
  147.      cout<<"Guardando";
  148.      paciente.Guardar(contador);
  149.      getch();
  150.      break;
  151.  
  152.      case 5:
  153.      cout<<"cargando";
  154.      CargarTxt();
  155.      }
  156.   }while(num!=6);
  157.  
  158. }//encola y desencola correcta el problema guardar esa cola en txt y despues cargarla
  159.  


En línea

eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: guardar nodos en txt
« Respuesta #1 en: 21 Abril 2014, 10:17 am »

Nota 1.

Una lista enlazada es, por definición, dinámica... luego la dificultad es siempre la misma. No?

Nota 2.

Estás trabajando con C++, luego no termino de entender por qué el nombre lo almacenas con un array de chars en vez de usar la clase string.

Código
  1. class nodo {
  2.   public:
  3.    nodo(int num, const std::string& name, nodo *sig = NULL)


Nota 3.

No tiene sentido que pongas includes de C... los includes de C++ no llevan la extensión .h. La STL es suficientemente amplia y completa, no necesitas los includes de C para nada.

Nota 4.

Por qué motivo cola es clase friend de nodo??? Es mucho mejor que pongas los getters y setters correspondientes en nodo... pocas veces es necesario usar friend y este no es el caso ( además puede ser una fuente de problemas ).

Código
  1. class nodo {
  2.   public:
  3.    nodo(int num, const std::string& name, nodo *sig = NULL)
  4.      : numero( num ),
  5.        nombre( name ),
  6.        siguiente( sig )
  7.    {
  8.    }//constructor
  9.  
  10.    int Numero( ) const
  11.    { return numero; }
  12.  
  13.    std::string Nombre( ) const
  14.    { return nombre; }
  15.  
  16.    nodo* Siguiente( ) const
  17.    { return siguiente; }
  18.  
  19.    void SetSiguiente( nodo* sig )
  20.    { siguiente = sig; }
  21.  
  22.   private:
  23.    int numero;
  24.    std::string nombre;
  25.    nodo *siguiente;
  26. };

Nota 5.

Código
  1. typedef nodo *pnodo; //definimos un tipo de dato personalizaodo. Tipo puntero de la clase NODO

Ya que usas un typedef... por qué no lo pones al principio y lo usas también en "nodo"??

Yo personalmente no soy partidario de usar alias para ahorrarte un asterisco... bueno, no te lo ahorras, lo cambias por una "p"... pero si lo usas, al menos intenta aprovecharlo al máximo:

Código
  1.  
  2. class nodo; // declaration forward para el typedef
  3.  
  4. typedef nodo *pnodo; //definimos un tipo de dato personalizaodo. Tipo puntero de la clase NODO
  5.  
  6. class nodo {
  7.   public:
  8.    nodo(int num, const std::string& name, pnodo sig = NULL)
  9.      : numero( num ),
  10.        nombre( name ),
  11.        siguiente( sig )
  12.    {
  13.    }//constructor
  14.  
  15.    int Numero( ) const
  16.    { return numero; }
  17.  
  18.    std::string Nombre( ) const
  19.    { return nombre; }
  20.  
  21.    pnodo Siguiente( ) const
  22.    { return siguiente; }
  23.  
  24.    void SetSiguiente( pnodo sig )
  25.    { siguiente = sig; }
  26.  
  27.   private:
  28.    int numero;
  29.    std::string nombre;
  30.    pnodo siguiente;
  31. };

Nota 6.

Código
  1. cola paciente;

No solo es muy mala idea usar variables globales sino que, además, la has metido entre medias de la implementación de "cola"... mi consejo es no usar variables globales, pero si las usas, al menos que estén en sitios concretos y correctamente identificadas.

Nota 7.

Como te comenté al principio, la STL tiene una colección bastante decente y completa de utilidades que te permiten "olvidar" las viejas funciones de C.

En el caso de acceso y manipulación de ficheros, tienes las clases ostream e istream ( y sus derivadas ) que simplifican la gestión de ficheros. Además vienen con opciones especiales para poder trabajar con clases nativas de C++, como la clase string.

Nota 8.

A la hora de guardar clases en ficheros no es buena idea guardar la clase "a pelo" volcando su memoria al fichero. La razón es que en ese volcado puede viajar información RTTI ( la que se usa en dynamic_cast y que gestiona la herencia )... y no creo que quieras exportar eso porque puedes tener problemas si cambia la estructura de las clases. La forma correcta de trabajar es guardar las cosas miembro a miembro. Lo mejor es crear una clase que sepa como "serializar" cada elemento "nodo" para almacenar / recuperar un nodo a partir de un archivo.

Por supuesto, lo que no puedes hacer es volcar el contenido de la cola literalmente... la cola almacena punteros... y lo que vas a almacenar en el fichero es el valor de los punteros, no el contenido apuntado por dichos punteros...

Nota 9.

Yo soy partidario de seguir la norma "1 clase = 1 responsabilidad"... simplifica el diseño, evita dependencias absurdas y facilita la depuración y el mantenimiento.

En tu caso, "cola" tiene 2 responsabilidades. Por un lado gestiona una lista de nodos y, por otra, permite volcar dichos nodos a la salida estándar... Yo habría optado por quitar esta segunda responsabilidad de "cola" y la habría puesto o bien en una clase creada para la ocasión o bien en una función independiente.

No hay que tener miedo a tener decenas de clases sencillas... al contrario de la creencia popular entre los que van aprendiendo, tener clases sencillas facilita muchísimo el proceso de crear software... es como usar piezas de Lego...

Si caes en la tentación de juntar múltiples responsabilidades en una sola clase o función al final acabarás gestionando clases gigantescas las cuales te van a devorar al intentar hacer modificaciones o correcciones... quedas avisado.


En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
interconexión de nodos
Redes
nosoqui 4 3,676 Último mensaje 10 Mayo 2011, 13:06 pm
por T0rete
nodos
Programación C/C++
alea 1 1,470 Último mensaje 3 Marzo 2012, 10:45 am
por Xandrete
No se eliminan nodos
Programación C/C++
BJM 2 1,302 Último mensaje 22 Enero 2013, 21:19 pm
por BJM
Guardar nodos de un treeview en un documento de texto con vb 2010
Programación Visual Basic
Alvares97 3 2,942 Último mensaje 24 Abril 2013, 22:14 pm
por Alvares97
Enlazar Nodos?
Programación C/C++
BrendiisFox 8 2,844 Último mensaje 13 Septiembre 2015, 12:55 pm
por ivancea96
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines