洗车队列问题

我正在研究"汽车队列"或"洗车"问题的变体，其中我必须输入汽车洗车需要多长时间，汽车在任何给定时刻进入队列进行洗车的几率，然后接收作为输出，一天结束时有多少汽车被洗过，队列中还剩下多少辆汽车， 以及总等待时间是多少。我对 c++ 仍然很陌生，最近几个月才广泛使用它。我的队列实现代码很可能有一个我没有发现的错误，但我相信错误是主要的。目前，我为每个循环添加了输出，因此我可以观察代码运行并遵循它。它似乎在接受一辆汽车，然后立即完成对它的清洗。然后，当没有汽车在场时，它只是在洗涤和等待循环之间交替。任何帮助将不胜感激。

#include <assert>
#include <iostream>
#include <fstream>
#include <ostream>
#include <ctime>
#include <cstdlib>
using namespace std;
class Node
  {
    private:
     int item;
Node * next;
public:
    Node ();
    Node (const int& anItem);
    Node (const int& anItem, Node * nextNodePtr);
    void setItem (const int& anItem);
    void setNext (Node * nextNodePtr);
    int getItem ();
    Node* getNext();
   };
class LinkedQueue 
  { 
    private:  
       Node* backPtr; 
       Node* frontPtr; 
    public: 
       bool isEmpty(); 
       bool enqueue(int& newEntry); 
       bool dequeue(); 
       int peekFront() const;
       LinkedQueue();
       ~LinkedQueue();
       LinkedQueue(const LinkedQueue& aQueue); 
   };
int main ()
{   
    srand(1);
    int timeForWash;
    int minute;
    int timeEnteredQueue;
    int carsWashed;
    int totalQueueMin;
    int timeLeftOnCar;
    int probOfArrival;
    int carsInQueue = 0;
    LinkedQueue carQueue;
    cout << "Enter time to wash one car:" << endl;
    cin >> timeForWash;
    cout << endl;
    cout << "Enter probability of arrival per minute" << endl;
    cin >> probOfArrival;
    carsWashed = 0;
    totalQueueMin = 0;
    timeLeftOnCar = 0;
    for (minute = 1; minute <= 20; ++minute)
    {
        if (rand()%100 <= probOfArrival)
            {
                carQueue.enqueue(minute);
                carsInQueue++;
                cout << "Queued" << endl;
            }
        if ((timeLeftOnCar == 0) && ( !carQueue.isEmpty()))
        {
            timeEnteredQueue = carQueue.peekFront();
            carQueue.dequeue();
            totalQueueMin = totalQueueMin + (minute - timeEnteredQueue);
            ++carsWashed;
            carsInQueue--;
            timeLeftOnCar = timeForWash;
            cout << "Finish" << endl;
            }
            if (timeLeftOnCar =! 0)
            {
                timeLeftOnCar -= 1;
                cout << "Washing" << endl;
            }
        if ((timeLeftOnCar == 0) && ( carQueue.isEmpty()))
        {
            cout << "Waiting" << endl;
        }
    }
    cout << carsWashed << endl;
    cout << totalQueueMin << endl;
    cout << carsInQueue << endl;
    system("pause");
    return(0);
  };
//Implementation
Node:: Node() : next (nullptr)
{
} // default
Node:: Node (const int& anItem) : item(anItem), next(nullptr)
{
}
Node:: Node (const int& anItem, Node * nextNodePtr) : item(anItem), next(nextNodePtr)
{
}
void Node:: setItem (const int& anItem)
{
    item = anItem;
}
void Node:: setNext (Node * nextNodePtr)
{
    next = nextNodePtr;
}
int Node:: getItem ()
{
    return item;
}
Node * Node:: getNext ()
{
    return next;
}
bool LinkedQueue::enqueue(int& newEntry) 
    { 
     Node* newNodePtr = new Node(newEntry); 
     //Insert the new node 
     if (isEmpty()) 
     frontPtr = newNodePtr; // The queue was empty 
     else
     backPtr->setNext(newNodePtr); // The queue was not empty 
     backPtr = newNodePtr; // New node is at back 
     return true; 
} // end enqueue
bool LinkedQueue::dequeue() 
{ 
    bool result = false; 
    if (!isEmpty()) 
     { 
     // Queue is not empty; remove front 
     Node* nodeToDeletePtr = frontPtr; 
     if (frontPtr == backPtr) 
     { // Special case: one node in queue 
     frontPtr = nullptr; 
     backPtr = nullptr; 
     } 
     else
     frontPtr = frontPtr->getNext(); 
     // Return deleted node to system 
     nodeToDeletePtr->setNext( nullptr); 
     delete nodeToDeletePtr; 
     nodeToDeletePtr = nullptr; 
     result = true; 
     } // end if 
     return result; 
} // end dequeue
bool LinkedQueue:: isEmpty()
{
    return (frontPtr == nullptr );
}
int LinkedQueue:: peekFront() const
{
    return frontPtr->getItem();
} 
LinkedQueue::LinkedQueue() 
{
    frontPtr = nullptr;
    backPtr = nullptr;
} 
LinkedQueue::LinkedQueue( const LinkedQueue& aQueue) : 
frontPtr(aQueue.frontPtr) 
{ 
} // end copy constructor  
LinkedQueue::~LinkedQueue() 
{ 
} // end destructor