Результати виконання роботи

// clock.h

// Definition for class Clock.

#ifndef CLOCK_H

#define CLOCK_H

class Clock {

public:

Clock(); // constructor

~Clock(); // destructor

void tick(); //increment clock by second

int GetTime()const; //returns time

private:

int time; // clock's time

};

#endif // CLOCK_H

// clock.cpp

#include <iostream>

using namespace std;

#include "clock.h"

Clock::Clock() // constructor

: time( 0 ) { }

Clock::~Clock(){ }// destructor

void Clock::tick()// increment time by 1

{ time++; }

int Clock::GetTime()const//return time

{ return time; }

// elevator.h

// Definition for class Elevator

#ifndef ELEVATOR_H

#define ELEVATOR_H

#include "elevatorButton.h"

#include "door.h"

#include "bell.h"

//for using as parameters in functions

class Floor; // forward declaration

class Person; // forward declaration

class Elevator {

public:

Elevator( Floor &, Floor & );

Elevator(Elevator&);

~Elevator();

void SummonElevator( int );

void PrepareToLeave( bool );

void ProcessTime(int); //give time

//lab6: board a passenger

void PassengerEnters( Person* const );

void PassengerExits();

ElevatorButton elevatorButton;

private:

void ProcessPossibleArrival();

void ProcessPossibleDeparture();

void ArriveAtFloor( Floor & );

void Move();

bool moving; // elevator state

int direction; // current direction

int currentFloor; // current location

int arrivalTime; //arrive at a floor

Floor &floor1Ref;//reference to floor1

Floor &floor2Ref;//reference to floor2

Person *passengerPtr;

Door door;

Bell bell;

};

#endif // ELEVATOR_H

// elevator.cpp

// implementation of class Elevator

#include <iostream>

using namespace std;

#include "elevator.h"

#include "person.h"

#include "floor.h"

// constructor initialization

Elevator::Elevator( Floor &firstFloor, Floor &secondFloor):elevatorButton(*this)

, moving(false), direction(0)

, currentFloor(1), arrivalTime(0)

, floor1Ref(firstFloor)

, floor2Ref(secondFloor), passengerPtr(0)

{ cout << "elevator created" << endl; }

//copy constructor

Elevator::Elevator(Elevator& object)

: elevatorButton( object.elevatorButton)

, moving( object.moving)

, direction( object.direction)

, currentFloor( object.currentFloor)

, arrivalTime( object.arrivalTime)

, floor1Ref( object.floor1Ref)

, floor2Ref( object.floor2Ref)

, passengerPtr( object.passengerPtr)

{cout<<"copy elevator created"<<endl; }

Elevator::~Elevator() // destructor

{ cout << "elevator destroyed" << endl; }

// give time to elevator

void Elevator::ProcessTime(int time){}

//.....

//lab6: пасажир увійшов до ліфта

void Elevator::PassengerEnters(Person* const personPtr)

{ passengerPtr = personPtr;

cout<<"person "<<passengerPtr->GetID()

<< " enters elevator from floor "

<< currentFloor << endl;

}

//повідомлення ліфту про вихід пасажира

void Elevator::PassengerExits()

{ passengerPtr = 0; }

// floor.h

// Definition for class Floor.

#ifndef FLOOR_H

#define FLOOR_H

#include "floorButton.h"

#include "light.h"

#include "door.h"

class Elevator; // forward declaration

class Person; // forward declaration

class Floor {

public:

Floor( int, Elevator & );

~Floor();

//lab6: return true if floor occupied

bool IsOccupied()const;

//lab6: return floor's number

int GetNumber()const;

//lab6: new person coming on floor

void PersonArrives( Person* const);

//notify floor that elevator has arrived

Person *elevatorArrived();

//notify floor that elevator is leaving

void ElevatorLeaving();

//notify floor that person is leaving

void PersonBoardingElevator();

FloorButton floorButton;

private:

//lab6: the floor's number

const int floorNumber;

Elevator& elevatorRef;

Person* occupantPtr;

Light light;

};

#endif // FLOOR_H

// floor.cpp

// Implementation od class Floor

#include <iostream>

using namespace std;

#include "floor.h"

#include "person.h"

#include "elevator.h"

// constructor

Floor::Floor(int number, Elevator &elevatorHandle )

: floorButton( number, elevatorHandle ),

floorNumber( number ),

elevatorRef( elevatorHandle ),

occupantPtr ( 0 ),

light(floorNumber==1?"floor1":"floor2")

{ cout << "floor " << floorNumber << " created" << endl; }

// destructor

Floor::~Floor() {cout << "floor " << floorNumber << " destroyed" << endl; }

//lab6: determine if floor is occupied

bool Floor::IsOccupied() const

{ return ( occupantPtr != 0 ); }

//lab6: return this floor's number

int Floor::GetNumber()const

{ return floorNumber; }

//lab6: pass person to floor

void Floor::PersonArrives( Person* const personPtr )

{ occupantPtr = personPtr;}

// notify floor that elevator has arrived

Person *Floor::elevatorArrived()

{ return occupantPtr;}

// tell floor that elevator is leaving

void Floor::ElevatorLeaving() { }

//. . . . . . . . . . . . . . . .

// person.h

// definition of class Person

#ifndef PERSON_H

#define PERSON_H

#include<string>

using namespace std;

class Floor; // forward declaration

class Elevator; // forward declaration

class Person {

public:

Person();

Person( const int );//lab6: constructor

~Person(); // destructor

Person( Person& ); //copy constructor

Person( string tabnumber);

int GetID() const;//lab6: returns ID

void StepOntoFloor( Floor & );

void EnterElevator(Elevator&, Floor&);

void exitElevator(const Floor&, Elevator&) const; //lab6:

private:

int personCount;//person’s number

const int ID; //lab6: person's ID #

const int destinationFloor;

};

#endif // PERSON_H

/* person.cpp – подані тільки реалізації константних методів і тих, які використовують константні члени класу */

#include <iostream>

#include<string>

using namespace std;

#include "person.h"

#include "floor.h"

#include "elevator.h"

/*lab6: default constructor – присвоєння константним членам значень в тілі конструктора заборонено */

Person::Person():ID(0),destinationFloor(0)

{ personCount=0;

cout<<"default initialization of man take place - void object created"<<endl; }

// constructor-initialization

Person::Person( int destFloor )

: ID(++personCount), personCount(0)

, destinationFloor(destFloor)

{cout<<"person "<<ID<<" created on floor "<<destinationFloor<<endl;}

//lab6:copy constructor – ініціалізація

//тільки списком

Person::Person(Person& man )

:ID(man.ID)

, destinationFloor(man.destinationFloor)

{ personCount=man.personCount;

cout<<"person (man) "<<ID<<" created on floor "<<destinationFloor<<" again"; }

//lab6:constructor transformation

Person::Person( string tabnumber )

:ID(tabnumber[0])

,destinationFloor(tabnumber[1])

{ string str2 = tabnumber.substr(2,1);

const char* s2=str2.c_str();

personCount=atoi(s2);

cout<<"constructor transformation"<<endl;

cout<<"person "<<ID<<" created on floor "<<destinationFloor<<" count="<< personCount<<endl; }

//lab6: метод-аксесор

int Person::GetID() const

{ return ID; } // get the ID

//lab6: person exits elevator

void Person::exitElevator(const Floor &floor, Elevator &elevator) const

{ cout<<"person "<<ID<<" exits elevator on floor " <<floor.GetNumber()<<endl;

elevator.PassengerExits();

}