Guardar Información de una lista ligada en un archivo .txt

[EdsonGuizar]

Buenas... Soy nuevo en esto, espero poder explicar bien mi duda:

Estoy creando un programa de nómina básico, donde el usuario ingresa datos del empleado, como nombre, ID, departamento, etc... Estoy usando como estructura de datos una lista ligada simple. No tengo problemas con agregar nodos, ni eliminar alguno. Todo corre bien (o eso creo). Lo que pasa es que no sé como guardar todos los datos de los empleados en un archivo .txt, para que cuando vuelva a ejecutar el programa aparezcan de nuevo... El primer código es la implementación de la clase Lista, Nodo, y Empleado. El segundo código es la implementación de la clase Nomina, donde tengo unas funciones para cargar y guardar el archivo, pero a lo más, me guarda la información del primer empleado que añadí, pero si cierro el programa y lo ejecuto de nuevo, no aparece ningún dato. En verdad agradecería su ayuda.

Código [Seleccionar] Expandir

//
//  Empleado.h
//  ELE
//
//  Created by Edson Guízar on 21/04/16.
//  Copyright (c) 2016 Edson Jardiel Guízar Cruz. All rights reserved.
//

#include<iostream>
#define N1 1750
#define N2 1100
#define N3 750
#define N4 390
#define N5 240


using namespace std;

/* Prototipo de la plantilla de la clase Lista. AsÌ, en la clase NodoLista
se podr· hacer referencia a ella. */

template <class T>
class Lista;

template <class T>
class NodoLista
{
private:
   NodoLista<T> *Liga;
   T Info;
public:
   NodoLista();
   T RegresaInfo();
   NodoLista<T>*RegresaLiga();
   void setInfo(T info);
   friend class Lista<T>;
   friend class NominaC;
};

/* DeclaraciÛn del mÈtodo constructor por defecto. Inicializa con el valor NULL
al apuntador al siguiente nodo. */
template <class T>
NodoLista<T>::NodoLista()
{
   Liga=NULL;
}

/* MÈtodo que permite, a usuarios ajenos a la clase, conocer el valor del
atributo Info. */
template <class T>
T NodoLista<T>::RegresaInfo()
{
   return Info;
}

template <class T>
NodoLista<T>* NodoLista<T>::RegresaLiga(){
   
   return Liga;
}

template <class T>
void NodoLista<T>::setInfo(T info){
   Info=info;
}

/* DefiniciÛn de la clase Lista */
template <class T>
class Lista
{
private:
   NodoLista<T> *Primero;
public:
   Lista();
   NodoLista<T> *RegresaPrimero();
   void CreaInicio();
   void CreaFinal();
   void ImprimeIterativo();
   void ImprimeRecursivo(NodoLista<T> *);
   void ImprimeUnNodo(NodoLista<T> *);
   void InsertaInicio(T);
   void InsertaFinal(T);
   void InsertaOrdenCrec(T);
   int InsertaAntes(T, T);
   int InsertaDespues(T, T);
   int EliminaPrimero();
   int EliminaUltimo();
   int EliminaUnNodo(T);
   int EliminaAnterior(T);
   int EliminaDespues(T);
   int Conta(int,NodoLista<T>*);
   NodoLista<T> *BuscaDesordenada(T);
   NodoLista<T> *BuscaOrdenada(T);
   NodoLista<T> *BuscaRecursivo(T, NodoLista<T> *);
   friend class NominaC;
};

/* DeclaraciÛn del mÈtodo constructor. Inicializa el apuntador al primer nodo
de la lista con el valor NULL: indica la lista vacÌa. */
template <class T>
Lista<T>::Lista()
{
   Primero=NULL;
}

/* MÈtodo que regresa la direcciÛn de primer nodo de la lista. */
template <class T>
NodoLista<T> *Lista<T>::RegresaPrimero()
{
   return Primero;
}

template <class T>

int Lista<T>::Conta(int d,NodoLista<T> *Apunt){
   if (Apunt!=NULL)
   {
       
       Conta(d,Apunt->Liga);
       d++;
   }
   
   return d;
}

