"Fred" <email@example.com> ha scritto nel messaggio
thanks for the tip.
You are welcome.
In the meantime, I managed to solve my problem by declaring a pointer
to the second CMap instead of the CMap itself.
******* IAMMetaDataAttribute.h **********
CMap <int, int, int, int> *alternateValue;
OK, defining CMap as a pointer in above context I think that you are
going to shoot yourself in the foot.
In fact, there is a reason of the previous compiler error about CMap:
the compiler was trying to warn you: "CMap can't be deep-copied, CMap
does not have a copy semantic".
If you define a data member as a pointer to CMap you are shutting up the
But you are preparing for troubles. In fact, if two instances of
CIAMMetaDataAttribute are going to be copied, the value of the pointer
(i.e. a memory address) is copied, and not the CMap instance itself.
So, in the above class, you should forbid copy semantic, declaring
private copy constructor and operator= for CIAMMetaDataAttribute.
Or just use std::map, which is copyable.
So I guessed I could get out with it this way... but your post about
the std::map object puzzled me ;)
Could you tell me more about this std::map thing? Is it more efficient
than CMap? It seems to be less convenient to manipulate, isn't it?
I'm not sure about efficiency. You should do some benchmarks in that
regard (Joe told us an importan lesson: "When you are in doubt, measure.").
I think that STL standard states that std::map insertion is O(log(N)),
but I'm not sure.
Moreover, IIRC, std::map is implemented as a kind of binary tree. If you
really want an hash-map data structure container, it is called hash_map
(probably its namespace is 'stdext', not 'std').
If you are not interested in sorting keys, stdext::hash_map may be
faster than std::map.
Moreover, as already stated, std::map is copyable, and CMap is not.
If I could do a criticism to std::map, it would be that I prefer
identifier names like 'key' and 'value' instead of 'first' and 'second'.
Moreover, I would have liked a member function something like contains()
to check if a key is stored in a std::map instance.
Instead, we have to write code like this:
std::map< string, int > someMap;
if ( someMap.find("Connie") == someMap.end() )
... "Connie" is not in the map.
I would have preferred something like 'someMap.contains("Connie")'
instead of comparing to someMap.end().
(Note that QT QMap has an intuitive method named 'contains' that does
just that: http://qt.nokia.com/doc/4.0/qmap.html#contains )
Thanks again Giovanni for your explanations.