TP2 Algoritmos

/*
Trabajo Practico Nº2 Algoritmos y Estructura de datos

Integrantes:
             - Centeno, Nicolas
             - Gonzalez Groba, Matias Alejandro
             - Porracin Dieguez, Marco


*/

#include<iostream>
#include<string.h>
#include<conio.h>
#include<stdio.h>
using namespace std;


//Estructuras
struct AC{  //estructura para el archivo de camiones
       int NroCamion;
       char Patente[7];
       char Marca[20];
       float CCarga;   //capacidad de carga
       float Kilometraje;
       float CViajes;  //Cantidad de viajes
       };

struct AO{   //estructura para el archivo de operaciones
       int NroDespacho;
       long int Fecha;  //AAMMDD
       int NroCamion;
       int NroDestino;
       float KgTransportados; //kilogramos transportados
       float Kilometraje;  //kilometros recorridos
       };

struct Detalles{    //estructura para armar la cola de la segunda planilla
       int NroCamion;
       long int fecha;  //AAMMDD
       int Destino;
       int NroDespacho;
       float Carga;
       float PorcentajeOcupado; //porcentaje ocupado
       };

        struct TNodo{           //estructura puntero a detalles
               Detalles info;
               struct TNodo *sgte;
        };

        struct Camiones{          //estructura que funciona como separador de la segunda planilla
               float CapacidadMax;
               char Patente[7];
               int CViajes;
               float Kilometraje;
        };

//variables predefinidas
typedef TNodo Cola;
typedef Detalles Dt;
typedef Camiones Cm[20];

//variables globales

//prototipos
void cargaCamiones(FILE *,AC,Cm);
void CargaOperaciones(FILE *,AO,Cm,Cola *[20],Cola *[20],float[10]);
void enqueue(Cola *&, Cola *&,Dt);
void dequeue(Cola *&, Cola *&,Dt &);
float ObtPorcentaje(float,float);
long long int ObtOrden(int,long int);
void mostrarPl1(float [10]);
void mostrarPl2(Cola *[20],Cola *[20],FILE *,Cm);
void actualizarRegistro(FILE *,AC,Cm);

//principal

int main()
{
    //variables locales
    AC cam;
    AO op;
    Cm Camiones;
    FILE *FO;
    FILE *FC;
    float KgsxDestino[10];
    for(int i=0;i<10;i++) KgsxDestino[i]=0;
    Cola *ViajeC[20];
    Cola *ViajeF[20];
    FO = fopen("Operaciones.dat","rb");
    FC = fopen("Camiones.dat","rb");
    if((!FO) || (!FC))
    {
             cout<<"al menos uno de los archivos no existe";
             getch();
             exit(1);
    }
    cargaCamiones(FC,cam,Camiones);
    fclose(FC);
    for(int i=0;i<20;i++)
    {
            ViajeC[i]=NULL;
            ViajeF[i]=NULL;
    }
    CargaOperaciones(FO,op,Camiones,ViajeC,ViajeF,KgsxDestino);
    fclose(FO);
    mostrarPl1(KgsxDestino);  //funcion para mostrar planillas
    mostrarPl2(ViajeC,ViajeF,FC,Camiones);
    actualizarRegistro(FC,cam,Camiones);  //funcion para actualizar AC
    getch();
}


//FUNCIONES

void CargaOperaciones(FILE *FO,AO op,Cm Camiones,Cola *ViajeC[20],Cola *ViajeF[20], float KgsxDestino[10])
{
    Dt Aux;
    fread(&op,sizeof(struct AO),1,FO);
     while(!feof(FO))
    {
       Aux.NroCamion=op.NroCamion;
       Aux.fecha = op.Fecha;
       Aux.Destino = op.NroDestino;
       Aux.NroDespacho = op.NroDespacho;
       Aux.Carga = op.KgTransportados;
       Aux.PorcentajeOcupado = ObtPorcentaje(Camiones[op.NroCamion-1].CapacidadMax,op.KgTransportados);
       enqueue(ViajeC[op.NroCamion-1],ViajeF[op.NroCamion-1],Aux);
       Camiones[op.NroCamion-1].CViajes++;
       Camiones[op.NroCamion-1].Kilometraje+=op.Kilometraje;
       KgsxDestino[op.NroDestino-1] += op.KgTransportados;
       fread(&op,sizeof(struct AO),1,FO);
    }
}

//Carga al vector de arrays Camiones
void cargaCamiones(FILE *FC, AC cam,Cm Camiones)
{
    FC = fopen("Camiones.dat","rb");
     fread(&cam,sizeof(struct AC),1,FC);
     while(!feof(FC))
     {
                     Camiones[cam.NroCamion-1].CapacidadMax = cam.CCarga;
                     strcpy(Camiones[cam.NroCamion-1].Patente,cam.Patente);
                     fread(&cam,sizeof(struct AC),1,FC);
     }
     fclose(FC);
}


//Muestra planilla 1
void mostrarPl1(float KgsxDestino[20])
{
      cout<<"Kilogramos por destino: \n\n";
    for(int k=0;k<10;k++)   cout<<k+1<<"\t"<<KgsxDestino[k]<<"\n";///MOSTRAR KgsxDestino

}

void mostrarPl2(Cola *ViajeC[20],Cola *ViajeF[20], FILE *FC,Cm Camiones)
{
     Dt aux;
     cout<<"\n\nViajes realizados en el mes: \n";
     for(int k=0;k<20;k++)
     {
            cout<<"\nCamion "<<k+1<<"    Capacidad en Kgrs total:"<<Camiones[k].CapacidadMax<<"   Patente:"<<Camiones[k].Patente<<"\n"<<"\t\t\tViajes\n";
            cout<<"Fecha\tDestino\tDespacho   Kgrs\t\tPorcentaje de ocupacion\n";
             while(ViajeC[k]!=NULL)
             {
                                dequeue(ViajeC[k],ViajeF[k],aux);
                                cout<<aux.fecha<<"\t";
                                cout<<aux.Destino<<"\t";
                                cout<<aux.NroDespacho<<"\t   ";
                                cout<<aux.Carga<<"\t\t";
                                cout<<aux.PorcentajeOcupado<<"\n";
             }
     }
 }

void actualizarRegistro(FILE *FC,AC cam,Cm Camiones)  //Actualiza el registro AC
{
     FC = fopen("Camiones.dat","rb");
     fread(&cam,sizeof(struct AC),1,FC);
     while(FC!=NULL)
     {
                   cam.CViajes+=Camiones[cam.NroCamion-1].CViajes;
                   cam.Kilometraje+=Camiones[cam.NroCamion-1].Kilometraje;
                   fread(&cam,sizeof(struct AC),1,FC);
     }
     fclose(FC);
 }


//obtener porcentaje
float ObtPorcentaje(float maximo,float cantidad)
{
                 return (cantidad*100)/maximo;
}


//Insertar datos en la cola
void enqueue(Cola *&ColaC, Cola *&ColaF, Dt valor)
{
     Cola *P;
     P=new Cola();
     P->info=valor;
     P->sgte=NULL;
     if(ColaC==NULL)     ColaC=P;
     else ColaF->sgte=P;
     ColaF=P;
}


//Obtener y borrar los datos en la cola
void dequeue(Cola *&ColaC, Cola *&ColaF, Dt &valor)
{
     Cola *P;
     P=ColaC;
     valor = P->info;
     ColaC=P->sgte;
     if(ColaC==NULL) ColaF=NULL;
     delete(P);
}