/* MÈtodo que crea una lista agregando el nuevo nodo al inicio de la misma. */
template <class T>
void Lista<T>::CreaInicio()
{
   NodoLista<T> *P;
   T Dato;
   char Resp;
   Primero=new NodoLista<T>();
   cout << "Introduce la informacion a almacenar: \n";
   cin >> Dato;
   Primero->Info=Dato;
   cout << "\nDeseas introducir otro elemento (S/N)? ";
   cin >> Resp;
   while (Resp == 'S' || Resp =='s')
   {
       cout << "Introduce la informacion: \n";
       cin >> Dato;
       P=new NodoLista<T>();
       P->Info=Dato;
       P->Liga=Primero;
       Primero=P;
       cout << "\nDeseas agregar otro elemento (S/N)? ";
       cin >> Resp;
   }
}

/* MÈtodo que crea una lista agregando el nuevo nodo al final de la misma. */
template <class T>
void Lista<T>::CreaFinal()
{
   NodoLista<T> *P, *Ultimo;
   T Dato;
   char Resp;
   Primero=new NodoLista<T>();
   cin >> Dato;
   Primero->Info=Dato;
   /* Se mantiene el apuntador al ˙ltimo nodo agregado a la lista para evitar
    tener que recorrerla con cada nuevo nodo. */
   Ultimo=Primero;
   cout << "\nDeseas introducir otro elemento (S/N)? ";
   cin >> Resp;
   while (Resp == 'S' || Resp =='s')
   {
       cin >> Dato;
       P=new NodoLista<T>();
       P->Info=Dato;
       Ultimo->Liga=P;
       Ultimo=P;
       cout << "\nDeseas agregar otro elemento (S/N)? ";
       cin >> Resp;
   }
}

/* MÈtodo que imprime el contenido de la lista de forma iterativa. */
template <class T>
void Lista<T>::ImprimeIterativo()
{
   NodoLista<T> *P;
   P=Primero;
   while (P)
   {
       cout << '\n'<<P->Info;
       P=P->Liga;
   }
   cout << "\n";
}

/* MÈtodo que imprime el contenido de la lista de forma recursiva. Recibe como
par·metro el nodo cuya informaciÛn se va a imprimir. */
template <class T>
void Lista<T>::ImprimeRecursivo(NodoLista<T> *P)
{
   if (P)
   {
       cout << P->Info;
       ImprimeRecursivo(P->Liga);
   }
   cout << "\n";
}

/* MÈtodo que imprime la informaciÛn de un nodo dado como dato. */
template <class T>
void Lista<T>::ImprimeUnNodo(NodoLista<T> *P)
{
   if (P)
       cout << '\n'<<P->Info;
}

/* MÈtodo que inserta un nodo al inicio de la lista. El mÈtodo es v·lido tanto
para listas ya creadas como para listas vacÌas. */
template <class T>
void Lista<T>::InsertaInicio(T Dato)
{
   NodoLista<T> *P;
   P=new NodoLista<T>();
   P->Info=Dato;
   P->Liga=Primero;
   Primero=P;
}

/* MÈtodo que inserta un nodo al final de la lista. El mÈtodo es v·lido tanto
para listas ya creadas como para listas vacÌas. */
template <class T>
void Lista<T>::InsertaFinal(T Dato)
{
   NodoLista<T> *P, *Ultimo;
   P=new NodoLista<T>();
   P->Info=Dato;
   if (Primero)
   {
       /* Si la lista tiene al menos un elemento, entonces se debe recorrer
        hasta llegar al ˙ltimo nodo. */
       Ultimo=Primero;
       while (Ultimo->Liga)
           Ultimo=Ultimo->Liga;
       /* El ˙ltimo nodo de la lista apunta al nuevo nodo, cuya direcciÛn
        est· en P. */
       Ultimo->Liga=P;
   }
   else
   /* Si la lista no tiene elementos, entonces el nuevo elemento ser· el
    primero de la misma. */
       Primero=P;
}

/* MÈtodo que inserta un nodo en orden creciente. Luego de varias inserciones,
usando este mÈtodo, se habr· generado una lista ordenada de menor a mayor. */
template <class T>
void Lista<T>::InsertaOrdenCrec(T Dato)
{
   NodoLista<T> *P, *Q, *Ant;
   if (!Primero || Primero->Info > Dato)
       InsertaInicio(Dato);
   else
   {
       Q=Primero;
       while (Q && Q->Info < Dato)
       {
           Ant=Q;
           Q=Q->Liga;
       }
       P=new NodoLista<T>();
       P->Info=Dato;
       Ant->Liga=P;
       P->Liga=Q;
   }
}

