On Dec 20, 11:25 pm, Paulo da Silva
<psdasilva.nos...@netcabonospam.pt> wrote:
Em 21-12-2010 03:37, Paulo da Silva escreveu:
Em 20-12-2010 22:59, Paulo da Silva escreveu:
I just saw (wikipedia for example) that unordered_set should implement
the same behaviour as that of hash_set. Neverthless it is not working in
this code!
#include <memory>
#include <unordered_set>
#include <iostream>
using namespace std;
class Foo
{public:
string s;
Foo(char const * const sc): s(sc) {}
};
class eqf
{public:
inline bool operator()(Foo const &s1,Foo const &s2) const
{ return (s1.s==s2.s);
}
};
class hf
{public:
inline size_t operator()(Foo const &x) const
{ return hash<char const *>()(x.s.c_str());
}
};
// typedef __gnu_cxx::hash_set<Foo,hf,eqf> MSet;
typedef unordered_set<Foo,hf,eqf> MSet;
int main()
{ MSet mc;
pair<MSet::iterator,bool> r;
r=mc.insert(Foo("xxxx"));
// OK expected and obtained
cout << "xxxx " << (r.second?"OK":"BAD") << endl;
mc.insert(Foo("zzzz"));
// Does not allow duplicates ...
r=mc.insert(Foo("zzzz"));
// BAD (duplicate) expected but OK obtained
cout << "zzzz " << (r.second?"OK":"BAD") << endl;
MSet::const_iterator it=mc.find(Foo("xxxx"));
for (it=mc.begin();it!=mc.end();++it)
cout << it->s << endl;
return 0;
}
Anything wrong? Better way to implement?
Thanks for any comments.
Replacing class hf with this works.
class hf
{public:
inline size_t operator()(Foo const &s) const
{ return hash<string const &>()(s.s);
}
};
I still don't understand why the previous example stopped to work!
I suspect it was a change in the behavior of the hash<char const*>
function. In C++0x std::hash<char const*> simply hashes the pointer,
not a null terminated string. Therefore using std::hash<char const*>
combined with your eqf would give you the situation that two Foo's
could compare equal but hash to different buckets. This is a
situation that will essentially corrupt your container. Your fix
(using hash<string const &>) is correct.
That makes sense and explains the whole thing.
Nevertheless it seems a weird behaviour of hash<char const*>.