I have query regarding std::map.
if I have a std::map like:
std::map <T1, T2*> my_map; T1 t; T2* tt = new T2; my_map[t]=tt; who is responsible to clean this container, Will destructor of T2 will take care of it (T2* tt). Also if I want to retain this container throughout the program, where should I clean it.
Thanks
The map destroys the objects stored in the map. The map stores some T1 objects, which will be destroyed, and it stores some T2 pointers, which will be destroyed.
But it does not store actual T2 objects. So no T2 objects will be destroyed.
Raw pointers do not have ownership of the objects they point to. So when a pointer is destroyed, it will not delete whatever it points to.
Generally speaking, when you have a pointer, there is no way to know if
delete on some random garbage in memory), new (if it has been allocated in another way, it should not be deleted with delete), ordelete. Which one?)So even if you wanted to, there is no way to automatically delete an object when a pointer to it is destroyed.
The destructor of T2 is called nowhere in this example, only the pointer is destroyed. When the map is out of scope, it will destroy all pairs of elements <T1, T2*>, but this will not call delete on the second item.
You could however use boost::shared_ptr or std::shared_ptr (C++11) if you want reference-counted pointers.
#include <boost/shared_ptr.hpp> std::map <T1, boost::shared_ptr<T2> > my_map; T1 t; T2 *tt = new T2; my_map[t] = tt; // tt is passed to a shared_ptr, ref count = 1 // when out of scope, the destructor of `boost::shared_ptr` will call `delete`. If you needn't make copies of the objects stored in the map, you can use C++11's std::unique_ptr.
unique_ptr would be more suitable than shared_ptr, since shared ownership isn't required.unique_ptr some algorithms might be unavailable (that make an object copy) since unique_ptr(unique_ptr&) = delete;.
unique_ptr. It's easier to relax the ownership rules later on, than it is to try to tighten them.What Benoit said; but as an alternative consider a boost::ptr_map; basically a map which takes ownership of contained pointer values.
It's up to you to decide who is responsible to clean data, depending on what is your intent (for instance, your map can be a temporary storage to help perform some algorithm and you want to avoid copies). However, using boost::shared_ptr (or std::tr1::shared_ptr) is often the good way to go.
This object is a local variable created in the stack(in other words not in the heap). Once it's out of scope, it will be destroyed.
To explain a bit more, when you create an object with new operator it's created in the heap, and you have to manually delete it. When you instantiate it like AClass a this will be created in the stack and when the program flow gets out of the scope it's created it will be destroyed automatically.
std::map <T1, T2*> my_map; is created in the stack.