Buenas, ando necesitando una mano, no se asusten por el código, tiene ideas a medio terminar, y no tengo mucha experiencia programando en c++, está solo por si no se entiende lo que estoy queriendo hacer.

Estoy haciendo un ejercicio en dónde se me da dos archivos en binario con listas de precios de dos empresas, estas se unifican, y me piden generar un nuevo archivo, se supone que utilizan los mismos números de artículos, así que debo sumar los stocks de los productos con el mismo número de artículo. Pero no todos los artículos que vende una, lo tiene la otra. Todo utilizando listas.

Mi duda es, como formo el nuevo archivo, ¿está bien lo de generar dos listas a la vez?¿No puedo igualar los dos punteros de las estructuras a NULL no? Que me recomiendan para hacerlo.

Muchas Gracias.

 



/*Resumen del ejercicio: De dos archivos que contienen listas de productos, se pide unificarlos en uno solo utilizando listas. Si tienen 

el mismo número de articulo se suman los stocks, y se considera el precio mayor para el nuevo archivo*/ 



#include<iostream>



using namespace std;



class ListaUnif

{

      struct datos1

      {

             int Nro_art;

                  char Descripcion[30];

                  float Pre_uni;

                  int Cant_exist;

                  }Reg;

       struct Nodo

       {

          struct datos1 X;

          struct Nodo *next;

       }*H;

        struct datos2

      {

             int Nro_art;

                  char Descripcion[30];

                  float Pre_uni;

                  float Pre_Caja;

                  int Cant_exist;

                  }Reg2;

       

       struct Nodo2

       {

          struct datos2 Y;

          struct Nodo2 *nextt;

       }*G;               

      

      struct Nodo3

      {

             struct datos1 Z;

             struct Nodo3 *nexxtt;

      }*T;      

      char Vacio1();

      char Vacio2();

      FILE *fp1;

      FILE *fp2;

      FILE *fp3;       

       

  public:

         ListaUnif();

         int CrearLista1();

         int CrearLista2();

         void Poner1(datos1);

         void Poner2(datos2);

         

};



//Constructor: Inicializa la pila



//-----------------------------------------------------------------------------

ListaUnif::ListaUnif()

{

   H==NULL;

   G==NULL;

}



//Verifica si la lista está vacía

//-----------------------------------------------------------------------------

char ListaUnif::Vacio1()

{

     return(H==NULL);

}



char ListaUnif::Vacio2()

{

     return(G==NULL);

}     

//-----------------------------------------------------------------------------          

void ListaUnif::Poner1(struct datos1 Dato)

{

struct Nodo *p, *i=H;

p=new(struct Nodo);

p->X=Dato;

p->next=NULL;

if(Vacio1())

    H=p;

 else

   {

     while(i->next)

     i=i->next;

     i->next=p;

  }                                    

}

//-----------------------------------------------------------------------------

void ListaUnif::Poner2(struct datos2 Dato2)

{

     struct Nodo2 *j,*k=G;

     j=new(struct Nodo2);

     j->Y=Dato2;

     j->nextt=NULL;

     if(Vacio2())

         G=j;

     else

     {

         while(j->nextt)

         k=k->nextt;

         k->nextt=j;

     }       

}



//-----------------------------------------------------------------------------

int ListaUnif::CrearLista1()

{

    if(!(fp1=fopen("I:\\stockpro.bin","rb")))

     {

        cout<<"No se puede abrir el archivo"<<endl;

        return(1);

     }   

fread(&Reg, sizeof(Reg),1,fp1);



while(!feof(fp1))

{

     Poner1(Reg);

     fread(&Reg, sizeof(Reg),1,fp1);

}

fclose(fp1);

}

//------------------------------------------------------------------------------

int ListaUnif::CrearLista2()

{

    if(!(fp2=fopen("I:\\stockpro2.bin","rb")))

    {

      cout<<"No se puede abrir el archivo"<<endl;

      return(1);

}

fread(&Reg2,sizeof(Reg),1,fp2);



while(!feof(fp2))

{

   Poner2(Reg2);

   fread(&Reg2,sizeof(Reg2),1,fp2);

}

fclose(fp2);

}





 //-----------------------------------------------------------------------------   

void UnificarLista()

{

     if(!(fp=fopen("I:\\listafinal.bin","wb")))

    {

    printf("No se puede abrir el archivo\n");

    return(1);

    }

    for(struct Nodo *p=H; p!=NULL; p->next)

         for(struct Nodo2 *j=G; *j!=NULL; j->next)

            {

                  if(X.Nro_art==Y.Nro_art)

                  {

                   Z.Nro_art=X.Nro_art;

                   Z.Descripcion=X.Descripcion;

                   Z.Cant_exist=X.Cant_exist+Y.Cant_exist;

//El precio del producto será el mayor                   

                   if(X.Pre_uni>Y.Pre_uni)

                      Z.Pre_Uni=X.Pre_Uni; 

                   }

                   else

                   {

                   Z.Nro_art=X.Nro_art;

                   Z.Descripcion=X.Descripcion;

                   Z.Cant_exist=X.Cant_exist;

                   Z.Pre_Uni=X.Pre_Uni;

                   

                   

                   

                          

//-----------------------------------------------------------------------------

void ListaUnif::Espiar1(void)

{

   struct Nodo *p=T;

   if(Vacio3())

   cout<<"La lista esta vacia"<<endl;

   else

      while(p)

      {

              cout<<p->Z.Nro_art<<"\t"<<p->Z.Descripcion<<"\t"<<p->Z.Cant_exist<<"\t"<<p->Z.Pre_uni<<"\n";

            p=p->nexxtt;

            

      }      

}

                      

    fwrite(&Z, sizeof(Z), 1, fp3);

    }

fclose(fp);                

//-----------------------------------------------------------------------------                  

int main(void)

{

    int opcion,dato,dato1,,dato2;

    ListaUnif Prueba;

    Prueba.CrearLista1();

    Prueba.CrearLista2();

    Prueba.UnificarLista();

    Prueba.Espiar3();

    system("pause");

}





system("PAUSE");

exit(0);

}

             

El puntero NULL se usa para todo: lista, pilas, colas, atc. Que tengas 2 listas, 1 cola, 3 pilas; no pasa nada: el puntero null es para todo.
Se me ocurre abrir dos listas y en una tercera guardas el rejunte. Tendrias 3 punteros diferentes.

Hacelo con una sola lista.

Para agregar un elemento a la lista, iteras y te fijas si no existe ya.
Si existe, sumás al stock. Si no, agregás al final.

Gracias,Ya salió, lo hice como dijiste leibniz.

Genial!