Read Access Violation (this->headPtr was 0xCDCDCDCD)

Question

Remove (T &item) is supposed to remove the headPtr and store that "item value" in "item" and return true, otherwise return false if no elements are in the queue. I get a "read access violation error" in this function. Here is the class and function definitions:

class SharedQueue {
public:
    SharedQueue();
    ~SharedQueue();

    //Return true if the queue is empty
    bool IsEmpty() const;

    //Enqueue the next item at the tail of the queue.
    void Add(T value);

    //Dequeue the next queue element and store it in "item" variable.  The function returns false if the queue is empty and no item can be retrieved.
    bool Remove(T &item);
    void Print();
private:
    struct QueueItem {
        T item;
        QueueItem *next;
    };
    //Fill in the The private data members.
    QueueItem *headPtr;
    QueueItem *tailPtr;
};

template <typename T> SharedQueue<T>::SharedQueue() {
    headPtr = NULL;
    tailPtr = NULL;
}

template <typename T>SharedQueue<T>::~SharedQueue() {
    QueueItem *temp;
    while (headPtr != NULL) {
        temp = headPtr;
        headPtr = headPtr->next;
        delete temp;
    }
}

template <typename T> bool SharedQueue<T>::IsEmpty() const {
    if (headPtr == NULL && tailPtr == NULL) {
        return true;
    }
    return false;
}

template <typename T> void SharedQueue<T>::Add(T aValue) {
    if (headPtr == NULL) {
        QueueItem *newItem = new QueueItem;
        newItem->item = aValue;
        tailPtr = headPtr = newItem;
    }
    else {
        QueueItem *newItem = new QueueItem;
        newItem->item = aValue;
        tailPtr->next = newItem;
        tailPtr = tailPtr->next;
    }
}

template <typename T> bool SharedQueue<T>::Remove(T &item) {
    if (headPtr == NULL) {
        return false;
    }
    else {
        QueueItem temp = *headPtr;
        item = headPtr->item;
        delete headPtr;
        headPtr = temp.next;
        return true;
    }
}

template <typename T> void SharedQueue<T>::Print() {
    QueueItem *temp = headPtr;
    while (temp != NULL) {
        std::cout << temp->item << "\n";
        temp = temp->next;
    }
}

Answer 1

When you add an item to a non-empty SharedQueue<T>:

    QueueItem *newItem = new QueueItem;
    newItem->item = aValue;
    tailPtr->next = newItem;
    tailPtr = tailPtr->next;

You never set the newItem->next = NULL.

Your private struct QueueItem can (and maybe should) have its own constructor(s)/destructor to help ensure that things like this are set consistently.