Ultimas cosas del main que llegue a hacer

Proyecto/libreria/Funciones.h

@@ -6,7 +6,7 @@
 enum reservar{ErrNoEncontrada=-1,ErrNoHayCupos=-2,ErrYaReservada=-3,ErrHorarioNoValido=-4,ErrActividadsuperpuesta=-5,ErrMuchasReservasActivas=-6,ErrClienteNoEncontrado=-7,ErrFaltadePago=-8,Reservadaconexito=1};
 typedef enum reservar Eres;
 //-------------------------CANCELAR RESERVA------------------------------------------------
-enum DescartarReserva{ErrNoReservada=-1,Canceladaconexito=1};
+enum DescartarReserva{ErrNoEncontradaDesc=-1,ErrHorarioNoValidoDesc=-4,Canceladaconexito=1};
 typedef enum DescartarReserva Edesc;
 //--------------------INICIALIZACION DE VARIABLE-------------------------------------------
 enum inicializar{ErrReservarmemoria=-1,ErrCantidadDeClientesSobrepasada=-2, inicializacionexitosa=1};
@@ -29,7 +29,8 @@ typedef struct cliente Scliente;
 
 struct musculacion{
     Scliente* cliente;//no se cuantos clientes asignare, uso memoria dinamica
-    int* iDClase,*horarios,CantHorarios;
+    int* iDClase,CantHorarios;
+    float *horarios;
     str Nombre;
 
 };
@@ -49,9 +50,24 @@ struct GIMNASIO{
     int CantClases,CantClientes,ClientesMax;
 };
 typedef struct GIMNASIO Sgym;
+//--------------------------------------PARA EL BINARIO----------------------------------------------
+struct Inscripcion{
+    u_int idCurso;
+    time_t fechaInscripcion;
+};
+typedef struct Inscripcion Sins;
+
+struct Asistencias{
+    u_int idCliente;
+    u_int cantInscriptos;
+    Sins* CursoYfecha;//es un array porque depende de cuantos inscriptos hay en la actividad
+
+};
+typedef struct Asistencias Sasis;
 
 //-----------------------------------------FUNCIONES-------------------------------------------------
 ini inicializarVariablesFijas(Sgym* Gimnasio);//puedo llamar a esta funcion para "reiniciar el dia"
+string generarActAlAzar(u_int NUM,str* Actividades);
 //------------------------------------------BUSCAR---------------------------------------------------
 int BuscarActividadPorNombre(Sgym ActsGim,str actividadPasada);//devuelve la posicion donde lo encuentra
 int BuscarActividadPorHorario(Sgym ActsGim,int horarioelegido,int posN);//recibira el dato de la otra funcion buscar y devuelve la posicion de la hora
@@ -65,11 +81,12 @@ Edesc CancelarReserva(Sgym* ActsGim,Scliente *misActs,int posN,int posH);//devue
 //Sacts es puntero porque va a tener que cambiar globalmente la cantidad de cupos,mientras que cliente tendra que cambiar actividad y horario.
 //------------------------------------------RESIZES--------------------------------------------------
 ini ResizeCliente(Scliente*& Clientes,int &tam,int ntam);
+ini ResizeAsistencias(Sasis*& Asist,int &tam,int ntam);
 //-----------------------------------------ARCHIVOS--------------------------------------------------
 Archi LeerArchivoActividades(ifstream& Archivo,Sgym* Gimnasio);//deberia usar resize u otros metodos pero tengo una variable que inicia los valores de las actividades con un numero fijo
 int ContarCantClientes(ifstream& Archivo);//cuenta las lineas del archivo y devuelve el numero total
 Archi LeerArchivoClientes(ifstream& Archivo,Sgym*Gimnasio,int &cantclientes,int cantclientesT);
-bool ChequearDatos(ifstream& Clientes);
-Archi Asistencias(ifstream& Asistencia);
+Archi ChequearDatos(ifstream& Clientes,int*& posErrNom,int*& posErrApe, int*& posErrorTel,int*& posErrorFecha);
+Archi LeerAsistencias(ifstream& Archivo,Sasis*& Asis,int*cantidadAsis);
 void SepararFecha(string fecha, int& dia, int& mes, int& ano);
 #endif // FUNCIONES_H