/* MÈtodo que inserta un nodo antes de un nodo dado como referencia. Recibe como
par·metros la informaciÛn a insertar y un dato dado como referencia.
Regresa 1 si se pudo insertar, 0 si no se encontrÛ la referencia y -1 si la
lista est· vacÌa. */
template <class T>
int Lista<T>::InsertaAntes(T Dato, T Ref)
{
   NodoLista<T> *P, *Ant, *Q;
   int Resp=1;
   if (Primero)
   {
       Q=Primero;
       while ((Q!=NULL) && (Q->Info!=Ref))
       {
           Ant=Q;
           Q=Q->Liga;
       }
       if (Q!=NULL)
       {
           P=new NodoLista<T>();
           P->Info=Dato;
           /* El dato de referencia es el primero de la lista. */
           if (Primero==Q)
           {
               P->Liga=Primero;
               Primero=P;
           }
           else
           {
               Ant->Liga=P;
               P->Liga=Q;
           }
       }
       else
       /* No se encontrÛ el dato como referencia. */
           Resp=0;
   }
   else
   /* La lista est· vacÌa. */
       Resp=-1;
   return Resp;
}

/* MÈtodo que inserta un nodo despuÈs de uno dado como referencia. Recibe como
par·metros la informaciÛn a insertar y la refeencia. Regresa 1 si se pudo
insertar, 0 si no se encontrÛ el dato dado y -1 si la lista est· vacÌa. */
template <class T>
int Lista<T>::InsertaDespues(T Dato, T Ref)
{
   NodoLista<T> *Q, *P;
   int Resp=1;
   if (Primero)
   {
       Q=Primero;
       while((Q!=NULL) && (Q->Info!=Ref))
           Q=Q->Liga;
       if (Q!=NULL)
       {
           P=new NodoLista<T>();
           P->Info=Dato;
           P->Liga=Q->Liga;
           Q->Liga=P;
       }
       /* No se encontrÛ la referencia. */
       Resp=0;
   }
   else
   /* La lista est· vacÌa. */
       Resp=-1;
   return Resp;
}

/* MÈtodo que elimina el primer elemento de la lista. El mÈtodo redefine el
apuntador al inicio de la lista y libera el espacio de memoria del nodo
eliminado. Regresa 1 si se pudo llevar a cabo la operaciÛn y 0 en caso
contrario. */
template <class T>
int Lista<T>::EliminaPrimero()
{
   NodoLista<T> *P;
   int Resp=1;
   if (Primero)
   {
       P=Primero;
       Primero=P->Liga;
       delete (P);
   }
   else
   /* La lista est· vacÌa. */
       Resp=0;
   return Resp;
   
}

/* MÈtodo que elimina el ˙ltimo elemento de una lista. Primero lo localiza,
guardando la direcciÛn del nodo que le precede. Posteriormente redefine la
liga de Èste con el valor NULL para indicar que ahora Èste es el ˙ltimo y
libera el espacio de memoria. Regresa 1 si se efectuo la eliminaciÛn y 0
en caso contrario. */
template <class T>
int Lista<T>::EliminaUltimo()
{
   NodoLista<T> *Ant, *P;
   int Resp=1;
   if (Primero)
   {
       /* Verifica si la lista est· formada por un ˙nico elemento, en tal caso
        redefine el apuntador al inicio con el valor NULL, indicando lista
        vacÌa. */
       if (!Primero->Liga)
       {
           delete (Primero);
           Primero=NULL;
       }
       else
       {
           P=Primero;
           while (P->Liga)
           {
               Ant=P;
               P=P->Liga;
           }
           Ant->Liga=NULL;
           delete (P);
       }
   }
   else
   /* La Lista est· vacÌa. */
       Resp=0;
   return Resp;
}

