How to free memory for Queue? Mine doesn't free - c++

Question

This is the revised version.
It takes 3.5GB memory and the pop function doesn't free the memory... How can I use new and delete to get those memory back? Now I'm using STL. since new and delete only works for pointers?
queue<Graphnode> ss;
for(i=0;i<30000000;i++)
{
ss.push( *g.root);
}
printf("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n");
for(i=0;i<30000000;i++)
{
ss.pop();
}
printf("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n");
//delete &ss;
here is my node.h file. I think I need to malloc and free or New, delete pointers here?
#include <stdio.h>
#include <stdlib.h>
#include <tr1/array>
typedef struct point
{
std::tr1::array<int, 16> state;
int x;
}point;
typedef struct Graphnode
{
struct point pvalue;
int depth;
struct Graphnode *up;
struct Graphnode *down;
struct Graphnode *left;
struct Graphnode *right;
}Graphnode;
so after revise the code should look like this?
#include <stdio.h>
#include <stdlib.h>
#include <tr1/array>
typedef struct point
{
std::tr1::array<int, 16> state;
int x;
int depth;
}point;
typedef struct Graphnode
{
point *pvalue = (point *)malloc(sizeof(point));
Graphnode *up = (Graphnode*)malloc(sizeof(Graphnode));
Graphnode *down= (Graphnode*)malloc(sizeof(Graphnode));;
Graphnode *left= (Graphnode*)malloc(sizeof(Graphnode));;
Graphnode *right= (Graphnode*)malloc(sizeof(Graphnode));;
}Graphnode;

Answer 1

If you're using c++, you should use queue<T> from the standard library. Here is a reference: http://www.cplusplus.com/reference/stl/queue/.
For c++ code you should never write your own container classes unless it is absolutely necessary. The standard library provides many useful containers that cover most use cases. They are heavily used and tested and have been for many years.

Answer 2

Your queue can clean up after itself if and only if struct Graphnode is self-contained and does not contain pointers to allocated memory.
void emptyQueue(struct queue *q) {
queueElement *element, *nextElement;
element = q->head;
while(element) {
nextElement = element->next;
free(element);
element = nextElement;
}
initQueue(q);
}
Note that since initQueue does not malloc, its counterpart function, emptyQueue, should not free. This allows you to create queues on the stack if you need to.
If your struct Graphnode has pointers to allocated memory, then you will need to do this by hand, and not in emptyQueue. Your code will look something like:
struct Graphnode node;
while(!isEmpty(q)) {
node = front(q);
/* Delete the stuff in `node` here. */
dequeue(q);
}
Some comments on your C code...
In enqueue you have:
if (q->head == NULL) {
//first element
q->head = newElement;
q->tail = newElement;
} else {
//put it to the tail
q->tail->next= newElement;
q->tail = newElement;
}
Since you're doing q->tail = newElement; in both paths, move it out:
if (q->head == NULL) {
//first element
q->head = newElement;
} else {
//put it at the tail
q->tail->next= newElement;
}
q->tail = newElement;
Also, consistent indentation is a good habit to have. Your text editor should make this easy for you.
In dequeue:
if (q->head == NULL) {
//empty queue
return;
} else {
element = q->head;
q->head = q->head->next;
free(element);
}
The else isn't needed, since the first part always returns.
if (q->head == NULL) {
//empty queue
return;
}
element = q->head;
q->head = q->head->next;
free(element);
Finally, in ifEmpty:
return (q->head == NULL ? 1:0);
C represents true as nonzero and false as 0. The result of the == operator is guaranteed to be like this, so there's no point forcing true to be 1;
return q->head == NULL;
One final note: on some systems, the "memory used" read out by a program like top might not go down. This is because the system is keeping the pages of freed memory around for future use. It may release the physical memory, but the virtual memory addresses will be kept around as "available" for your program until termination.

Answer 3

Even an empty queue structure will still use memory. I am assuming you have defined queue as something like
struct queue
{
queueElement* head;
queueElement* tail;
};
So an empty queue will still require the memory to store the head and tail pointers even when they are both NULL.
How are you "measuring" the memory usage? Obviously sizeof is no good as it'll just be the constant size of the struct queue. So I assume you've got some other tool or code which is measuring it. But the code looks OK to me, and shuld be releasing the memory as you expect.
One bug you have is that the dequeue function never sets tail. But if head is NULL after setting it to head->next, then you also need to set tail to NULL. Don't think this would cause a memory leak, but definitely opens you up to a corruption or segfault if you enqueue after a dequeue empties the queue.