/**-------------------------------------------------------------
| Funcion: eliminarTramo |
---------------------------------------------------------------
| Entradas: ninguna |
| Retorno: seleccion del usuario. |
--------------------------------------------------------------*/
void eliminarTramo(Tren tren)
{
char archivo[50], archivo2[50];
char opcion;
L_Tramos Tramos;
sprintf(archivo, "../BaseDatos/Rutas/%s.ruta", tren);
sprintf(archivo2, "../BaseDatos/Rutas/%s.lista", tren);
Tramos.num = NumRegArchivoBin(archivo, sizeof(TipoTramo));
if(!Tramos.num){
printf( "La lista de tramos esta vacia. \n");
Pausa();
getchar();
return; // salimos de la función
}
mostrarTramo(tren);
printf("\n\nVa a borrar TODOS los tramos del tren: %s\n", tren);
opcion = leerSiNo("Desea continuar (S/N)?");
if(opcion == 'S')
{
remove(archivo);
remove(archivo2);
}
else
{
printf("Eliminacion cancelada\n");
Pausa();
}
}
// --------------------------------------------------------------------------
// Chama as funcoes que inicializam os atributos, os mostram e modificam.
// Obs: esta funcao poderia ser eliminada, se as diferencas em relacao a
// funcao da classe base sejam incluidas em uma das funcoes acessadas
// pela funcao de entrada da classe base.
void
CMaterialMeioPorosoAmostra::f_entrada ()
{
cout << "\n\tO objeto CMaterialMeioPorosoAmostra e' complexo, "
<< "\n\tconsiste de dois objetos todo parte"
<< "\n\t(material meio poroso MMP e material fluido MF)"
<< "\n\tAlem disso, herda os atributos da classe base material,"
<< "\n\te inclue novos atributos."
<< "\n\n\tPrimeiro obtem dados dos objetos todo parte"
<< "\n\tDepois do objeto CMaterialMeioPorosoAmostra";
cout << "\n\n\tVai executar as funcoes de entrada do objeto todo"
<< " parte Material_Fluido";
Pausa ();
MF->Entrada (); // entrada classe base material fluido
// cin>>MF;
cin.get ();
Carimbo ();
cout << "\n\tVai executar as funcoes de entrada do objeto "
<< "\n\ttodo parte Material_Meio_Poroso";
Pausa ();
MMP->Entrada (); // entrada classe base TMaterial meio poroso
// cin>>MMP;
cin.get ();
Carimbo ();
cout << "\n\tVai executar a funcao de entrada "
<< "do objeto CMaterialMeioPorosoAmostra"
<< "\n\tPrimeiro os atributos da classe base depois os novos.";
Pausa ();
TMaterial::Entrada (); // executa a funcao de entrada da classe base.
}
/**-------------------------------------------------------------
| Funcion: mostrarTodosTrenes |
---------------------------------------------------------------
| Descripción: Lista todos los trenes registrados |
| |
| Entradas: vector de registros de tipo Tren |
| Retorno: nada |
--------------------------------------------------------------*/
void mostrarTodosTrenes(void)
{
char ID[8];
// Variables locales
int np, j;
char linea[255];
L_Trenes Trenes;
int encontrado=0;
// Compruebo existencia de archivo y nº de registros
Trenes.num = NumRegArchivoBin(TRENES_BIN, sizeof(Tren));
if(!Trenes.num){
printf( "La lista de trenes esta vacia. \n");
Pausa();
return; // salimos de la función
}
// Cargamos los datos desde el archivo
abrirArchivoTrenes(&Trenes);
system("cls");
cabeceraTabla("Listado de Trenes");
comienzoTabla();
sprintf(linea, FMT_TRENX, 179, "ID", "Tren", "Tipo",
"Origen", "Destino", "Hora Sal.", "Hora Lleg.", "Precio", 179);
printf("%s", linea);
linea[0] = (char)195; for(j=1;j<78;j++) linea[j] = (char)196; linea[78]=(char)180; linea[79]=0;
printf("%s\n", linea);
if (Trenes.num == 0) {
printf("%c %-75s %c\n", 179, "La lista de trenes esta vacia.",179);
}
else {
for (np=0; np < Trenes.num; np++) {
mostrarTren(Trenes.lista[np]);
}
}
finTabla();
printf("\n\nPresione <RETURN> para volver al menu anterior o bien introduzca la ID del \ntren del que desea mostrar la ruta: "); fflush(stdin); gets(ID);
// compruebo si la cadena contiene algun codigo
if(strlen(ID)==0)
{
return;
}
for(np=0;np<Trenes.num;np++)
{
if(strcmp(Trenes.lista[np].ID, ID) ==0) encontrado =1; //los ID coinciden encontrado=1,
}
if(!encontrado) {printf("\n\nEl ID NO es valido\n\n"); Pausa();}
else mostrarTramo(ID);
}
/**-------------------------------------------------------------
| Funcion: mostrarTramo |
---------------------------------------------------------------
| Descripción: Lista el tramo |
| |
| Entradas: nada |
| Retorno: nada |
--------------------------------------------------------------*/
void mostrarTramo(Tren ID)
{
// Variables locales
int np, j,var1,var2;
char linea[255];
L_Tramos Tramos;
L_Estaciones estaciones;
char archivo[50];
// Compruebo existencia de archivo y nº de registros
sprintf(archivo, "../BaseDatos/Rutas/%s.ruta", ID);
Tramos.num = NumRegArchivoBin(archivo, sizeof(TipoTramo));
if(!Tramos.num){
printf( "La lista de tramos esta vacia. \n");
Pausa();
return; // salimos de la función
}
// Cargamos los datos desde el archivo
abrirArchivoRutasSinNumero(&Tramos, ID);
abrirArchivoEstacionesSinNumero(&estaciones);
printf("\n\n");
cabeceraTabla("Listado de Tramos");
comienzoTabla();
sprintf(linea, FMT_TRAMOX2, 179, "ID", "Origen", "Destino",
"Inicio", "Fin", "Precio", 179);
printf("%s", linea);
linea[0] = (char)195; for(j=1;j<78;j++) linea[j] = (char)196; linea[78]=(char)180; linea[79]=0;
printf("%s\n", linea);
if (Tramos.num == 0) {
printf("%c %-75s %c\n", 179, "La lista de tramos esta vacia.",179);
}
else {
for (np=0; np < Tramos.num; np++) {
var1 = comprobarNombre(Tramos.lista[np].IDorigen);
var2 = comprobarNombre(Tramos.lista[np].IDdestino);
printf(FMT_TRAMO2, 179, Tramos.lista[np].ID, estaciones.lista[var1].nombre,
estaciones.lista[var2].nombre,Tramos.lista[np].inicio.horas,
Tramos.lista[np].inicio.minutos,Tramos.lista[np].fin.horas,
Tramos.lista[np].fin.minutos, Tramos.lista[np].precio, 179);
}
}
finTabla();
Pausa();
}
/**-------------------------------------------------------------
| Funcion: modificarUnTren |
---------------------------------------------------------------
| Descripción: selecciona un tren y modifica uno de sus |
| campos |
| |
| Entradas: ninguna |
| Retorno: nada |
--------------------------------------------------------------*/
void modificarUnTren()
{
int encontrado = 0, i=0;
char cadena[80]="";
L_Trenes trenes;
// Compruebo existencia de archivo y nº de registros
trenes.num = NumRegArchivoBin(TRENES_BIN, sizeof(Tren));
if(!trenes.num){
printf( "La lista de trenes esta vacia. \n");
Pausa();
return;
}
// hay paradas registradas
system("cls");
cabeceraTabla("Actualizar los datos de un tren");
abrirArchivoTrenes(&trenes);
mostrarTodosTrenes_v2();
printf("Seleccione codigo del tren \na modificar (pulse <RETURN> para cancelar): ");
fflush(stdin); gets(cadena);
// compruebo si la cadena contiene algun codigo
if(strlen(cadena)==0)
{
printf("Modificacion cancelada\n");
Pausa();
return;
}
// busqueda del tren correspondiente al codigo tecleado
i=0;
while(!encontrado && i<trenes.num) {
if( strcmp(trenes.lista[i].ID, cadena) == 0) {
encontrado = 1;
}
else i++;
}
if(encontrado) { // se ha encontrado la estacion
modificarTren(&trenes.lista[i]);
grabarArchivoTrenes(trenes);
}
else{ // no se ha encontrado la estacion
printf("El tren de codigo %s no esta registrado\n", cadena);
Pausa();
}
}
/**-------------------------------------------------------------
| Funcion: generarTramo |
---------------------------------------------------------------
| Entradas: ninguna |
| Retorno: seleccion del usuario. |
--------------------------------------------------------------*/
void generarTramos()
{
FILE *ptr;
FILE *ptr1;
int i;
char archivo[50];
L_Trenes Trenes;
L_Tramos Tramos;
abrirArchivoTrenes(&Trenes);
ptr1 = fopen("../BaseDatos/tramos.dat", "wb");
for(i=0;i<Trenes.num;i++)
{
sprintf(archivo, "../BaseDatos/Rutas/%s.ruta", Trenes.lista[i].ID);
Tramos.num = NumRegArchivoBin(archivo, sizeof(TipoTramo));
if(Tramos.num){
ptr = fopen(archivo, "rb");
// Creamos un vector de Tramos->num registros de tipo Tramos
Tramos.lista = (TipoTramo*) calloc(sizeof(TipoTramo), Tramos.num);
if(Tramos.lista == NULL) {
printf("No hay memoria suficiente para la lista de tramos.\n");
Pausa();
exit(0);
}
fread((TipoTramo*)Tramos.lista, sizeof(TipoTramo), Tramos.num, ptr);
}
printf("\nNumero de tramos en %s.ruta: %d\n", Trenes.lista[i].ID, Tramos.num);
fwrite((TipoTramo*)Tramos.lista, sizeof(TipoTramo), Tramos.num, ptr1);
}
imprimirTodosTramos();
fclose(ptr1);
}
void modificarEstacion(Estacion *estacion)
{
int eleccion;
comienzoTabla();
mostrarEstacion(*estacion);
finTabla();
printf("Indique el campo que quiere modificar (1 a 4): ");
eleccion = leerOpcionValida("Seleccione opcion: ", '4');
switch(eleccion)
{
case 1: // ID
printf("Nuevo codigo: "); gets(estacion->ID);
break;
case 2: // Nombre
printf("Nuevo nombre: "); gets(estacion->nombre);
break;
case 3: // Localidad
printf("Localidad: "); gets(estacion->localidad);
break;
case 4: // posicion
estacion->pos = leerPosicion_v1();
break;
default: printf("Seleccion erronea\n");
printf("La estacion de codigo %s no ha sido modificada\n", estacion->ID);
Pausa();
return;
}
printf("La estacion de codigo %s ha sido modificada\n", estacion->ID);
}
/**-------------------------------------------------------------
| FUNCION: validarHora |
|---------------------------------------------------------------|
| RESEÑA: Busca si la hora esta bien o no |
| |
| DEVUELVE: si la hora esta bien |
--------------------------------------------------------------*/
void validarHora(int *horas, int *minutos)
{
if(horas<0 || horas>23)
{
printf("\n\nHora NO valida. Revisa la Hora\n");
Pausa();
getchar();
mantenimientoTrenes();
}
if(minutos<0 || minutos>59)
{
printf("Hora no valida. Revisa los minutos\n\n");
Pausa();
getchar();
mantenimientoTrenes();
}
}
// ---------------------------------------------------------------------------
// Mostra os valores dos atributos
void
CMaterialMeioPorosoAmostra::Saida ()
{
// se na funcao de entrada, permite a entrada dos atributos dos dois objetos
// estaticos, MF e MMP, aqui deveria mostrar os atributos destes dois objetos
// para que o usuário possa os alterar?
// Isto nao e necessario, pois voce executa as funcoes f_entrada dos objetos
// estaticos, e a funcao f_entrada ja verifica a entrada correta dos dados
// possibilitando ao usuário a alteracao atributos errados. OK.
cout <<
"\n\tObjeto material meio poroso amostra, atributos da classe base.";
TMaterial::Saida ();
cout << "\n\tObjeto CMaterialMeioPorosoAmostra, atributos novos:";
Pausa ();
// cout<<"\n\tdimensao_x="<<dimensao_x;
// cout<<"\tdimensao_y="<<dimensao_y;
// cout<<"\tdimensao_z="<<dimensao_z;
cout << "\tconcentracao_vapor=" << concentracao_vapor;
cout << "\n\tmassa_saturada=" << massa_saturada;
cout << "\tmassa_seca=" << massa_seca;
cout << "\n\tvolume=" << volume;
cout << "\n\tumidade=" << umidade;
cout << "\n\tconteudo_ol=" << conteudo_ol;
cout << "\tconteudo_wl=" << conteudo_wl;
cout << "\n\tfator_experimental=" << fator_experimental;
cout << "\n\ttemperatura_ensaio de adsorcao e dessorcao" <<
temperatura_ensaio_adsorcao;
cout << "\n\tdtv=" << dtv;
cout << "\tdtl=" << dtl;
cout << "\tdolv=" << dolv;
cout << "\tdoll=" << doll;
// f_pausa();
cout << "\n\tDeseja ver os polinomios do objeto CMaterialMeioPorosoAmostra"
<<
"\n\tCondutividade,adsorcao,dessorcao,difusividade,derivada_h_teta e fator exp:";
cin.get (resp); // =getche();
cin.get ();
if (resp == 's' || resp == 'S')
{
cout << "\n\tCoeficientes polinomio condutividade\n";
cout << &p_k; // p_k.f_saida();
cout << "\n\tCoeficientes polinomio adsorcao\n";
cout << &p_ads; // p_ads.f_saida();
cout << "\n\tCoeficientes polinomio dessorcao\n";
cout << &p_des; // p_des.f_saida();
cout << "\n\tCoeficientes polinomio difusividade\n";
cout << &p_dif_termica; // p_dif_termica.f_saida();
cout << "\n\tCoeficientes polinomio para derivada_h_teta\n";
cout << &p_der; // p_der.f_saida();
cout << "\n\tCoeficientes polinomio para fator experimental\n";
cout << &p_fe; // p_fe.f_saida();
}
}
void validarEstacion(char *ID)
{
FILE *ptr;
Estacion estacion;
char opcion;
int encontrado = 0;
ptr = fopen(ESTACIONES_BIN, "rb");
if(ptr!=NULL) // el archivo existe
{
while(!feof(ptr) && !encontrado)
{
fread(&estacion, sizeof(Estacion), 1, ptr); // leo el registro
if(strcmp(estacion.ID, ID)==0 ) // los ID coinciden
{
encontrado = 1;
}
}
fclose(ptr);
}
if(!encontrado)
{
printf("\nESTACION NO REGISTRADA.\n\n");
opcion = leerSiNo("La estacion DEBE estar registrada para poder continuar\n\nDesea crear una estacion con ese codigo (S/N)?");
if(opcion == 'S')
{
strcpy(estacion.ID, ID);
fflush(stdin);
printf("\tNombre: "); gets(estacion.nombre);
printf("\tLocalidad: "); gets(estacion.localidad);
printf("\tLatitud (en grados) : "); scanf("%lf", &estacion.pos.latitud);
printf("\tLongitud (en grados): "); scanf("%lf", &estacion.pos.longitud);
// grabar datos de la nueva estacion
ptr = fopen(ESTACIONES_BIN, "ab");
if(ptr == NULL) {
printf("El archivo %s no existe.\n", ESTACIONES_BIN);
}
fwrite((Estacion*)&estacion, sizeof(Estacion), 1, ptr);
fclose(ptr);
/* llamo a la funcion imprimirEstaciones para generar el archivo de texto */
imprimirEstaciones();
Pausa();
}
else
{
mantenimientoTrenes();
}
}
}
/**-------------------------------------------------------------
| Funcion: mostrarTodosTrenes |
---------------------------------------------------------------
| Descripción: Lista todos los trenes registrados |
| |
| Entradas: vector de registros de tipo Tren |
| Retorno: nada |
--------------------------------------------------------------*/
void mostrarTodosTrenes_v2(void)
{
char ID[8];
// Variables locales
int np, j;
char linea[255];
L_Trenes Trenes;
int encontrado=0;
// Compruebo existencia de archivo y nº de registros
Trenes.num = NumRegArchivoBin(TRENES_BIN, sizeof(Tren));
if(!Trenes.num){
printf( "La lista de trenes esta vacia. \n");
Pausa();
return; // salimos de la función
}
// Cargamos los datos desde el archivo
abrirArchivoTrenes(&Trenes);
system("cls");
cabeceraTabla("Listado de Trenes");
comienzoTabla();
sprintf(linea, FMT_TRENX, 179, "ID", "Tren", "Tipo",
"Origen", "Destino", "Hora Sal.", "Hora Lleg.", "Precio", 179);
printf("%s", linea);
linea[0] = (char)195; for(j=1;j<78;j++) linea[j] = (char)196; linea[78]=(char)180; linea[79]=0;
printf("%s\n", linea);
if (Trenes.num == 0) {
printf("%c %-75s %c\n", 179, "La lista de trenes esta vacia.",179);
}
else {
for (np=0; np < Trenes.num; np++) {
mostrarTren(Trenes.lista[np]);
}
}
finTabla();
Pausa();
}
/**-------------------------------------------------------------
| Función : identificacionCliente() |
---------------------------------------------------------------
| Reseña : controla el acceso a la aplicación Tienda Virtual. |
| Pide el nombre de usuario y la clave, y comprueba |
| si es un cliente autorizado. |
| Se permiten 3 intentos; si al tercero no se |
| introduce un usuario/clave correcto, el |
| programa finaliza. |
| Devuelve: código de cliente, ó 0, si el cliente no está |
| registrado |
--------------------------------------------------------------*/
int identificacionCliente(void)
{
int i=0;
int encontrado=-1;
char usuario[12];
char clave[12];
tListaClientes clientes;
cargarDatosClientes(&clientes);
printf("Nombre de usuario: ");
gets(usuario);
printf("Contrase%ca: ",164);
gets(clave);
while(i<clientes._num && encontrado==-1 )
{
if(strcmp(clientes._lista[i]._login, usuario)==0) // mismo nombre
{
if(strcmp(clientes._lista[i]._clave, clave)==0) // mismo nombre
{
encontrado = i; // guardo el indice en encontrado
}
else
{
i++;
}
}
else
{
i++;
}
}
printf("Comprobando identidad...\n");
Pausa();
if(encontrado==-1)
return -1;
else
return i;
}
/**-------------------------------------------------------------
| Funcion: grabarArchivoTrenes |
---------------------------------------------------------------
| Descripción: graba la lista de trenes en un archivo |
| binario |
| Entradas: registro 'lista de Trenes' |
| Retorno: nada |
--------------------------------------------------------------*/
void grabarArchivoTrenes(L_Trenes Trenes)
{
FILE *ptr;
int reg;
// Compruebo existencia de registros
if(Trenes.num){
ptr = fopen(TRENES_BIN, "wb");
reg = fwrite((Tren*)Trenes.lista, sizeof(Tren), Trenes.num, ptr);
fclose(ptr);
}
else
{
printf("La lista esta vacia.\n");
Pausa();
}
}
void Taulell::enTeclaAvall(wxKeyEvent& event)
{
if (!this->isIniciat || this->FitxaActual.TreuForma() == FormaBuida) {
event.Skip();
return;
}
int keycode = event.GetKeyCode();
if (keycode == 'p' || keycode == 'P') {
Pausa();
return;
}
if (isAturat)
return;
switch (keycode) {
case WXK_LEFT:
this->ProvaMoure(curPiece, curX - 1, curY);
break;
case WXK_RIGHT:
this->ProvaMoure(curPiece, curX + 1, curY);
break;
case WXK_DOWN:
this->ProvaMoure(curPiece.RotateRight(), curX, curY);
break;
case WXK_UP:
this->ProvaMoure(curPiece.RotateLeft(), curX, curY);
break;
case WXK_SPACE:
this->LlancaAvall();
break;
case 'd':
this->LiniaAbaix();
break;
case 'D':
this->LiniaAbaix();
break;
default:
event.Skip();
}
}
/**-------------------------------------------------------------
| Funcion: abrirArchivoTrenesSinNumero |
---------------------------------------------------------------
| Descripción: Abre el archivo binario de trenes y lo carga |
| en memoria en la dirección pasada como parámetro|
| |
| Entradas: direccion del registro 'lista de Trenes' |
| Retorno: nada |
--------------------------------------------------------------*/
void abrirArchivoTrenesSinNumero(L_Trenes *Trenes)
{
FILE *ptr;
// Compruebo existencia de archivo y nº de registros
Trenes->num = NumRegArchivoBin(TRENES_BIN, sizeof(Tren));
if(Trenes->num){
ptr = fopen(TRENES_BIN, "rb");
// Creamos un vector de Trenes->num registros de tipo Tren
Trenes->lista = (Tren*) calloc(sizeof(Tren), Trenes->num);
if(Trenes->lista == NULL) {
printf("No hay memoria suficiente para la lista de trenes.\n");
Pausa();
exit(0);
}
fread((Tren*)Trenes->lista, sizeof(Tren), Trenes->num, ptr);
}
// return Trenes->num;
}
/**-------------------------------------------------------------
| Función : identificacionEmpleado() |
---------------------------------------------------------------
| Reseña : controla el acceso a la aplicación. Pide el |
| nombre de usuario y la clave, y comprueba si |
| es un usuario autorizado. |
| Si el usuario es gerente, devuelve 1; |
| si es un encargado, devuelve 2. |
| Si es un cajero, devuelve 3. |
| Se permiten 3 intentos; si al tercero no se |
| introduce un usuario/clave correcto, devuelve 0. |
| programa finaliza. |
| Devuelve: tipo de usuario: |
| 1: gerente |
| 2: encargado |
| 3: cajero |
| 0: el usuario no es empleado |
--------------------------------------------------------------*/
int identificacionEmpleado(void)
{
FILE *ptr;
char usuario[100];
char fusuario[100];
char pass[100];
char fpass[100];
int acceso = -1;
int facceso = -1;
// Solicito al empleado el usuario y clave de acceso.
printf("Usuario: "); gets(usuario);
printf("Clave: "); gets(pass);
printf("\n");
// Apertura y comprobación en archivo de empleados.
ptr = fopen("../BaseDatos/empleados.user", "r");
if(ptr == NULL)
{
return 0;
}
while(!feof(ptr)) //Blucle para recorrer todos los usuarios.
{
fscanf(ptr, "%s %s %d", fusuario, fpass, &facceso);
if(strcmp(fusuario,usuario)==0 && strcmp(fpass,pass)==0) //Comprobamos usuario y clave
{
acceso = facceso;
break;
}
}
/* Cierro el archivo */
fclose(ptr);
printf("Comprobando identidad...");
Pausa();
return acceso; // POR DEFECTO el usuario NO ES EMPLEADO
}
void VEmpresa::ReporteSalaCine(vector<string> auxtiposa,
vector<string> auxtipofu, vector<string> auxcod,
vector<int> auxcantev, float montotv){
Limpiar();
ImprimirEncabezado("REPORTE DE SALAS CINEX METROPOLIS", "==============================");
for(unsigned int i=0; i<auxtiposa.size(); i++){
ImprimirNroJustificado(i+1, 5);
ImprimirLineasBlanco(1);
ImprimirStringJustificado("Tipo Sala: "+ auxtiposa[i], 10);
ImprimirStringJustificado("Tipo de funcion: "+ auxtipofu[i], 10);
ImprimirLineasBlanco(1);
ImprimirString("Codigo de la pelicula: ", auxcod[i]);
ImprimirLineasBlanco(1);
ImprimirNro("Total entradas vendidas", auxcantev[i]);
ImprimirLineasBlanco(1);
}
ImprimirNroDecimal("MONTO TOTAL BSF. INGRESADO A LA EMPRESA: ", montotv);
Pausa();
}
/**-------------------------------------------------------------
| Funcion: abrirArchivoRutasSinNumero |
---------------------------------------------------------------
| Descripción: Abre el archivo binario de estaciones y lo carga|
| en memoria en la dirección pasada como parámetro|
| |
| Entradas: direccion del registro 'lista de Estaciones' |
| Retorno: nada |
--------------------------------------------------------------*/
void abrirArchivoRutasSinNumero(L_Tramos *Tramos,Tren tren)
{
FILE *ptr;
char archivo[50];
// Compruebo existencia de archivo y nº de registros
sprintf(archivo, "../BaseDatos/Rutas/%s.ruta", tren);
Tramos->num = NumRegArchivoBin(archivo, sizeof(TipoTramo));
if(Tramos->num){
ptr = fopen(archivo, "rb");
// Creamos un vector de Tramos->num registros de tipo Tramos
Tramos->lista = (TipoTramo*) calloc(sizeof(TipoTramo), Tramos->num);
if(Tramos->lista == NULL) {
printf("No hay memoria suficiente para la lista de tramos.\n");
Pausa();
exit(0);
}
fread((TipoTramo*)Tramos->lista, sizeof(TipoTramo), Tramos->num, ptr);
}
}
void funcionAmpliacion(int opc)
{
int ID;
ListaNodos nodos;
ListaArcos arcos;
TipoGrafo Grafo;
cargarListaNodos(&nodos);
cargarListaTramos(&arcos, opc);
crearGrafo(nodos, arcos, &Grafo);
printf("Introduce el ID del nodo: "); scanf("%d", &ID);
// En el caso de que el numero no exista
if(ID>nodos.numNodos)
{
printf("ERROR. El numero debe estar comprendido entre 0 y %d\n", nodos.numNodos);
Pausa();
getchar();
exit(0);
}
muestraEstacionesCercanas(Grafo, ID);
}
void VEmpresa::ReporteVendedores(vector<string> auxced, vector<string> auxnom,
vector<float> auxsuel) {
Limpiar();
ImprimirStringJustificado("LISTADO CORREDORES DE SEGUROS",46);
ImprimirLineasBlanco(1);
ImprimirStringJustificado("=============================",46);
ImprimirLineasBlanco(2);
ImprimirStringJustificado("CEDULA",12);
ImprimirStringJustificado("NOMBRE",25);
ImprimirStringJustificado("SUELDONETO",20);
ImprimirLineasBlanco(1);
/* Instrucciones que imprimen la cédula, nombre y comision
mensual de los corredores de seguros*/
for(unsigned int i=0; i<auxced.size(); i++)
{
ImprimirStringJustificado(auxced[i],12);
ImprimirStringJustificado(auxnom[i],25);
ImprimirNroDecimalJustificado(auxsuel[i],20);
ImprimirLineasBlanco(1);
}
ImprimirLineasBlanco(1);
Pausa();
}
void VEmpresa::PorcentajeVespec(int porc) {
ImprimirNro( "\n\n 2. Porcentaje de vendedores cuyo monto total de ventas estuvo entre la mayor venta y 10% por debajo de la mayor venta: ", porc);
ImprimirLineasBlanco(3);
Pausa();
}
/**-------------------------------------------------------------
| Funcion: eliminarTren |
---------------------------------------------------------------
| Descripción: elimina un tren de la lista |
| |
| Entradas: los datos se leen del archivo |
| Retorno: nada |
--------------------------------------------------------------*/
void eliminarTren(void)
{
int i, encontrado;
char codigo[10];
char archivo[50];
char archivo2[50];
int eleccion;
char opcion;
L_Trenes trenes;
// Compruebo existencia de archivo y nº de registros
trenes.num = NumRegArchivoBin(TRENES_BIN, sizeof(Tren));
if(!trenes.num){
printf( "La lista de trenes esta vacia. \n");
Pausa();
return;
}
// hay paradass registradas
system("cls");
cabeceraTabla("Eliminar un tren");
abrirArchivoTrenes(&trenes);
mostrarTodosTrenes_v2();
printf("Indique el codigo del tren que quiere eliminar: ");
gets(codigo);
i= 0;
encontrado = 0;
while(i<trenes.num && !encontrado)
{
if( strcmp(trenes.lista[i].ID, codigo) == 0) // si el codigo del tren coincide
{
encontrado = 1; // hemos encontrado el tren a borrar
}
else i++;
}
if(encontrado)
{
eleccion = i;
printf("Ha seleccionado el siguiente tren:\n");
comienzoTabla();
mostrarTren(trenes.lista[eleccion]);
finTabla();
opcion = leerSiNo("Desea eliminarlo (S/N)?");
if(opcion == 'S')
{
// borro el archivo ruta correspondiente
sprintf(archivo, "../BaseDatos/Rutas/%s.ruta", trenes.lista[eleccion].ID);
sprintf(archivo2, "../BaseDatos/Rutas/%s.lista", trenes.lista[eleccion].ID);
remove(archivo);
remove(archivo2);
for(i=eleccion;i<trenes.num;i++)
trenes.lista[i] = trenes.lista[i+1]; // copio el tren i+1 en la i
trenes.num--;
printf("El tren de codigo %s ha sido borrado\n", codigo);
grabarArchivoTrenes(trenes);
imprimirTrenes();
}
else
{
printf("Eliminacion cancelada\n");
Pausa();
}
}
else // no existe esa estacion
printf("El codigo seleccionado (%s) no corresponde a ningun tren.\n", codigo);
Pausa();
}
/**-------------------------------------------------------------
| Funcion: eliminarUnTramo |
---------------------------------------------------------------
| Descripción: elimina un tramo de la lista |
| |
| Entradas: los datos se leen del archivo |
| Retorno: nada |
--------------------------------------------------------------*/
void eliminarUnTramo(Tren tren)
{
FILE *ptr;
int i,i1, est1, est2,encontrado1,encontrado, duracionMin, duracionHor,np,var1,duracionTren;
char cadena[10];
char archivo[50];
int eleccion;
char opcion;
L_Tramos tramos;
L_Estaciones estaciones;
// Compruebo existencia de archivo y nº de registros
sprintf(archivo, "../BaseDatos/Rutas/%s.ruta", tren);
tramos.num = NumRegArchivoBin(archivo, sizeof(TipoTramo));
if(!tramos.num){
printf( "La lista de tramos esta vacia. \n");
Pausa();
return;
}
// hay paradass registradas
system("cls");
cabeceraTabla("Eliminar un tramo");
abrirArchivoRutas(&tramos,tren);
mostrarTramo(tren);
printf("Asociacion de nombre con su ID:\n");
abrirArchivoEstacionesSinNumero(&estaciones);
for (np=0; np < tramos.num; np++) {
var1 = comprobarNombre(tramos.lista[np].IDorigen);
printf("\t%d. %s - (%s%)\n", np, estaciones.lista[var1].nombre,tramos.lista[np].IDorigen);
}
printf("\nEscriba la ID de la estacion de origen del tramo que quiere eliminar: ");
gets(cadena);
i= 0;
encontrado = 0;
while(i<tramos.num && !encontrado)
{
if( strcmp(tramos.lista[i].IDorigen, cadena) == 0) // si el codigo de la estacion coincide
{
encontrado = 1; // hemos encontrado la estacion a borrar
}
else i++;
}
if(encontrado)
{
eleccion = i;
printf("Ha seleccionado el siguiente tramo:\n");
comienzoTabla();
mostrarUnTramo(tramos.lista[eleccion]);
finTabla();
opcion = leerSiNo("Desea eliminarlo (S/N)?");
if(opcion == 'S')
{
// Recalculamos IDdestino de la anterior ID, la hora..precio..duracion..distancia..
tramos.lista[i-1].fin.horas = tramos.lista[i].fin.horas;
tramos.lista[i-1].fin.minutos = tramos.lista[i].fin.minutos;
strcpy(tramos.lista[i-1].IDdestino, tramos.lista[i+1].IDorigen);
// Calculamos la duracion del tramo
if(tramos.lista[i-1].inicio.minutos > tramos.lista[i-1].fin.minutos)
{
duracionHor = (((tramos.lista[i-1].fin.horas) - (tramos.lista[i-1].inicio.horas))-1)*60;
duracionMin = ((60-tramos.lista[i-1].inicio.minutos)+tramos.lista[i-1].fin.minutos);
}
else
{
duracionHor = (tramos.lista[i-1].fin.horas - tramos.lista[i-1].inicio.horas)*60; // En minutos
duracionMin = tramos.lista[i-1].fin.minutos - tramos.lista[i-1].inicio.minutos;
if(duracionMin<0) duracionMin = -(duracionMin); // Cambiamos el signo si fuera negativo
if(duracionHor<0) duracionHor = -(duracionHor);
}
tramos.lista[i-1].duracion = duracionMin + duracionHor;
// Calculamos la duracion
if(tren.salida.minutos > tren.llegada.minutos)
{
duracionHor = (((tren.llegada.horas) - (tren.salida.horas))-1)*60;
duracionMin = ((60-tren.salida.minutos)+tren.llegada.minutos);
}
else
{
duracionHor = (tren.llegada.horas - tren.salida.horas)*60; // En minutos
duracionMin = tren.llegada.minutos - tren.salida.minutos;
if(duracionMin<0) duracionMin = -(duracionMin); // Cambiamos el signo si fuera negativo
if(duracionHor<0) duracionHor = -(duracionHor);
}
duracionTren = duracionMin + duracionHor;
//Recalculamos el precio
tramos.lista[i-1].precio = ((tramos.lista[i-1].duracion) * (tren.precio/duracionTren));
// Calculamos la distancia, abriendo las estaciones
abrirArchivoEstaciones(&estaciones);
// aqui buscamos la estacion que corresponde con la ID
encontrado1=0;
i1=0;
while(i1<estaciones.num && !encontrado1)
{
if(strcmp(estaciones.lista[i1].ID, tramos.lista[i-1].IDorigen)==0) encontrado1=1; //encontro
else i1++;
}
est1 = i1; //copiamos
i1=0;
encontrado1=0;
while(i1<estaciones.num && !encontrado1)
{
if(strcmp(estaciones.lista[i1].ID, tramos.lista[i-1].IDdestino)==0) encontrado1=1;
else i1++;
}
est2 = i1;
tramos.lista[i-1].distancia = distanciaGeodesica(estaciones.lista[est1].pos, estaciones.lista[est2].pos);
for(i=eleccion;i<tramos.num;i++)
tramos.lista[i] = tramos.lista[i+1]; // copio el tramo i+1 en la i
tramos.num--;
printf("El tramo ha sido borrado\n"); Pausa();
ptr = fopen(archivo, "wb");
fwrite((TipoTramo*)tramos.lista, sizeof(TipoTramo), tramos.num, ptr);
fclose(ptr);
imprimirTramos(tren);
}
else
{
printf("Eliminacion cancelada\n");
Pausa();
}
}
else // no existe esa estacion
printf("El codigo seleccionado (%s) no corresponde a ningun tramo.\n", cadena);
Pausa();
}
// ---------------------------------------------------------------------------
// Permite a modificacao dos atributos
void
CMaterialMeioPorosoAmostra::Modificar ()
{
// cout<<"\n\tVai modificar atributos da classe base do CMaterialMeioPorosoAmostra";
TMaterial::Modificar (); // modificacao do objeto material meio poroso
// As modificacoes dos objetos estaticos ja foram realizadas atraves da funcao f_entrada destes objetos.
// Verificar se nao agride a uniformidade, do sistema de entrada, alteracao e saida de dados.
cout << "\n\tEntre os novos atributos do CMaterialMeioPorosoAmostra:";
Pausa ();
// cout<<"\n\tdimensao_x=";
// cin>>dimensao_x;
// cout<<"\tdimensao_y=";
// cin>>dimensao_y;
// cout<<"\tdimensao_z=";
// cin>>dimensao_z;
cout << "\tmassa_saturada=";
cin >> massa_saturada;
cout << "\tmassa_seca=";
cin >> massa_seca;
cout << "\tvolume=";
cin >> volume;
cout << "\tEntre com a umidade=";
cin >> umidade;
cout << "\tconteudo_ol =";
cin >> conteudo_ol;
cout << "\tconteudo_wl =";
cin >> conteudo_wl;
cout << "\tconcentracao_vapor:";
cin >> concentracao_vapor;
cout << "\tdifusividade dtv=";
cin >> dtv;
cout << "\tdifusividade dtl=";
cin >> dtl;
cout << "\tdifusividade dolv=";
cin >> dolv;
cout << "\tdifusividade doll=";
cin >> doll;
cout << "\tfator_experimental=";
cin >> fator_experimental;
cout << "\ttempertura_ensaio adsorcao/dessorcao=";
cin >> temperatura_ensaio_adsorcao;
Pausa ();
cout << "\n\tDeseja modificar polinomios para condutividade, adsorcao,"
<<
"\n\tdessorcao, difusividade, derivada_h_teta e fator experimental(s/n)?:";
cin.get (resp); // =getche();
cin.get ();
if (resp == 's' || resp == 'S')
{
cout << "\n\tPolinomio para condutividade";
// erro cin>>&p_k;
cout << "\n\tPolinomio para adsorcao";
// erro cin>>&p_ads;
cout << "\n\tPolinomio para dessorcao(s/n)?:";
// erro cin>>&p_des;
cout << "\n\tPolinomio para difusividade(s/n)?:";
// erro cin>>&p_dif_termica;
cout << "\n\tPolinomio para derivada_h_teta curva adsorcao(s/n)?:";
// erro cin>>&p_der;
cout << "\n\tPolinomio para fator experimental(s/n)?:";
// erro cin>>&p_fe;
cin.get ();
}
}
/**-------------------------------------------------------------
| Funcion: muestraEstacionesCercanas |
---------------------------------------------------------------
| Descripción: Abre el archivo binario de estaciones y lo carga|
| en memoria en la dirección pasada como parámetro|
| |
| Entradas: registro TipoGrafo e ID de origen del nodo |
| Retorno: nada |
--------------------------------------------------------------*/
void muestraEstacionesCercanas(TipoGrafo grafo, int ID_origen)
{
int z,numArcos,n,encontrado,i,numEst;
int tramosTotales = 1; // Va a ver un tramo por lo menos, es util inicializarlo a 1 para que luego empiece a contar desde 1 y no 0 para que compare con los anteriores...
int *vector;
int nomEst,nomEst1;
int min,minN;
char archivo[50];
FILE *ptr;
L_Estaciones estaciones;
sprintf(archivo, "../PlanViaje/Destinos/%d.destinos", ID_origen);
// Abrimos el archivo
ptr = fopen(archivo, "w");
//Llamos numEst al IDorigen
numEst=ID_origen;
//Calculamos los arcos que salen de ese nodo
numArcos = grafo.nodos.nodo[numEst].arcos.numArcos;
// Vamos a contar UNICAMENTE cuantos tramos salen de ese nodo (tramos UNICOS.. no numArcos)
for(n=1; n<numArcos; n++)
{
encontrado = 0;
i = 1;
while(i<=n && !encontrado)
{
// En el caso de que ese nodo ya hubiera sido analizado, se compara con los anteriores para ver si son el mismo
if(grafo.nodos.nodo[numEst].arcos.arco[n].dest == grafo.nodos.nodo[numEst].arcos.arco[n-i].dest) encontrado = 1;
else i++;
}
if(encontrado == 0) tramosTotales++; // Si es la primera vez que "ve" el nodo, suma 1 a los tramos totales UNICOS del nodo
}
// Creamos un vector de tamaño los tramos totales que salen del nodo ID_origen
vector = calloc(sizeof(vector), tramosTotales);
// El primer elemento del vector, es el primer elemento de la lista --> 0
// Hacemos esto porque la lista comienza en el 1, y hay que tener en cuenta el 0 también
vector[0] = 0;
// Comenzamos a contar en vector[1]
z = 1;
// Vamos a copiar en el vector, los nodos que nos interesan
for(n=1; n<numArcos; n++)
{
encontrado = 0;
i = 1;
while(i<=n && !encontrado)
{
// Si el destino de ese arco es igual a otro cualquiera, ese destino no cuenta como destino UNICO
if(grafo.nodos.nodo[numEst].arcos.arco[n].dest == grafo.nodos.nodo[numEst].arcos.arco[n-i].dest) encontrado = 1;
else i++;
}
if(encontrado == 0) // No lo ha encontrado
{
vector[z] = n; // Copiamos n en cada elemento del vector
z++;
}
}
// Imprimimos con cuantas estanciones esta conectado el nodo
fprintf(ptr, "%s %s %s %d %s", "La estacion", grafo.nodos.nodo[numEst].estacion.nombre, "esta conectado con",tramosTotales,"estaciones");
// Abrimos el archivo de estaciones para mostrar el nombre de las estaciones a partir de ahora
abrirArchivoEstacionesSinNumero(&estaciones);
for(i=0; i<tramosTotales;i++)
{
// Comprobamos el nombre con una funcion auxiliar creada en el prototipo 1
nomEst = comprobarNombre(grafo.nodos.nodo[numEst].arcos.arco[vector[i]].tramo.IDdestino);
// Imprimimos el nombre de la estacion
fprintf(ptr, "\n\n%s %s\n", "Estacion: ", estaciones.lista[nomEst].nombre);
min = grafo.nodos.nodo[numEst].arcos.arco[vector[i]].tramo.duracion; // Suponemos como 'min' la duracion del tramo de vector[i]
minN = vector[i];
for(n=0; n<numArcos; n++)
{
if(grafo.nodos.nodo[numEst].arcos.arco[vector[i]].dest == grafo.nodos.nodo[numEst].arcos.arco[n].dest)
{
// Imprimos la informacion del tramo
// Hay que mencionar que ya hay una funcion mostrarTramo, pero nos muestra la ID no el nombre, por eso creo esto.
nomEst1 = comprobarNombre(grafo.nodos.nodo[numEst].estacion.ID); // Comprobamos el nombre a partir del ID con una funcion auxiliar
fprintf(ptr, " %s %s %s %02d:%02d %02d:%02d %.2f\n", grafo.nodos.nodo[numEst].arcos.arco[n].tramo.ID, estaciones.lista[nomEst1].nombre,estaciones.lista[nomEst].nombre,
grafo.nodos.nodo[numEst].arcos.arco[n].tramo.inicio.horas,grafo.nodos.nodo[numEst].arcos.arco[n].tramo.inicio.minutos,
grafo.nodos.nodo[numEst].arcos.arco[n].tramo.fin.horas,grafo.nodos.nodo[numEst].arcos.arco[n].tramo.fin.minutos,
grafo.nodos.nodo[numEst].arcos.arco[n].tramo.precio);
// Comprobamos cual es la duracion mínimam, comparando cada duracion con el minimo
if(grafo.nodos.nodo[numEst].arcos.arco[n].tramo.duracion < min)
{
min = grafo.nodos.nodo[numEst].arcos.arco[n].tramo.duracion;
minN = n;
}
}
}
// Imprimimos por ultimo la distancia minima, informando a qué tren corresponde
fprintf(ptr, "\n%s%s%s %d %s\n", "El tren mas rapido (",grafo.nodos.nodo[numEst].arcos.arco[minN].tramo.ID,") dura",min,"minutos");
}
fclose(ptr); // Cerramos el archivo .destino
printf("\n\nArchivo creado con exito\n");
Pausa();
getchar();
}
/**-------------------------------------------------------------
| Funcion: imprimirTodosTramos |
---------------------------------------------------------------
| Descripción: Imprime todos los tramos en tramos.lista |
| |
| Entradas: nada |
| Retorno: nada |
--------------------------------------------------------------*/
void imprimirTodosTramos()
{
FILE *ptr;
FILE *ptr1;
L_Estaciones estaciones;
int encontrado = 0;
int np,i;
char separa[] = " ------------------------------------------------------------------------------------------------------------------ \n";
char linea[255];
int var1,var2;
L_Trenes Trenes;
L_Tramos Tramos;
char archivo[50];
abrirArchivoEstacionesSinNumero(&estaciones);
abrirArchivoTrenesSinNumero(&Trenes);
// abro archivo de texto para escritura
ptr = fopen("../BaseDatos/tramos.lista", "w");
fputs(separa, ptr);
sprintf(linea, FMT_TRAMOX, ' ', "ID", "Origen", "Destino", "Inicio",
"Fin", "Duracion", "Distancia", "Precio", ' ');
fputs(linea, ptr);
fputs(separa, ptr);
for(i=0;i<Trenes.num;i++)
{
sprintf(archivo, "../BaseDatos/Rutas/%s.ruta", Trenes.lista[i].ID);
Tramos.num = NumRegArchivoBin(archivo, sizeof(TipoTramo));
ptr1 = fopen(archivo, "rb");
// Creamos un vector de Tramos->num registros de tipo Tramos
Tramos.lista = (TipoTramo*) calloc(sizeof(TipoTramo), Tramos.num);
if(Tramos.lista == NULL) {
printf("No hay memoria suficiente para la lista de tramos.\n");
Pausa();
exit(0);
}
fread((TipoTramo*)Tramos.lista, sizeof(TipoTramo), Tramos.num, ptr1);
for (np=0; np < Tramos.num; np++) {
var1 = comprobarNombre(Tramos.lista[np].IDorigen);
var2 = comprobarNombre(Tramos.lista[np].IDdestino);
fprintf(ptr, FMT_TRAMO, ' ', Tramos.lista[np].ID,
estaciones.lista[var1].nombre,
estaciones.lista[var2].nombre,
Tramos.lista[np].inicio.horas,
Tramos.lista[np].inicio.minutos,
Tramos.lista[np].fin.horas,
Tramos.lista[np].fin.minutos,
Tramos.lista[np].duracion,
Tramos.lista[np].distancia,
Tramos.lista[np].precio, ' ');
fwrite((TipoTramo*)Tramos.lista, sizeof(TipoTramo), Tramos.num, ptr1);
}
}
Pausa();
fclose(ptr1);
fclose(ptr);
}