/* MÈtodo que elimina un nodo que almacena cierta informaciÛn. Recibe como
par·metro el dato a eliminar y regresa como resultado 1 si lo elimina, 0
si no lo encuentra y -1 si la lista est· vacÌa. */
template <class T>
int Lista<T>::EliminaUnNodo(T Ref)
{
   NodoLista<T> *P, *Ant;
   int Resp=1;
   if (Primero)
   {
       P=Primero;
       while ((P->Liga)&&(P->Info!=Ref))
       {
           Ant=P;
           P=P->Liga;
       }
       if (P->Info!=Ref)
       /* El elemento no fue encontrado. */
           Resp=0;
       else
       {
           if (Primero==P)
               Primero=P->Liga;
           else
               Ant->Liga=P->Liga;
           delete (P);
       }
   }
   else
       Resp=-1;
   return Resp;
}

/* MÈtodo que elimina el nodo anterior al nodo que almacena un dato dado como
referencia. Regresa 1 si el nodo fue eliminado, 2 si la referencia es el
primero, 3 si no fue encontrado y 4 si la lista est· vacÌa. */
template <class T>
int Lista<T>::EliminaAnterior(T Ref)
{
   NodoLista<T> *Q, *Ant, *P;
   int Resp=1;
   if (Primero)
   {
       if (Primero->Info==Ref)
       /* No hay nodo que preceda al proporcionado como referencia. */
           Resp=2;
       else
       {
           Q=Primero;
           Ant=Primero;
           /* Ciclo que permite encontrar la informaciÛn dada como referencia,
            guardando la direcciÛn del nodo que le precede (nodo que se
            eliminar·) y del anterior a Èste para establecer las ligas
            correspondientes. */
           while ((Q->Info!=Ref)&&(Q->Liga))
           {
               P=Ant;
               Ant=Q;
               Q=Q->Liga;
           }
           if (Q->Info!=Ref)
           /* El elemento dado como referencia no est· en la lista. */
               Resp=3;
           else
               if (Primero->Liga==Q)
               {
                   delete (Primero);
                   Primero=Q;
               }
               else
               {
                   P->Liga=Q;
                   delete (Ant);
               }
       }
   }
   else
   /* La lista est· vacÌa. */
       Resp =4;
   return Resp;
}

/* MÈtodo que busca un elemento dado como referencia en una lista desordenada.
Regresa la direcciÛn del nodo si lo encuentra y NULL en caso contrario. */
template <class T>
NodoLista<T> *Lista<T>::BuscaDesordenada(T Ref)
{
   NodoLista<T> *Q, *Resp=NULL;
   if (Primero)
   {
       Q=Primero;
       while ((Q->Info!=Ref)&&(Q->Liga))
           Q=Q->Liga;
       /* Se verifica si el elemento dado como referencia fue encontrado en
        la lista. */
       if (Q->Info==Ref)
           Resp=Q;
   }
   return Resp;
}

/* MÈtodo que busca un elemento dado como referencia, en una lista ordenada
de menor a mayor. Regresa la direcciÛn del nodo si lo encuentra y NULL en
caso contrario. */
template <class T>
NodoLista<T> *Lista<T>::BuscaOrdenada(T Ref)
{
   NodoLista<T> *Q, *Resp=NULL;
   if (Primero)
   {
       Q=Primero;
       while ((Q->Info < Ref)&&(Q->Liga))
           Q=Q->Liga;
       /* Se verifica si el elemento dado como referencia fue encontrado en
        la lista. */
       if (Q->Info==Ref)
           Resp=Q;
   }
   return Resp;
}

/* MÈtodo que busca un dato en la lista. La operaciÛn se realiza recursivamente.
El mÈtodo recibe como par·metro el elemento a buscar (Dato) y una variable
(Q) que almacena la direcciÛn de un nodo (la primera vez es la direcciÛn
del primero). Regresa como resultado la direcciÛn del nodo si lo encuentra
y NULL en caso contrario. */
template <class T>
NodoLista<T> *Lista<T>::BuscaRecursivo(T Dato, NodoLista<T> *Q)
{
   if (Q)
       if (Q->Info==Dato)
           return Q;
       else
           return BuscaRecursivo(Dato, Q->Liga);
       else
           return NULL;
}


char aux[2];

class Empleado{
   
protected:
   string Nombre="";
   int ID=0;
   int Departamento=0;
   int Nivel=0;
   int Antiguedad=0;
   int TipoContrato=0;
   int DiasTrabajados=0;
   int HorasExtra=0;
   double Salario=0;
   double Bonos=0;
   double Descuentos=0;
   friend class NominaC;
   
public:
   
