implementing a copy contructor for ADT queue

I did implement the copy constructor but still have a problem with
it. It is not working. What could be wrong?

#include "QueueP.h"
#include <cassert> // for assert
#include <new> // for bad_alloc
#include <iostream>
//typedef std::queue<QueueItemType> Queue;
using namespace std;
//private:{Queue::Queue(const Queue& Q)}

Queue::Queue() : backPtr(0), frontPtr(0)//copy constructor initializes
the data members
{
} // end default constructor

Queue::Queue(const Queue& Q) throw(OutOfStorageException)// because
the compiler-generated default constructorwould not necessarily
initialize data members to appropriate values, you must create your
own. pg 198
//:backPtr(const Queue& Q)
//:frontPtr (const Queue& Q)
if (Q.frontPtr == 0)
     frontPtr = 0; // original Queue is empty

      else
      { // copy first node
     try
     {
        frontPtr = new QueueNode;
        frontPtr->item = Q.frontPtr->item;

        // copy rest of Queue
        QueueNode *newPtr = frontPtr; // new Queue pointer
        // newPtr points to last node in new Queue
        // origPtr points to nodes in original Queue
        for (QueueNode *origPtr = Q.frontPtr->next;
         origPtr != 0;
         origPtr = origPtr->next)
        { newPtr->next = new QueueNode;
           newPtr = newPtr->next;
           newPtr->item = origPtr->item;
        } // end for

        newPtr->next = 0;
     } // end try
     catch (bad_alloc e)
     {
        throw OutOfStorageException(
           "OutOfStorageException: Cannot allocate memory in copy
constructor.");
     } // end catch
      } // end if
   } // 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