Question

Hello, please solve this problem for object oriented programming in C++ program language. I have final tomorrow so it will be very helpful. thank you.

PROBLEM 1: application that simulates the highway Create an In order to solve above mentioned requirements, it is necessary to implement several classes: 1. Class Vehicle contains information about the vehicles that drive on the highway. Each vehicle has information about its a Type (can be one of these: Motorcycle, Car, Truck) b. License number (string) c. Maximum speed (in m/s) d Current speed (in m/s) For each type of the vehicle create child class. Maximum speed of a motorcycle ts 8 m's, of a car is 7 m/s and of a truck is 4 m/s. A constructor of each subclass only takes one parameter (a license plate number). Provide two methods that accelerate and decelerate a vehicle. Each call to the method will change motorcycle's speed by 2 m/s, car's speed by 2 m's and truck's speed by 1 m/s Minimum speed is 0 m/s. Vehicles cannot drive in reverse on the highway. Use virtual methods to implement Create get and set methods if necessary. All member variables must be private or protected 2. Class Track models a track where the vehicles can drive on This is a simple class containing following member variables: a. Direction (can be either North or South-use enumerator for this) b. MotorcyclesOnly (true if only motorcycles can drive on it, false otherwise) Constructor should initialize both variables. Add copy constructor. Add get/set methods if when needed. 3. Class Highway contains information about it's tracks and the vehicles that are currently driving on the highway. Use vectors to hold pointers to Tracks and Vehicles. It is necessary to provide methods to add track to the highway, as well as the method to add a vehicle to the highway (keep in mind that only motorcycles can drive on motorcycle only tracks). When a vehicle enters the highway, it's speed in 3 m's. You might need to change the definition of Vehicle class to include Track pointer and current position on the Track Adding vehicles to the highway places them on the beginning of the track, facing track's direction. Vehicles cannot be added if there is another vehicle in the first 3 meters of the track Method advanceTime) will advance time by one second, changing vehicles positions according to their current velocity. Method show) will print out first 30 meters of the highway, and the vehicles on its tracks (only vehicles that did not drive out of the 30 meter window), according to the format shown in the Figure 1. Page 1 of 1 d States)

Answer 1

Code:

#include <iostream>
#include <vector>
#include <iomanip>
#include <string>

using namespace std;

enum class Direction
{
   NORTH,
   SOUTH,
   EAST,
   WEST
};

class Track
{
public:
   Track(Direction direction, bool bmotorOnly) :m_direction(direction), m_bMotorcyclesOnly(bmotorOnly) {}
   Direction getTrackDirection() const
   {
       return m_direction;
   }
   bool isMotorCyclesOnlyTrack() const
   {
       return m_bMotorcyclesOnly;
   }
private:
   Direction m_direction;
   bool m_bMotorcyclesOnly;
};

class Vehicle
{
public:
   Vehicle(string licenseNumber):m_licenseNumber(licenseNumber){}
   virtual void accelerate() = 0;
   virtual void decelerate() = 0;
   virtual void calculateCurrPosition() = 0;
   void setTrack(Track* aTrack)
   {
       m_track = aTrack;
   }
   Track* getTrack()
   {
       return m_track;
   }
   double getCurPosition()
   {
       return m_curPosition;
   }
   void setCurPosition(double pos)
   {
       m_curPosition = pos;
   }
   void setCurSpeed(double curSpeed)
   {
       m_curSpeed = curSpeed;
   }
   string getType() const
   {
       return m_type;
   }
protected:
   string m_type;
   string m_licenseNumber;
   double m_maxSpeed;
   double m_curSpeed = 0.0;
   double m_curPosition = 0.0;
   Track* m_track;
};

class Car:public Vehicle
{
public:
   Car(string licenseNumber) :Vehicle(licenseNumber)
   {
       m_maxSpeed = 7.0;
       m_type = "C";
   }
   void accelerate() override
   {
       if (m_curSpeed < m_maxSpeed)
           m_curSpeed += 2;

       if (m_curSpeed > m_maxSpeed)
           m_curSpeed = m_maxSpeed;
   }

   void decelerate() override
   {
       if(m_curSpeed > 0)
           m_curSpeed -= 2;

       if (m_curSpeed < 0)
           m_curSpeed = 0;
   }

   void calculateCurrPosition() override
   {
       if (m_track->getTrackDirection() == Direction::EAST)
       {
           m_curPosition += m_curSpeed * 1;
       }
       else if (m_track->getTrackDirection() == Direction::WEST)
       {
           m_curPosition -= m_curSpeed * 1;
       }
   }

};