   Empleado(){ }
   Empleado(string N, int I, int D, int Ni, int A, int TC, double S, int DT, int HE, double B, double De){
       setNombre(N);
       setID(I);
       setDepartamento(D);
       setNivel(Ni);
       setAntiguedad(A);
       setTipoContrato(TC);
       setSalario(S);
       setDiasTrabajados(DT);
       setHorasExtra(HE);
       setBonos(B);
       setDescuentos(De);
   }
   
   string getNombre(){ return Nombre; }
   void setNombre(string Nom){ Nombre=Nom; }
   
   int getID(){ return ID; }
   void setID(int id){ ID=id; }
   
   int getDepartamento(){ return Departamento; }
   void setDepartamento(int Dep){ Departamento=Dep; }
   
   int getNivel(){ return Nivel; }
   void setNivel(int Ni){ Nivel=Ni; }
   
   int getAntiguedad(){ return Antiguedad; }
   void setAntiguedad(int An){ Antiguedad=An; }
   
   int getTipoContrato(){ return TipoContrato; }
   void setTipoContrato(int TiC){ TipoContrato=TiC; }
   
   int getHorasExtra(){ return HorasExtra; }
   void setHorasExtra(int HoE){ HorasExtra=HoE; }
   
   double getSalario(){ return Salario; }
   void setSalario(double Sa){ Salario=Sa; }
   
   int getDiasTrabajados(){ return DiasTrabajados; }
   void setDiasTrabajados(int DiT){ DiasTrabajados=DiT; }
   
   double getBonos(){ return Bonos; }
   void setBonos(double Bon){ Bonos=Bon; }
   
   double getDescuentos(){ return Descuentos; }
   void setDescuentos(double Des){ Descuentos=Des; }
   
   
   void CalculaSalario(){
       
       switch (Departamento) {
           case 1:
               switch (Nivel) {
                   case 1:
                       Salario=N1*1.2;
                       break;
                   case 2:
                       Salario=N2*1.2;
                       break;
                   case 3:
                       Salario=N3*1.2;
                       break;
                   case 4:
                       Salario=N4*1.2;
                       break;
                   case 5:
                       Salario=N5*1.2;
                       break;
                   default:
                       break;
               }
               break;
               
           default:
               break;
       }
       
   }
   
   void setSalario(double Bonos, double Descuentos, int HorasExtra, int DiasTrab){
       Salario=(((Salario/12)*DiasTrab)+(HorasExtra*30)+Bonos-Descuentos);
   }
   
   
   /* MÈtodo que permite comparar dos objetos de tipo Producto para determinar si
    son iguales. Regresa 1 si los productos son iguales (tienen la misma clave)
    y 0 en caso contrario. Se usa sobrecarga del operador ==. */
   int operator == (Empleado E)
   {
       int Resp=0;
       if (ID==E.ID)
           Resp=1;
       return Resp;
   }
   
   /* MÈtodo que permite comparar dos objetos de tipo Producto para determinar si
    son distintos. Regresa 1 si los productos son distintos (tienen diferente
    clave) y 0 en caso contrario. Se usa sobrecarga del operador !=. */
   int operator != (Empleado E)
   {
       int Resp=0;
       if (ID!=E.ID)
           Resp=1;
       return Resp;
   }
   
   
   /* MÈtodo que permite comparar dos objetos de tipo Producto para determinar si
    el asociado al operador es mayor que el dado como par·metro. Regresa 1
    cuando es mayor (su clave es mayor que la clave del dado como par·metro)
    y 0 en caso contrario. Se usa sobrecarga del operador >, */
   int operator > (Empleado E)
   {
       int Resp=0;
       if (ID > E.ID)
           Resp=1;
       return Resp;
   }
   
   /* MÈtodo que permite comparar dos objetos de tipo Producto para determinar si
    el asociado al operador es menor que el dado como par·metro. Regres 1 cuando
    es menor (su clave es menor que la clave del dado como par·metro) y 0 en
    caso contrario. Se usa sobrecarga del operador <. */
   int operator < (Empleado E)
   {
       int Resp=0;
       if (ID < E.ID)
           Resp=1;
       return Resp;
   }
   
