unordered-map

I understand that the complexity of the clear() operation is linear in the size of the container, because the destructors must be called. But what about primitive types (and POD)? It seems the best thing to do would be to set the vector size to 0, so that the complexity is constant. If this is possible, is it also possible for std::unordered_map? dasblinkenlight It seems the best thing to do would be to set the vector size to 0, so that the complexity is constant. In general, the complexity of resizing a vector to zero is linear in the number of elements currently stored in the vector .

I have a class C, which has a string* ps private data member. Now, I'd like to have an unordered_map<C, int> for which I need a custom hash function. According to the c++ reference , I can do that like namespace std { template<> class hash<C> { public: size_t operator()(const C &c) const { return std::hash<std::string>()(*c.ps); } }; } The problem is that I can't seem to make operator() and C friends so that I could access ps . I have tried this: class C; template<> class std::hash<C>; class C{ //... friend std::hash<C>::operator ()(const C&) const; // error: Incomplete type }; // define hash

How can I sort an unordered_map by key? I need to print an unordered_map sorted by key. std::unordered_map<int, int> unordered; std::map<int, int> ordered(unordered.begin(), unordered.end()); for(auto it = ordered.begin(); it != ordered.end(); ++it) std::cout << it->second; An alternate solution is to construct a vector of the keys, sort the vector, and print per that sorted vector. This will be considerably faster than the approaches that constructed a map from the ordered map, but will also involve more code. std::unordered_map<KeyType, MapType> unordered; std::vector<KeyType> keys; keys

The multimap in C++ seems to work really odd, i would like to know why #include <iostream> #include <unordered_map> using namespace std; typedef unordered_multimap<char,int> MyMap; int main(int argc, char **argv) { MyMap map; map.insert(MyMap::value_type('a', 1)); map.insert(MyMap::value_type('b', 2)); map.insert(MyMap::value_type('c', 3)); map.insert(MyMap::value_type('d', 4)); map.insert(MyMap::value_type('a', 7)); map.insert(MyMap::value_type('b', 18)); for(auto it = map.begin(); it != map.end(); it++) { cout << it->first << '\t'; cout << it->second << endl; } cout << "all values to a" <<

I have an unordered_map that uses a string-type as a key: std::unordered_map<string, value> map; A std::hash specialization is provided for string , as well as a suitable operator== . Now I also have a "string view" class, which is a weak pointer into an existing string, avoiding heap allocations: class string_view { string *data; size_t begin, len; // ... }; Now I'd like to be able to check if a key exists in the map using a string_view object. Unfortunately, std::unordered_map::find takes a Key argument, not a generic T argument. (Sure, I can "promote" one to a string , but that causes an

I wanted to have something like unordered_set<vector<pair<int,int>>> us; but even without pair: #include <vector> #include <unordered_set> using namespace std; int main() { unordered_set<vector<int>> um; } it fails: In file included from /usr/include/c++/4.8/bits/hashtable.h:35:0, from /usr/include/c++/4.8/unordered_set:47, from prog.cpp:2: /usr/include/c++/4.8/bits/hashtable_policy.h: In instantiation of ‘struct std::__detail::_Hash_code_base<std::vector<int>, std::vector<int>, std::__detail::_Identity, std::hash<std::vector<int> >, std::__detail::_Mod_range_hashing, std::__detail::_Default

I recently discovered that the implementation of the hash map in C++ will be called unordered_map . When I looked up why they weren't just using hash_map , I discovered that apparently there are compatibility issues with the implementation of hash_map that unordered_map resolves (more about it here ). That wiki page doesn't give much more information so I wondering if anyone knew some of the issues with hash_map that unordered_map resolves. Stef Since there was no hash table defined in the C++ standard library, different implementors of the standard libraries would provide a non-standard hash