Re: STL map question : directed to stl map expert(s)....
On 19 Sep., 22:10, altagrego <altagr...@gmail.com> wrote:
Given the following:
// map construction:
map<string, CMyClass*> myMap;
// construct next map key/element
CMyClass* pMC = new CMyClass("MyDataMember");
string myString = "mystring";
Let me first comment that it is a rather brittle
approach which you are using here. The main reason
for this is due to the fact that you have to ensure
manual resource release, which is both error-prone
and not tricky to make exception-safe. Also, there
is often lurking undefined behaviour around, if you
don't ensure careful release of values that have to
be deleted. You should consider to use either a
well-designed smart pointer class as mapped_type
(*not* std::auto_ptr, but e.g. boost::shared_ptr!)
or use an intrusive container, like boost::ptr_map.
// insert key/element into map;
myMap[myString ] = pMC;
QUESTION:
after accessing an element via a key..
In addition to removing an element from the map using "erase()", do I
still need to call delete on the "removed" object itself explicitly.
This is absolutly necessary, because the mapped_type of
your map is CMyClass*. The map will invoke the destructor
on this type, which is a no-op. All standard-containers
are value-oriented, that means they don't assume anything
special concerning pointer elements - how should they know,
that these were allocated at all or if so, by which means?
my access/erase/delete example ??????
CMyClass* p = myMap[myString];
myMap.erase(myString)
delete p;
If I am not on the right track...PLEASE PROVIDE SHORT EXAMPLE OF
ACCESS/ERASE/DELETE (using my sample)
Basically you are on the right track here, the important point
- which you nicely respect - is that you must *not* delete
any element which still is part of the container, otherwise
the container would contain a singular pointer for which
any read attempt causes U.B. The above lines do the right
thing in this regard. There is one issue that is not related
to the delete, but which is a side-effect of using map::operator[]
here. Consider the situation, if myMap would *not* contain any
key corresponding to myString. In this situation, this member
function will insert the new element pair (myString, 0) into
your map, which is probably *not* what you want. So I recommend
to use find instead, which is also more efficient:
typedef std::map<std::string, CMyClass*> MyMap;
MyMap::iterator it = myMap.find(myString);
if (it != myMap.end()) {
CMyClass* p = it->second; // Get a copy of the mapped type!
myMap.erase(it);
delete p;
}
Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]