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) )

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.

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

/** @file
*
*  @course CS1521
*  @section 1
*
*  Pointer-based <tt>Queue</tt> class implementation.<br>
*  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 <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

Edited 3 Years Ago by happygeek: fixed formatting

This article has been dead for over six months. Start a new discussion instead.