Unusual memory leak in queue - code hangs on exit - c++

Question

i need to create queue of classes to be processed by a thread afterwards. The problem is that every time i add a reference to an object, queue assigns memory for that class causing huge memory leaks. This also leads to program hang on exit.
Adding 12345678 references to an object of TaskClass to TaskQueue causes 137MB memory leak.
Notice that memory is not freed when calling queue.pop().
class TaskQueue:
template <class tjob>
class TaskQueue
{
private:
std::queue<tjob> _taskqueue;
public:
TaskQueue()
{
//constructor goes here
}
//add task to queue
template < typename Class>
bool AddTask( Class &PClass)
{
_taskqueue.push(PClass);
return true;
}
bool ProcessQueue()
{
while (!_taskqueue.empty())
{
_taskqueue.front().run();
_taskqueue.pop();
}
return true;
}
//run a function pointer
template < typename Task >
bool RunTask( Task task){
task();
return true;
}
//call class entry point member .run
template < typename Class>
bool RunClass ( Class& PClass){
PClass.run();
return true;
}
//return remaining tasks
int GetRemainingTasks(){
return _taskqueue.size();
}
};
class TaskClass:
class TaskClass
{
protected:
int *ptr_x;
public:
TaskClass() {
std::cout << "TaskClass Constructor called\n";
ptr_x = new int(0);
}
bool run(){
*ptr_x = *ptr_x + 1;
return true;
}
bool printx(){
std::cout << "x is now " << *ptr_x << std::endl;
return true;
}
~TaskClass(){
//std::cout << "TaskClass destructor called!\n";
}
};
main:
int main()
{
TaskClass job1;
int nojobs = 12345678;
TaskQueue<TaskClass> TestQueue;
std::cout << "Preparing Queue... Adding " << nojobs << " tasks.. "; //std::cin.get();
for (int i=0;i<nojobs;i++)
TestQueue.AddTask(job1);
std::cout << "Done!\n"; //std::cin.get();
std::cout << "Processing Queue... ";
TestQueue.ProcessQueue();
std::cout << "Done!\n";
job1.printx();
std::cout << "Remaining tasks: " << TestQueue.GetRemainingTasks() << std::endl;
//std::cin.get();
//exit(0);
return 0;
}

Answer 1

The memory leak is
ptr_x = new int(0);
because you never delete that memory. At a minimum, you need to delete it in the destructor, and also add a copy constructor which deep-copies it.
A better solution is to replace the pointer with a simple
class TaskClass
{
protected:
int x;
(although I don't see why it would be static as in billz's answer).
Incidental infelicities:
unnecessary templating:
template < typename Class>
bool AddTask( Class &PClass) {
the only valid type for Class is the class template argument tjob, so why template this method at all? And why require a non-const ref to something you can only copy?
bool AddTask(tjob const &job) {
_taskqueue.push(job);
return true;
}
is better. Similarly for the other templated methods.
i need to create queue of classes
No, you don't, and in fact you can't (I suppose you could create a queue of typeinfo_t if you really wanted). You need to create a queue of objects. Fortunately that's what you're actually doing, since calling an object reference PClass doesn't make it a pointer-to-class.
This might seem (and indeed be) pedantic, but it's generally easier for everyone if you get the terminology right.