   friend istream &operator>>(istream &, Empleado &);
   friend ostream &operator<<(ostream &, Empleado &);
   
};

ostream &operator<<(ostream &Imprime, Empleado &E) {
   
   Imprime<<E.getID()<<setw(30)<<E.getNombre()<<setw(18)<<E.getDepartamento()<<setw(6)<<E.getNivel()<<
   setw(7)<<E.getAntiguedad()<<setw(14)<<E.getTipoContrato()<<setw(10)<<E.getSalario()<<setw(12)<<E.getDiasTrabajados()<<setw(7)<<E.getHorasExtra()<<setw(7)<<E.getBonos()<<setw(7)<<E.getDescuentos();
   
   return Imprime;
}

istream &operator>>(istream &Escribe, Empleado &E){
   int datoint;
   char aux[2];
   string datostr;
   cout<<endl;
   cout<<"ID: ";
   cin>>datoint;
   E.setID(datoint);
   cin.getline(aux, 2);
   cout<<"Nombre: ";
   getline(cin, datostr);
   E.setNombre(datostr);
   cout<<"Departamento: ";
   cin>>datoint;
   E.setDepartamento(datoint);
   cout<<"Nivel: ";
   cin>>datoint;
   E.setNivel(datoint);
   cout<<"Antigüedad: ";
   cin>>datoint;
   E.setAntiguedad(datoint);
   cout<<"Tipo de contrato: ";
   cin>>datoint;
   E.setTipoContrato(datoint);
   cout<<endl;
   E.CalculaSalario();
   
   return Escribe;
}

Código [Seleccionar] Expandir

#include <iostream>
#include <string>
#include <iomanip>
#include "Empleado.h"
#include "stdlib.h"
#include <fstream>
#define N1 1750
#define N2 1100
#define N3 750
#define N4 390
#define N5 240

using namespace std;

class NominaC{
   Lista<Empleado> N;
   NodoLista<Empleado> Auxi,*Auxi2;
   int NumeroEmpleados=0;
public:
   
   void CargarArchivo(){
       int a;
       string Nombre;
       int ID;
       int Departamento;
       int Nivel;
       int Antiguedad;
       int TipoContrato;
       int DiasTrabajados;
       int HorasExtra;
       double Salario;
       double Bonos;
       double Descuentos;
       NodoLista<Empleado> *Auxiliar=N.RegresaPrimero();
       Empleado A;
       ifstream cargar;
       cargar.open("numero.txt",ios::in);
       cargar>>NumeroEmpleados;
       cargar.close();
       cargar.open("datos.txt",ios::in);
           while(Auxiliar){
           cargar>>ID>>Nombre>>Departamento>>Nivel>>Antiguedad>>TipoContrato>>DiasTrabajados>>HorasExtra>>Salario>>Bonos>>Descuentos;
               A.setID(ID);
               A.setNombre(Nombre);
               A.setDepartamento(Departamento);
               A.setNivel(Nivel);
               A.setAntiguedad(Antiguedad);
               A.setTipoContrato(TipoContrato);
               A.setDiasTrabajados(DiasTrabajados);
               A.setHorasExtra(HorasExtra);
               A.setSalario(Salario);
               A.setBonos(Bonos);
               A.setDescuentos(Descuentos);
               N.InsertaOrdenCrec(A);
               Auxiliar->setInfo(A);
               Auxiliar=Auxiliar->RegresaLiga();
               
           }
           
       
       
       cargar.close();
   }
   
   void guardarElemento(){
       NodoLista<Empleado> *Auxiliar;
       Empleado A;
       ofstream guardar;
       guardar.open("numero.txt",ios::out);
       guardar<<NumeroEmpleados;
       guardar.close();
       guardar.open("datos.txt",ios::out);
           while(Auxiliar){
               A=Auxiliar->RegresaInfo();
           guardar<<A.getID()<<"     "<<A.getNombre()<<"     "<<A.getDepartamento()<<"     "<<A.getNivel()<<"     "<<A.getAntiguedad()<<"     "
               <<A.getTipoContrato()<<"     "<<A.getDiasTrabajados()<<"     "<<A.getHorasExtra()<<"     "<<A.getSalario()<<"     "<<A.getBonos()
               <<"     "<<A.getDescuentos()<<endl;
               Auxiliar=Auxiliar->RegresaLiga();
       
       guardar.close();
   }
   }
   
