help! how to implement a copy constructor in c++ for ADT queues??

[ecestd1]

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

#include "Queuep.h"
#include <cassert>
#include <new>
 using namespace std;

Queue::Queue () : backPtr (0), frontPtr(0)
{
}

Queue::Queue(const Queue& Q) throw(OutOfStorageException)
{
     //implement here

}//end copy constructor

Queue::~Queue()
{
while ( !isEmpty() )
 {
     dequeue();

}//end while
}//end destructor

    assert( (backPtr == 0) && (frontPtr == 0) )

[twomers]

Erm. Copy all relivant data?
By the looks of it start at the back pointer and iterate to the front pointer assigning the values at each of the nodes (from Q), to your object along the way.

[Ancient Dragon]

Learn to format your code better so that you can see what you're doing. Only takes a couple seconds to hit that space bar.

[ecestd1]

thanks

[ecestd1]

I did implement the copy constructor but still its not working what could be the problem?

/** @file
*
* @course CS1521
* @section 1
*
* Pointer-based Queue class implementation.

* Adapted from page 352-4 in Carrano 5e.
*
* @author Frank M. Carrano
* @author Steve Holtz
* @date 3/11/2007
* @version 5.1 */

#include "QueueP.h"
#include // for assert
#include // for bad_alloc
#include
//typedef std::queue 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