How can you implement a copy constructor for ADT queue

how do you implement a copy constructor for this pointer-based ADT
queue

#include <cassert> // for assert
#include <new> // for bad_alloc

using namespace std;
//private:{Queue::Queue(const Queue& Q)}

Queue::Queue() : backPtr(0), frontPtr(0)
{
} // end default constructor

Queue::Queue(const Queue& Q) throw(OutOfStorageException)
{

                           /////////// Implementation
here!!!!!!///////////////

} // end copy constructor

Queue::~Queue()
{
   while (!isEmpty() )
   {
      dequeue();
   } // end while
   assert ( (backPtr == 0) && (frontPtr == 0) );
} // end destructor

bool Queue::isEmpty() const
{
   return backPtr == 0;
} // end isEmpty

void Queue::enqueue(const QueueItemType& newItem)
   throw(OutOfStorageException)
{
   try
   {
      QueueNode *newPtr = new QueueNode;

      newPtr->item = newItem;

      newPtr->next = 0;

      if (isEmpty() )
      {
     frontPtr = newPtr;
      }
      else
      {
     backPtr->next = newPtr;
      } // end if

      backPtr = newPtr;
   }
   catch(bad_alloc e)
   {
      throw OutOfStorageException("Memory allocation failed.");
   } // end try/catch
} // end enqueue

void Queue::dequeue() throw(OutOfDataException)
{
   if (isEmpty() )
   {
      throw OutOfDataException("Empty queue, cannot dequeue");
   }
   else
   { // queue is not empty; remove front
      QueueNode *tempPtr = frontPtr;
      if (frontPtr == backPtr) // special case?
      { // yes, one node in queue
         frontPtr = 0;
         backPtr = 0;
      }
      else
      {
         frontPtr = frontPtr->next;
      } // end if
     tempPtr->next = 0; // defensive strategy
      delete tempPtr;
   } // end if
} // end dequeue

void Queue::dequeue(QueueItemType& queueFront)
   throw(OutOfDataException)
{
   if (isEmpty() )
   {
      throw OutOfDataException("Empty queue, cannot dequeue");
   }
   else
   { // queue is not empty; retrieve front
      queueFront = frontPtr->item;
      dequeue(); // delete front
   } // end if
} // end dequeue

void Queue::getFront(QueueItemType& queueFront) const
   throw(OutOfDataException)
{
   if (isEmpty() )
   {
      throw OutOfDataException("Empty queue, cannot getFront");
   }
   else
   {
      // queue is not empty; retrieve front
      queueFront = frontPtr->item;
   } // end if
} // end getFront