   void AgregarEmpleado(){
       Empleado A;
       cin>>A;
       N.InsertaOrdenCrec(A);
       NumeroEmpleados++;
       guardarElemento();
   }
   
   void EliminarEmpleado(){
       int id,res;
       cout<<"ID del empleado: ";
       cin>>id;
       Empleado X(" ", id, 0, 0, 0, 0, 0, 0,0,0,0);
       res=N.EliminaUnNodo(X);
       switch (res)
       {
           case 1:  cout << "El empleado ha sido eliminado.\n";
               NumeroEmpleados--;
               break;
           case 0:  cout << "El ID no esta registrado.\n";
               break;
           case -1: cout << "No hay empleados registrados.\n";
               break;
       }
   }
   
   void EditarEmpleado(){
       int id,dato;
       cout<<"ID del empleado: ";
       cin>>id;
       Empleado X(" ", id, 0, 0, 0, 0, 0, 0,0,0,0),A;
       if(N.BuscaOrdenada(X)){
           Auxi=*N.BuscaOrdenada(X);
           A=Auxi.RegresaInfo();
           N.EliminaUnNodo(X);
           int cambio;
           cout<<"¿Qué dato deseas editar?\n(1) Departamento.\n(2) Nivel.\n(3) Antigüedad.\n(4) Tipo de Contrato.\nOpción: ";
           cin>>cambio;
           switch (cambio) {
               case 1:
               {
                   cout<<"Nuevo departamento: ";
                   cin>>dato;
                   A.setDepartamento(dato);
                   A.CalculaSalario();
                   N.InsertaOrdenCrec(A);
                   Auxi2=N.BuscaOrdenada(A);
                   N.ImprimeUnNodo(Auxi2);
                   break;
               }
               case 2:
               {
                   cout<<"Nuevo nivel: ";
                   cin>>dato;
                   A.setNivel(dato);
                   A.CalculaSalario();
                   N.InsertaOrdenCrec(A);
                   Auxi2=N.BuscaOrdenada(A);
                   N.ImprimeUnNodo(Auxi2);
                   break;
               }
               case 3:
               {
                   cout<<"Nueva antigüedad: ";
                   cin>>dato;
                   A.setAntiguedad(dato);
                   N.InsertaOrdenCrec(A);
                   Auxi2=N.BuscaOrdenada(A);
                   N.ImprimeUnNodo(Auxi2);
                   break;
               }
               case 4:
               {
                   cout<<"Nuevo tipo de contrato: ";
                   cin>>dato;
                   A.setTipoContrato(dato);
                   N.InsertaOrdenCrec(A);
                   Auxi2=N.BuscaOrdenada(A);
                   N.ImprimeUnNodo(Auxi2);
                   break;
               }
               default:
                   break;
           }
       }
       
   }
   
   void MostrarEmpleados(){
       cout<<"ID"<<setw(18)<<"|NOMBRE"<<setw(40)<<"|DEP."<<setw(7)<<"|NIVEL"<<setw(8)<<"|ANTIG."<<setw(10)<<
       "|CONTRATO"<<setw(14)<<"|SALARIO BASE"<<setw(10)<<"|D. TRAB."<<setw(12)<<"|HRS. EXTRA"<<setw(7)<<"|BONOS"<<setw(7)<<
       "|DESC.";
       N.ImprimeIterativo();
   }
   
   void MostrarUnEmpleado(){
       cout<<"ID del empleado: ";
       int id;
       cin>>id;
       Empleado M(" ",id,0,0,0,0,0,0,0,0,0);
       Auxi2=N.BuscaOrdenada(M);
       N.ImprimeUnNodo(Auxi2);
   }
   