class Truck :public Vehicle
{
public:
   Truck(string licenseNumber) :Vehicle(licenseNumber)
   {
       m_maxSpeed = 4.0;
       m_type = "T";
   }
   void accelerate() override
   {
       if(m_curSpeed < m_maxSpeed)
           m_curSpeed += 1;

       if (m_curSpeed > m_maxSpeed)
           m_curSpeed = m_maxSpeed;
   }

   void decelerate() override
   {
       if (m_curSpeed > 0)
           m_curSpeed -= 1;

       if (m_curSpeed < 0)
           m_curSpeed = 0;
   }

   void calculateCurrPosition() override
   {
       if (m_track->getTrackDirection() == Direction::EAST)
       {
           m_curPosition += m_curSpeed * 1;
       }
       else if (m_track->getTrackDirection() == Direction::WEST)
       {
           m_curPosition -= m_curSpeed * 1;
       }
   }
};

class Motorcycle :public Vehicle
{
public:
   Motorcycle(string licenseNumber) :Vehicle(licenseNumber)
   {
       m_maxSpeed = 8.0;
       m_type = "M";
   }
   void accelerate() override
   {
       if (m_curSpeed < m_maxSpeed)
           m_curSpeed += 2;

       if (m_curSpeed > m_maxSpeed)
           m_curSpeed = m_maxSpeed;
   }

   void decelerate() override
   {
       if (m_curSpeed > 0)
           m_curSpeed -= 2;

       if (m_curSpeed < 0)
           m_curSpeed = 0;
   }

   void calculateCurrPosition() override
   {
       if (m_track->getTrackDirection() == Direction::EAST)
       {
           m_curPosition += m_curSpeed * 1;
       }
       else if (m_track->getTrackDirection() == Direction::WEST)
       {
           m_curPosition -= m_curSpeed * 1;
       }
   }
};

class Highway
{
public:
   void addVehicle(Vehicle* vehicle,Track* track)
   {
       //Do not add any other vehicle other than the Motocycle in Motorcycle only track
       if (track->isMotorCyclesOnlyTrack())
       {
           if (vehicle->getType() != "M")
               return;
       }
       vehicle->setCurSpeed(3);
       if (track->getTrackDirection() == Direction::EAST)
       {
           vehicle->setCurPosition(0);
           for (Vehicle* aVehicle : vVehicles)
           {
               //Safety check whether the vehicle belongs to the same track and the distance
               if (aVehicle->getTrack() == track && aVehicle->getCurPosition() <= 3)
                   return;
           }
       }
       else if (track->getTrackDirection() == Direction::WEST)
       {
           vehicle->setCurPosition(30);
           for (Vehicle* aVehicle : vVehicles)
           {
               if (aVehicle->getTrack() == track && aVehicle->getCurPosition() <= 27)
                   return;
           }
       }
       vehicle->setTrack(track);
       vVehicles.push_back(vehicle);
   }

   void addTrack(Track* track)
   {
       vTracks.push_back(track);
   }

   void show()
   {
       cout << "----------------------------------------------------------------";
       for (size_t i = 0; i < vTracks.size(); i++)
       {
           cout << "\n-----------------------------------------------------------------------";
           cout << "\n";
           cout << "\n";
           for (size_t j = 0; j < vVehicles.size(); j++)
           {
               if (vVehicles[j]->getTrack() == vTracks[i] &&
                   vVehicles[j]->getCurPosition() < 30)
               {
                   cout << setw(vVehicles[j]->getCurPosition()) << vVehicles[j]->getType();
               }
           }
           cout << "\n";
           cout << "\n";
           cout << "\n-----------------------------------------------------------------------";
       }
      
   }

   void advanceTime()
   {
       for (Vehicle*& aVehicle : vVehicles)
       {
           aVehicle->calculateCurrPosition();
       }
   }
private:
   vector<Track*> vTracks;
   vector<Vehicle*> vVehicles;
};

int main(int argc, char** argv)
{
   Highway testHighway;

   Track t1(Direction::EAST, false);
   Track t2(Direction::EAST, true);
   Track t3(Direction::WEST, false);

   testHighway.addTrack(&t1);
   testHighway.addTrack(&t2);
   testHighway.addTrack(&t3);

   Car c1("ABC-123");
   Truck tr1("REG-ABC");
   Motorcycle m1("MC-AI00");

   testHighway.addVehicle(&c1, &t1);
   testHighway.addVehicle(&tr1, &t3);
   testHighway.addVehicle(&m1, &t2);

   m1.accelerate();
   testHighway.advanceTime();
   c1.accelerate();
   c1.accelerate();
   testHighway.advanceTime();
   testHighway.advanceTime();
   testHighway.show();

   return 0;
}

OUTPUT:

Microsoft Visual Studio Debug Console C M