unordered-map

Consider the ordered and unordered associative containers in C++ keyed on double . Is NaN a valid key type? With ordered containers, I should say "no", because it does not respect the strict weak ordering. With unordered containers, I have no idea. Here's what happens in GCC 4.6.2: #include <map> #include <unordered_map> #include <cmath> #include <iostream> #include <prettyprint.hpp> int main() { typedef std::map<double, int> map_type; // replace by "unorderd_map" map_type dm; double d = std::acos(5); // a good nan dm[d] = 2; dm[d] = 5; dm[d] = 7; std::cout << "dm[NaN] = " << dm[d] << ", dm =

My code: typedef pair<int,int> Pair tr1::unordered_map<Pair,bool> h; h.insert(make_pair(Pair(0,0),true)); Erorr undefined reference to `std::tr1::hash<std::pair<int, int> >::operator()(std::pair<int, int>) const' Something I need to fix? thanks This happens because there is no specialization for std::tr1::hash<Key> with Key = std::pair<int, int> . You must to specialize std::tr1::hash<Key> with Key = std::pair<int, int> before declaring tr1::unordered_map<Pair,bool> h; . This happens because std don't know how to hash a pair<int, int> . Following there is a example of how to specialize std:

I have the following class with an unordered_map member, and a hash function defined for pair<int,int> class abc {public : unordered_map < pair<int,int> , int > rules ; unsigned nodes; unsigned packet ; }; namespace std { template <> class hash < std::pair< int,int> >{ public : size_t operator()(const pair< int, int> &x ) const { size_t h = std::hash<int>()(x.first) ^ std::hash<int>()(x.second); return h ; } }; } But I am getting the following errors : error: invalid use of incomplete type ‘struct std::hash<std::pair<int, int> > error: declaration of ‘struct std::hash<std::pair<int, int> >

Suppose I wanted to map data with a string as the key. What container should I have chosen, map or unordered_map ? unordered_map takes up more memory so let's suppose memory isn't an issue, and the concern is speed. unordered_map should generally give average complexity of O(1) with the worst case of O(n). In what cases would it get to O(n)? When does a map get more time efficient than unordered_map ? Does it happen when n is small? Assuming I would use STL unordered_map with the default haser Vs. map. string is the key. If I'm going to iterate over the elements rather than access an