   void CrearNomina(){
       NodoLista<Empleado> *Auxiliar=N.RegresaPrimero(),*Auxi2,*A3,*A4;
       Empleado A,B; int DT, HE; double Bonos, Descuentos;
       while (Auxiliar) {
           A=Auxiliar->RegresaInfo();
           Auxi2=N.BuscaOrdenada(A);
           N.ImprimeUnNodo(Auxi2);
           cout<<"Número de días trabajados: ";
           cin>>DT;
           A.setDiasTrabajados(DT);
           cout<<"Número de horas extra: ";
           cin>>HE;
           A.setHorasExtra(HE);
           cout<<"Bonos: ";
           cin>>Bonos;
           A.setBonos(Bonos);
           cout<<"Descuentos: ";
           cin>>Descuentos;
           A.setDescuentos(Descuentos);
           A.setSalario(Bonos, Descuentos, HE, DT);
           //A.CalculaSalario();
           Auxiliar->setInfo(A);
           Auxiliar=Auxiliar->RegresaLiga();
       }
       A3=N.RegresaPrimero();
       while (A3) {
           B=A3->RegresaInfo();
           A4=N.BuscaOrdenada(B);
           N.ImprimeUnNodo(A4);
           A3=A3->RegresaLiga();
       }
       
   }
   
};



void Menu(){
   
   cout<<"(1) Agregar empleado.\n(2) Eliminar empleado.\n(3) Editar información de empleado.\n(4) Mostrar empleados.\n(5) Mostrar un empleado.\n(6) Crear nómina.\n(7) Salir.\nOpción: ";
   
}


int main() {
   
   //Lista<Empleado> Nomina;
   //Empleado Aux;
   //NodoLista<Empleado> Auxi,*Auxi2;
   NominaC N;
   N.CargarArchivo();
   int Opcion;
   
   do {
       cout<<"\n\t\tSISTEMA DE GESTIÓN DE USUARIOS\n";
       Menu();
       cin>>Opcion;
       switch (Opcion) {
           case 1:
           {
               N.AgregarEmpleado();
               N.guardarElemento();
               break;
           }
           case 2:
           {
               N.EliminarEmpleado();
               N.guardarElemento();
               break;
           }
           case 3:
           {
               N.EditarEmpleado();
               N.guardarElemento();
               break;
           }
           case 4:
           {
               N.MostrarEmpleados();
               break;
           }
           case 5:
           {
               N.MostrarUnEmpleado();
               break;
           }
           case 6:
           {
               N.CrearNomina();
               N.guardarElemento();
               break;
           }
           case 7:
           {
               cout<<"Hasta pronto.\n\n";
               break;
           }
           default:
               cout<<"Opción inválida\n\n";
               break;
               
       }
   } while (Opcion!=7);
   
   N.guardarElemento();
   
   return 0;
   
}


[ivancea96]

Te pongo yo un código de 1000 líneas, y me quedo tan ancho.

Lo que debes hacer, es ir probando cada fragmento de código por separado y asegurándote de que funciona a la perfección.

[AlbertoBSD]

El problema de Guardar los datos es la eleccion del formarto lo que podria ser en Forma Binaria o en texto plano. Una vez elegido esto tambien tendremos que elegir si cada registro tiene longitud fija o longitud variable.

Tiens que elegir un formato y apegarte a el.

Nunca me a gustado la forma en la que trabaja C++ para sacar loa datos a archvos y darles entrada ( <<, >> )

Yo en lo personal prefiero guardar una estrutura fija con fwrite y leerla con fread ( Forma Binaria)

o si voy a trabajar con texto plano seria mediante una estrutura tipo CSV registros separados por lineas, campos separados por comas y cadenas entre comillas.

en tu código veo que usas dos archivos y ademas esos espacios separando los campos,  al momento de leer loa datos no veo que se haga un chequeo del archivo que pasa si un dato no fue ingresado?

Código [Seleccionar] Expandir

guardar.open("numero.txt",ios::out);
       guardar<<NumeroEmpleados;
       guardar.close();
       guardar.open("datos.txt",ios::out);
           while(Auxiliar){
               A=Auxiliar->RegresaInfo();
           guardar<<A.getID()<<"     "<<A.getNombre()<<"     "<<A.getDepartamento()<<"     "<<A.getNivel()<<"     "<<A.getAntiguedad()<<"     "
               <<A.getTipoContrato()<<"     "<<A.getDiasTrabajados()<<"     "<<A.getHorasExtra()<<"     "<<A.getSalario()<<"     "<<A.getBonos()
               <<"     "<<A.getDescuentos()<<endl;
               Auxiliar=Auxiliar->RegresaLiga();
       
       guardar.close();