Re: Inserting objects into a std::map?
Ian Collins wrote:
saneman wrote:
Ian Collins wrote:
saneman wrote:
I am reading section 23 in the C++ standard and cannot seem to find
where it says that the key_type must be defined for '<' when inserting
into std::map.
That's because it doesn't have to.
std::map has four template arguments, the third is the comparison, which
defaults to std::less. By definition, std::less requires operator <, so
that's where the requirement for a map key originates. You are free to
provide your own comparison object which does not require an operator <.
Assuming that std::map is based on some kind of balanced tree structure
it wouldn't make much sense if no ordering based on key_type was
supplied (<, >, < 5 etc).
I realize that the dependency comes from the comparator but since the
comparator is based on the key_type some kind of ordering operator still
needs to be valid for the key_type.
Did you read what I said? You are free to provide your own comparison
object which does not require an operator <. That's the way maps work.
Say you had a map of pointers and wanted to sort based on the objects
pointed to. In that case you would provide a comparison object.
So it would in my opinion make sense if the standard says that the
key_type needs to be valid for the comparator used. Or is this to
obvious to mention?
NO, because it does not!
I don't understand. Does std::map not require that the comparison object
implement a boolean operator () ? In the below example I have made a
comparison object independent of the key_type:
// Dummy comparator.
class myCmp {
public:
myCmp() {}
bool operator()() const {
return 0;
}
};
// Testing with myCmp
std::map<int, std::string, myCmp> m;
std::pair<int, std::string> p;
p.first = 22; // key.
p.second = "33"; // key.
m.insert(p);
And it gives the error:
error: no match for call to ?(myCmp) (const int&, const int&)?
bob.cpp:42: note: candidates are: bool myCmp::operator()() const
I read the first error line as it tries to call a function operator on
the two key_types, which I intensionally have omitted in the operator in
'myCmp'
Here is what the standard says:
"This comparison object may be a pointer to function or an object of a
type with an appropriate function call operator."
If I instead do:
template <typename T>
class myCmp {
public:
myCmp() {}
bool operator()(const T& x, const T& y) const {
return 0;
}
};
and declare the map with:
std::map<int, std::string, myCmp<int> > m;
it works.