Proyecto/libreria/FuncionesImp.cpp

@@ -1,8 +1,10 @@
 #include "Funciones.h"
+//------------------------------------------FUNCIONES PARA EL MAIN------------------------------------------------
 ini inicializarVariablesFijas(Sgym* Gimnasio){
     //esta funcion inicializa los datos que son fijos en mis variables, como los cupos y los id reservas(van a estar inicializados en 0)
     int i;
     Gimnasio->CantClases=6;//la cantidad de clases es fijo
+    Gimnasio->ClientesMax=300;
     Gimnasio->actividades=new Sact[Gimnasio->CantClases];
     if(Gimnasio->actividades==nullptr)
         return ErrReservarmemoria;
@@ -107,7 +109,7 @@ ini inicializarVariablesFijas(Sgym* Gimnasio){
     Gimnasio->musculacion=new musculacion;
     Gimnasio->musculacion->CantHorarios=27;
     Gimnasio->musculacion->Nombre="Musculacion";
-    Gimnasio->musculacion->horarios=new int[Gimnasio->musculacion->CantHorarios];
+    Gimnasio->musculacion->horarios=new float[Gimnasio->musculacion->CantHorarios];
     Gimnasio->musculacion->iDClase=new int[Gimnasio->musculacion->CantHorarios];
     if(Gimnasio->musculacion->horarios==nullptr)
         return ErrReservarmemoria;
@@ -118,6 +120,11 @@ ini inicializarVariablesFijas(Sgym* Gimnasio){
     return inicializacionexitosa;
     //libero memoria en el main, porque si borro la memoria dinamica aca no estaria inicializando nada
 }
+string generarActAlAzar(u_int NUM,str* Actividades) {
+    // Usar la función rand() para seleccionar un índice al azar
+    int i = rand() % NUM;
+    return Actividades[i];
+}
 int BuscarActividadPorNombre(Sgym ActsGim,str actividadPasada){
     int i;
     for(i=0;i<ActsGim.CantClases;i++)
@@ -195,23 +202,25 @@ Eres ReservarAct(Sgym* ActsGim,Scliente *misActs,int posN,int posH,int *posRepAc
         return ErrFaltadePago;
     else if(pos0==-1)
         return ErrNoEncontrada;
-    else if(pos0==-3)
+    else if(pos0==-3){
+        for(int i=0;i<3;i++)
+        {
+            if(ActsGim->actividades[posN].IdClase[posH]==misActs->iDClasereserv[i]){
+                contrepe++;
+                *posRepAct=i;
+            }
+
+        }//Me dice cual es la actividad repetida
         return ErrYaReservada;
+    }
     else if(pos0==-4)
         return ErrHorarioNoValido;
     else if(pos0==-6)
         return ErrMuchasReservasActivas;
     else if(ActsGim->actividades[posN].cupos[posH]==0)
         return ErrNoHayCupos;
 
-    for(int i=0;i<3;i++)
-    {
-        if(ActsGim->actividades[posN].horarios[posH]==misActs->horariosRes[i]){
-            contrepe++;
-            *posRepAct=i;
-        }
 
-    }
     //agarrar los id de la clase dentro de la structura del cliente y comparar esos horarios con el de la nueva actividad
     if(contrepe!=0)
         return ErrActividadsuperpuesta;
@@ -225,12 +234,22 @@ Eres ReservarAct(Sgym* ActsGim,Scliente *misActs,int posN,int posH,int *posRepAc
     return Reservadaconexito;
 }
 Edesc CancelarReserva(Sgym* ActsGim,Scliente *misActs,int posN,int posH){
-    int i=0;
-    while(i<3&&misActs->iDClasereserv[i]!=ActsGim->actividades[posN].IdClase[posH]){
+    int i,pos=-1;
+    if(posN==-1)
+        return ErrNoEncontradaDesc;
+    else if(posH==-1)
+        return ErrNoEncontradaDesc;
+    else if(posH==-4)
+        return ErrHorarioNoValidoDesc;
+    /*while(i<3&&misActs->iDClasereserv[i]!=ActsGim->actividades[posN].IdClase[posH]){
         i++;
+    }*///por alguna razon cada vez que intento usar este formato me salta un segmentation fault;
+    for(i=0;i<3;i++){
+        if(misActs->iDClasereserv[i]==ActsGim->actividades[posN].IdClase[posH])
+            pos=i;
     }
-    if(i==3)
-        return ErrNoReservada;//No encontro el id de la clase en las clases reservadas
+    if(pos==-1)
+        return ErrNoEncontradaDesc;//No encontro el id de la clase en las clases reservadas
     else
     {
         //Se restablecen los valores
@@ -286,8 +305,8 @@ Archi LeerArchivoActividades(ifstream& Archivo,Sgym* Gimnasio){
     int i,j,k,l,m,n,o,horariosI;
     i=j=k=l=m=n=o=0;
 
-    while(Archivo.good()&&!Archivo.eof()){
-        getline(Archivo,line);
+    while(getline(Archivo,line),Archivo.good()&&!Archivo.eof()){
+
         istringstream iss(line);//permite leer los "campos de la linea"
         getline(iss,id,delimiter);//de donde leo, a donde leo, hasta donde leo
         getline(iss,NomAct,delimiter);
@@ -332,7 +351,7 @@ Archi LeerArchivoActividades(ifstream& Archivo,Sgym* Gimnasio){
         }else if(horariosI>=7&&horariosI<8||horariosI>=19&&horariosI<=21){
             if(NomAct.compare("Musculacion")==0){
             Gimnasio->musculacion->horarios[o]=stoi(horarios);
-            Gimnasio->musculacion->iDClase[o]=stoi(id);
+            Gimnasio->musculacion->iDClase[o]=stof(id);
             o++;
             }
         }
@@ -413,3 +432,66 @@ void SepararFecha(string fecha, int& dia, int& mes, int& anio) {
     getline(ss, campo, delimitador);
     anio = stoi(campo);
 }
+/*
+Archi ChequearDatos(ifstream& Clientes,int*& posErrNom,int*& posErrApe, int*& posErrorTel,int*& posErrorFecha){
+
+}
+Archi LeerAsistencias(ifstream& Archivo,Sasis*& asistencia,int*cantidadAsis){
+    if(!Archivo.is_open())
+        return ErrAbrirArchivo;
+
+    // INICIALIZO VARIABLES
+    int cantAsistencias = 0;
+    int contadorAsistencias = 0;
+    Archivo.clear();
+    Archivo.seekg(0,ios::beg);
+
+    //Leo hasta el final el archivo
+    asistencia=new Asistencias;
+    while (!Archivo.eof()) {
+
+        Archivo.read((char*)&asistencia->idCliente, sizeof(u_int));//uso int y no u_int por como lo declare al tipo de dato
+        Archivo.read((char*)&asistencia->cantInscriptos, sizeof(u_int));
+
+        Inscripcion* registrados= new Inscripcion[asistencia->cantInscriptos];
+        Inscripcion*Aux=registrados;//mismo tamaño
+        for(int i=0;i<asistencia->cantInscriptos;i++){
+            Archivo.read((char*)Aux,sizeof(Inscripcion));
+            Aux++;//Muevo el puntero a la siguiente pos
+        }
+        asistencia->CursoYfecha=Aux;
+
+        //Cuento la cantidad de asistencias(creo)
+        contadorAsistencias++;
+        ResizeAsistencias(asistencia,cantAsistencias,contadorAsistencias);//No es lo mas optimo pero no entiendo del todo como funcionan los binarios
+    }
+    cantidadAsis=&contadorAsistencias;
+
+    return ArchivoManipuladoConExito;
+}
+ini ResizeAsistencias(Sasis*& Asist,int &tam,int ntam){
+    if(Asist==nullptr&&ntam>0){
+        Sasis*Aux=new Sasis[ntam];
+        delete Asist;
+        Asist=Aux;
+        tam=ntam;
+        return inicializacionexitosa;
+    }
+    if(tam>=0&&ntam>0){
+        Sasis*Aux=new Sasis[ntam];
+        u_int longitud=(tam<ntam)?tam:ntam;
+        for(u_int i=0;i<longitud;i++)
+            Aux[i]=Asist[i];
+        (tam>1)? delete[] Asist:delete Asist;
+        Asist=Aux;
+        tam=ntam;
+        return inicializacionexitosa;
+    }else if(ntam>0){
+        Asist=new Sasis[ntam];
+        tam=ntam;
+        return inicializacionexitosa;
+    }else ErrReservarmemoria;
+
+}*/
+
+

Proyecto/libreria/Includes.h

@@ -6,6 +6,8 @@
 #include <string>
 #include <fstream>
 #include <sstream>
+#include <ctime>
+#include <cstdlib>  // Para rand() y srand()
 using namespace std;
 typedef std::string str;
 typedef unsigned int u_int;

Proyecto/main/main.cpp

@@ -3,36 +3,115 @@
 #include "FuncionesImp.cpp"
 
 int main() {
+    srand(time(NULL));
 //---------------------------------------------VARIABLES------------------------------------------------
-    ifstream InputActividades,InputClientes;
-    ofstream TextoParaUbicarArchivo;
+    ifstream InputActividades,InputClientes,InputAsistencias;
+    ofstream TextoParaUbicarArchivo,InformeGym;
     int cont=0;
     Sgym* Gimnasio=new Sgym;
 //--------------------------------------INICIALIZACION/APERTURA-----------------------------------------
     TextoParaUbicarArchivo.open("../Ubicacion.txt");
     TextoParaUbicarArchivo<<"Hola";
     InputActividades.open("../iriClasesGYM.csv");
     InputClientes.open("../iriClientesGYM.csv");
+    InputAsistencias.open("../asistencias_1697673600000.dat",ios::binary);
+    InformeGym.open("../InformeGym.txt");
 
     if (!InputActividades.is_open())
-        cout << "Error al abrir archivo" << endl;    
+        cout << "Error al abrir archivo Actividades" << endl;
     if (!InputClientes.is_open())
-        cout << "Error al abrir archivo" << endl;
-
+        cout << "Error al abrir archivo Clientes" << endl;
+    if(!InputAsistencias.is_open())
+        cout<<"Error al abrir archivo Asistencias"<< endl;
+//------------------------------------------INICIALIZO LAS VARIABLES----------------------------------------------------------
     inicializarVariablesFijas(Gimnasio);
     LeerArchivoActividades(InputActividades,Gimnasio);
     cont=ContarCantClientes(InputClientes);
     LeerArchivoClientes(InputClientes,Gimnasio,Gimnasio->CantClientes,cont);
 
+//---------------------------------------------DATOS DE PRUEBA EXITOSOS-------------------------------------------------------
+    str ActividadesCorrectas[7]={"Spinning","Stretching","Boxeo","Musculacion","Yoga","Zumba","Pilates"};
+    u_int cantActs=7;
+    str ActElegida;
+    int posN,posH,HorarioRandom,iDrandom,posCliente,contErrores=0,posicionactividadrepetida,contReservas=0,contCancelaciones=0,valorenum;
 
-
-
-
-
+    for(int i=0;i<20;i++){
+        ActElegida=generarActAlAzar(cantActs,ActividadesCorrectas);//ActividadesValidas
+        HorarioRandom= 7+rand()%(22-7);//HorariosValidos
+        iDrandom=1+rand()%(251-1);//iD validos
+        posN=BuscarActividadPorNombre(*Gimnasio,ActElegida);
+        posH=BuscarActividadPorHorario(*Gimnasio,HorarioRandom,posN);
+        posCliente=BuscarClientePorId(*Gimnasio,iDrandom);
+        valorenum=ReservarAct(Gimnasio,&(Gimnasio->clientes[posCliente]),posN,posH,&posicionactividadrepetida);
+        if(valorenum==Reservadaconexito)
+            contReservas++;
+        else
+            contErrores++;
+    }
+    cout<<"Se resevraron: "<<contReservas<<" Actividades con exito"<<endl;
+    cout<<"Hubo "<<contErrores<<" errores al reservar"<<endl;
+    InformeGym<<"------------------RESERVAS------------------"<<endl;
+    InformeGym<<"Se reservaron: "<<contReservas<<" actividades con exito"<<endl;
+    InformeGym<<"Hubo "<<contErrores<<" al reservar"<<endl;
+    contErrores=0;
+    for(int i=0;i<20;i++){
+        ActElegida=generarActAlAzar(cantActs,ActividadesCorrectas);//ActividadesValidas
+        HorarioRandom= 7+rand()%(22-1);//HorariosValidos
+        iDrandom=1+rand()%(251-1);//iD validos
+        posN=BuscarActividadPorNombre(*Gimnasio,ActElegida);
+        posH=BuscarActividadPorHorario(*Gimnasio,HorarioRandom,posN);
+        posCliente=BuscarClientePorId(*Gimnasio,iDrandom);
+        valorenum=CancelarReserva(Gimnasio,&(Gimnasio->clientes[posCliente]),posN,posH);
+        if(valorenum==Canceladaconexito)
+            contCancelaciones++;
+        else
+            contErrores++;
+    }
+    InformeGym<<"------------------CANCELACIONES------------------"<<endl;
+    InformeGym<<"Se Cancelaron: "<<contCancelaciones<<" actividades con exito"<<endl;
+    InformeGym<<"Hubo "<<contErrores<<" errores al cancelar las reservas"<<endl;
+ /*
+//--------------------------------DATOS DE PRUEBA QUE TIENEN QUE FALLAR-------------------------------------------------------
+    str ActividadesIncorrectas[7]={"Spinng","Streing","Box","Muscacion","Yoa","Zmba","Pites"};
+    u_int cantActs=7;
+    str ActElegida;
+    int posN,posH,HorarioRandom,iDrandom,posCliente,contErrores=0,posicionactividadrepetida,contReservas=0,contCancelaciones=0,valorenum;
+    for(int i=0;i<20;i++){
+        ActElegida=generarActAlAzar(cantActs,ActividadesIncorrectas);//ActividadesValidas
+        HorarioRandom= 1+rand()%(30-1);//HorariosNovalidos
+        iDrandom=1+rand()%(500-1);//iD validos
+        posN=BuscarActividadPorNombre(*Gimnasio,ActElegida);
+        posH=BuscarActividadPorHorario(*Gimnasio,HorarioRandom,posN);
+        posCliente=BuscarClientePorId(*Gimnasio,iDrandom);
+        valorenum=ReservarAct(Gimnasio,&(Gimnasio->clientes[posCliente]),posN,posH,&posicionactividadrepetida);
+        if(valorenum==Reservadaconexito)
+            contReservas++;
+        else
+            contErrores++;
+    }
+    cout<<"Se resevraron: "<<contReservas<<" Actividades con exito"<<endl;
+    cout<<"Hubo "<<contErrores<<" errores al reservar"<<endl;//Deberian ser todos los del for
+    contErrores=0;
+    for(int i=0;i<20;i++){
+        ActElegida=generarActAlAzar(cantActs,ActividadesCorrectas);//ActividadesValidas
+        HorarioRandom= 7+rand()%(22-1);//HorariosValidos
+        iDrandom=1+rand()%(251-1);//iD validos
+        posN=BuscarActividadPorNombre(*Gimnasio,ActElegida);
+        posH=BuscarActividadPorHorario(*Gimnasio,HorarioRandom,posN);
+        posCliente=BuscarClientePorId(*Gimnasio,iDrandom);
+        valorenum=CancelarReserva(Gimnasio,&(Gimnasio->clientes[posCliente]),posN,posH);
+        if(valorenum==Canceladaconexito)
+            contCancelaciones++;
+        else
+            contErrores++;
+    }
+   */
 //-----------------------------------------------CERRAR ARCHIVOS--------------------------------------------------------------
     TextoParaUbicarArchivo.close();
     InputClientes.close();
     InputActividades.close();
+    InputAsistencias.close();
+    InformeGym.close();
 //--------------------------------------------ELIMINACION DINAMICAS----------------------------------------------------------
     for (int i = 0; i < Gimnasio->CantClases; ++i) {
         delete[] Gimnasio->actividades[i].horarios;