Simulación de ascensor
El código fuente del programa es el siguiente:
(Nota: compilado con C Builder 6.0)
// -
# include ltvcl.h gt
# incluir ltSyncObjs.hpp gt
# incluir ltiostream gt
# incluir ltstring gt
# incluir ltvector gt
#Pragma hdrstop
Usar espacio de nombres estándar
int num_piso, num_ascensor, capacidad_ascensor, tiempo_piso, tiempo_parada
TCriticalSection * lock = NULL
Solicitud de estructura
{
Nombre de cadena;
int de
int a;
Sala de ascensor;
TRequest(const string amp; name1, int from1, int to1):
Nombre (name1), from (from1), to (to1)
{
Elevador=-1;
}
};
Vector lt vector ltTRequest gt gt Arriba, abajo, fuera;
Clase TV;
Vector lt TV * gt ascensor
int select_elevator(const TRequest amp; req, int excluir _ ascensor =- 1);
void select_elevator_all()
{
int i, j;
for(I = 0 ;iltup.size ();i)
for(j = 0;j ltup[i].size();j)
{
arriba[i][ j]. ascensor = seleccionar _ ascensor(arriba[I][j]);
}
for(I = 0; i ltdown . size(); i )
for(j = 0;j lt abajo[i].size();j)
{
abajo[i][j].
ascensor = seleccionar _ ascensor(abajo[I][j]);
}
}
// -
TV- me gusta: hilo público
{
Público:
int persona _ num
int id
int cur _ piso
int run_time
int status; //0 - detener, 1 - arriba, 2 - detener arriba, 3 - bajar, 4 - detener abajo;
Boolean full()
{
Número de personas devuelto == capacidad del ascensor;
}
bool tiene (vector constante) ltTRequest gt amp five)
{
for(int I = 0; i lt(int)v . size(); i )
if (v [ i].
ascensor == id)
devuelve verdadero
devuelve falso
}
bool tiene _ arriba _ solicitudes (int cur _ piso)
{
for(int I = cur _ piso; I lt=número de piso; i)
{
If (! full() amp; amphas(arriba[i])
return true
if (i!= cur _ floor ampamp(!full() amp; amphas(abajo[i] ] ]) || tiene(fuera[i]))
{
devuelve verdadero
}
}
Devuelve falso
}
bool tiene _ down _ solicitudes (int cur _ floor)
{
for(int I = cur_floor; i gt = 1; i-)
{
if (!full() amp; amp have(down[i])
devuelve verdadero
if (i! = cur _ floor amp amp(!full() amp; amphas(up[i]) || has(out[i]))
{
Devuelve verdadero
}
}
Devuelve falso
}
bool has_stop_requests(int cur_floor, int status)
{
if(status == 1 amp; amp! full() amp; amp ha estado (en el piso[abajo])
| estado = = 3 amperios completo() amphas(abajo[cur_floor])
Devuelve verdadero
si (tiene(fuera[cur_floor] ])
devuelve verdadero
devuelve falso
}
void process_list(vector ltTRequest gt amp ampaction de cadena constante, bool inc_other = false )
{
Vector ltTRequest gtvtmp
for(int I = 0; i lt(int)v . size(); i )
{
if (inc_other || v[i].elevator==id)
{
if (acción == "en")
{
Si (! Completo())
{
cout lt lt《Ascensor》 lt ltid lt lt":" lt ltv[i]. Nombre lt lt" " " lt ltAction lt ltendl
v[i]. Ascensor = id
Fuera, fuera. A].
push_back(v[I]);
persona_num;
}
Otro
{
vtmp . push _ back(v[I]);
}
}
Otros
{
cout lt lt《Ascensor》 lt ltid lt lt":" lt ltv[i]. namelt lt" " " lt ltactionlt ltendl
person_num-;
}
}
Otro
{
vtmp . push _ back(v[I]);
}
}
v = vtmp
}
Solicitudes de proceso no válidas(int cur_floor, int status)
{
if(status == 2 amp; ampup[cur_floor ].size() )
{
lista_proceso(arriba[cur_floor], " en ", verdadero
}
if(status ==); 4 amperios abajo[cur_floor].
tamaño())
{
process_list(abajo[cur_floor], " en ", verdadero); out[cur_floor], " out ");
seleccione _ ascensor _ todo();
}
Virtual void __fastcall Ejecutar(void)
{
Bloqueo - gt; get();
cout lt lt《Elevator》 lt ltid lt lt": Empezar desde el piso" lt ltcur _ floor lt ltendl
for(;;)
{
Bloquear - gt;Release();
Dormir(10);
bloqueo - gt;get();
run_time;
cambiar(estado)
{
Caso 0 :/ /stop
{
run_time = 0;
break;
}
Caso 1: // arriba
{
if(run_time gt;=tiempo de piso)
{
run_time = 0
cout lt lt《Ascensor》 lt ltid lt lt": Piso de llegada" lt ltcur _ piso lt ltendl
}
Descanso;
}
Caso 2: //Parar hacia arriba
{
if(run_time gt; = tiempo de parada)
{
cout lt "Ascensor" lt lt lt ": Cierra la puerta" lt ltendl
process_requests (piso actual, estado);
run_time = 0;
status = 1;
}
Pausa;
}
Caso 3: //Abajo
{
if(run_time gt;=tiempo de piso)
{
run_time = 0
cur _ piso-;
cout lt lt《Ascensor》 lt ltid lt lt"：Llegó al piso" lt ltcur _ piso lt ltendl
}
Pausa;
}
Caso 4: //Detener
{
if(run_time gt;=stop tiempo)
{
cout lt lt《Elevator》 lt ltid lt lt"：Cierra la puerta" lt ltendl
process_requests(piso actual, estado);
run_time = 0;
status = 3;
}
Pausa;
}
}
if (run_time! = 0)
{
if(status == 2 ||status == 4)
process_requests(piso actual, estado
);
Continuar;
}
for(;;)
{
bool tiene _ arriba = has_up_requests(cur_floor);
bool has_down = has_down_requests(cur_floor);
if(has_up amp; amp status == 0)
{
estado = 1;
}
else if(has_down amp; amp status= = 0)
{
Estado = 3;
}
bool tiene _ parada = tiene _ parada _ solicitudes(cur _ piso, estado);
if (has_stop amp amp( status == 1 ||status == 3))
{
status;
cout lt lt《Elevator》 lt ltid lt lt"：Abre el puerta" lt ltendl
process_requests(piso actual, estado);
}
if(!Haas up amp amp!Tiene down amp amp((estado 2 ) != 0))
{
estado = 0;
}
else if(! Hay un estado de amplificador inactivo == 3)
{
Estado = 1;
}
else if(!Haas up amp amp estado == 1 )
{
status = 3;
}
if (has_stop_requests(cur_floor, status))
Continuar;
Romper;
}
}
//lock- gt();
}
televa tor(int id 1): id(id 1), TThread(true)
{
FreeOnTerminate = true
persona_num = 0;
cur_piso = 1;
tiempo de ejecución = 0
Estado = 0; parada, 1 - arriba, 2 - parada arriba, 3 - abajo, 4 - parada abajo
}
__fastcall ~TElevator()
{
Bloquear-gt; get();
cout lt lt"El ascensor termina..." lt ltendl
Bloquear->liberar();
}
};
int select_elevator(const TRequest & request, int exclusion_elevator)
{
int ascensor=- 1;
int min _ peso =-1;
for(int I = 1; I lt = número de ascensores; i )
{
int target _ piso = req.from
bool arriba
_ dirección =(req . de lt; req. a);
TElevator *p = ascensor [I]
bool ascensor _ arriba =(p- gt; estado = = 1 | p->;estado == 2 | estado = = 4 | ascensor_floor = p->cur _ piso
bool need_up =(elevator_floorlttarget_floor);
int peso;
if(I = = excluir _ ascensor | | p- gt; complete())
{
peso = 4 * piso _ num
}
else if(ascensor piso== piso objetivo amp ascensor_parada)
{
Peso=-número de pisos;
}
else if(p- gt; status == 0)
{
Peso = abs(elevator_floor-target_floor)-floor_number;
}
else if(elevator_floor==target_floor)
{
if(elevator_descending)
{
Peso=Elevator_FloorTarget_Floor-2;
}
Otros
{
Peso = 2 *Cantidad_piso-( Elevator_FloorTarget_Floor);
}
}
Otros
{
if(need_up&elevator_up||!need_up&elevator_down)
{
peso = abs(elevator_floor-target_floor) ;
}
Otros
{
Si (need_start)
{
Peso=Elevator_FloorTarget_Floor-2;
}
Otro
{
Peso = 2 * Cantidad de piso-(Elevator_FloorTarget_Floor);
}
}
Si (need_up! = dirección ascendente)
{
if (dirección ascendente)
{
Peso = 2 *(objetivo _ piso-1) ;
}
Otros
{
Peso = 2*(floor_quantity-target_floor);
}
}
}
if(ascensor == -1 || peso lt peso mínimo)
{
Ascensor = I;
min_weight = peso;
}
}
Regreso ascensor
}
#pragma argsused
int main(int argc, char* argv[])
{
int
I;
lock = new TCriticalSection
cout lt lt"Input floor_elevator number_elevator number_passenger load floor_time stop_time:";
CIN gt; de ascensores gt gt capacidad del ascensor gt gt piso _ tiempo gt gt stop_time
char buf[80]
cin.getline( buf, sizeof(buf));
arriba .resize(piso _ num 1);
abajo .resize(piso _ num 1);
fuera . p>
Ascensor. resize(ascensor número 1);
for(I = 1; i lt=número de ascensores; i)
{
Ascensor[i] = nuevo ascensor(I);
Ascensor[I]- gt; resume();
}
p>dormir(100) );
int x = 0, y = 0;
lock - gt; get();
cout lt lt Cambiar nombre de entrada a: " lt ltendl
for(;;)
{
Nombre de cadena;
Bloqueo - gt;Release();
Sueño(20);
CIN gt; gtNamegt gtx gt gty;
Bloquear - gt;Get()
//char buf; [80];
//cin.getline(buf, sizeof(buf));
if (x == y)
Continuar;
if(x lt; 1 | | x gt; número de piso)
Continuar
if(y lt ; 1 | >
req . ascensor = seleccione _ ascensor(req);
if(x lt; y)
push _ back(req
p>Otro
<); p>push_back(req);}
//lock- gt; release() ;
//Return 0;
}
// -