Seg fault when deleting temporary pointer - c++

Question

I used gdb to find the exact line with the seg fault. It's noted within the dequeue function as a comment.
Here is the entire queue class.
I seg fault upon calling dequeue() when there are two objects and the sentinal within the queue.
template <typename T>
void Queue<T>::clear()
{
while(!isEmpty())
dequeue();
}
template <typename T>
void Queue<T>::enqueue(const T& x)
{
if(isEmpty())
{
Queue<T>* temp = new Queue<T>;
m_data = x;
m_next = temp;
return;
}
Queue<T>* temp = this;
while(temp->m_next != NULL)
{
temp = temp->m_next;
}
Queue<T>* node = new Queue<T>();
temp->m_data = x;
node->m_next = temp->m_next;
temp->m_next = node;
return;
}
template <typename T>
void Queue<T>::dequeue()
{
if(isEmpty())
return;
if(m_next != NULL)
{
Queue<T>* temp = m_next;
m_data = temp->m_data;
m_next = temp->m_next;
delete temp; //Seg fault here
}
return;
}
template <typename T>
const T& Queue<T>::front() const throw (int)
{
if(isEmpty())
throw 0;
return m_data;
}
template <typename T>
bool Queue<T>::isEmpty() const
{
return (m_next==NULL);
}
template <typename T>
int Queue<T>::size() const
{
int size = 0;
const Queue<T>* temp = this;
while(temp->m_next != NULL)
{
temp = temp->m_next;
size++;
}
return size;
}
Sorry, thought I'd already posted the Queue class:
template <typename T>
class Queue : public AbstractQueue<T> {
public:
Queue(){m_next = NULL;};
virtual void clear();
virtual void enqueue(const T& x);
virtual void dequeue();
virtual const T& front() const throw (int);
virtual bool isEmpty() const;
virtual int size() const;
~Queue(){
clear();
return;
};
private:
T m_data;
Queue* m_next;
};
And it inherits from this class:
template < typename T >
class AbstractQueue
{
public:
// Purpose: clears the queue
// Postconditions: the queue is now empty
// -- PURE VIRTUAL
virtual void clear() = 0;
// Purpose: enqueue an element into the queue
// Parameters: x is the item to add to the queue
// Postconditions: x is now the element at the end of the queue,
// -- PURE VIRTUAL
virtual void enqueue(const T& x) = 0;
// Purpose: dequeues
// Postconditions: the element formerly at the front of the queue has
// been removed
// Dequeueing from an empty Queue produces no errors, queue remains empty.
// -- PURE VIRTUAL
virtual void dequeue() = 0;
// Purpose: looks at the front of the queue
// Returns: a reference to the element currently in front of the queue
// Exception: if the queue is currently empty, throw SOMETHING!!
// -- PURE VIRTUAL
virtual const T& front() const = 0;
// Purpose: Checks if a queue is empty
// Returns: 'true' if the queue is empty
// 'false' otherwise
// -- PURE VIRTUAL
virtual bool isEmpty() const = 0;
// Purpose: Returns the size of a queue.
// Returns: the number of elements in the Queue
// -- PURE VIRTUAL
virtual int size() const = 0;
// ----------------
// Purpose: Destructor
// -- VIRTUAL
virtual ~AbstractQueue() {};
};

Answer 1

In this code:
Queue<T>* temp = m_next;
m_data = m_next->m_data;
m_next = m_next->m_next;
You don't check that m_next is non-null (if you're at the end of the list) so you start dereferencing the null pointer and all bets are off at that point.

Answer 2

To me, the following line inside enqueue() looks little strange.
Queue<T>* node = new Queue<T>();
It is creating a new Queue every time.
Could the intention be the following instead?
T * node = new T;

Answer 3

OK, instead of giving you a fish, I will teach you how to fish...
When you get segmentation fault it means that the operating system has detected a memory access error.
This usually happens in C/C++ when you play with pointers. pointers are very dangerous and have to be treated carefully.
How to detect where the problem occurs ?
Well, Linux is not very informative when your program receives SEGFAULT however, it gives you a lot of information. you just need to know how to "read" it.
The coredump, is a picture of the memory, stack and variables at the moment the segmentation fault occurred. to run it
gdb myapp core
where myapp is your application executable, and core is the coredump.
now you'll see something like:
GNU gdb 19991004
Copyright 1998 Free Software ���.�
Core was generated by `testit'.
Program terminated with signal 11, Segmentation fault.
Reading symbols from /usr/lib/libstdc++-libc6.1-1.so.2...done.
Reading symbols from /lib/libm.so.6...done.
Reading symbols from /lib/libc.so.6...done.
Reading symbols from /lib/ld-linux.so.2...done.
#0 0x823221a in main () at blabla.c:3
10 *i++;
it will show you exactly which line caused the fault.
If you want to know exactly how you got to that line, type bt
this will show you the backtrace, from your application main() until the actual fault, including parameters passed to the functions.
I think that once you'll know exactly where the segmentation fault occurred it will be much easier for you to solve it.
Few notes:
If coredump is not created.
type this in the console:
ulimit -c unlimited
You need to compile your program with -g to enable meaningful names of symbols in gdb.