I have a std::queue that is wrapped as a templated class to make a thread-safe queue. I have two versions of this class: one that stores value types, one that stores pointer types.
For the pointer type, I’m having trouble deleting the elements of the queue on destruction. The reason is that I don’t know a way to remove the items from the queue safely.
This reference states (vacuously, so I guess it doesn’t actually STATE it) that the only way to remove elements from the queue is to call pop(). The reference also says that pop() calls the destructor for the item.
Well, this causes problems with my pointer types because they may or may not actually point to aggregates. If one of them points to an aggregate, they all will, but because the wrapper is templated, there is no guarantee which type (aggregated or non-aggregated) we are dealing with.
So, when pop() calls the destructor, what happens? How do I ensure that everything is being removed and the memory deallocation properly?
Lastly, my solution is using an older version of GCC for ARM9. I don’t have control over this. I understand that there are libraries that have smart pointers and containers that would assist here, but they are off-limits for me.
Online sources are worth what you pay for them – get a proper reference like Josuttis’s book. pop() does not “call the destructor” – it simply removes an element from the queue adaptor’s underlying representation (by default a std::deque) by calling pop_front() on it. If the thing being popped has a destructor, it will be used when the popped object goes out of scope, but the queue class has nothing to do with it.