operator[] will insert an entry for you with a default-constructed value, if one isn’t already there. It is equivalent to, but will probably be implemented more efficiently than: iterator iter = map.find(key); if(iter == map.end()) { iter = map.insert(value_type(key, int())).first; } return *iter; operator[] can be quicker than doing the work manually with find() and … Read more
Unfortunately, this program has undefined behavior. C++11 §17.6.4.2.1: A program may add a template specialization for any standard library template to namespace std only if the declaration depends on a user-defined type and the specialization meets the standard library requirements for the original template and is not explicitly prohibited. hash<pair<int,int>> depends on primitive and standard … Read more
| map | unordered_map ——————————————————— element ordering | strict weak | n/a | | common implementation | balanced tree | hash table | or red-black tree| | | search time | log(n) | O(1) if there are no hash collisions | | Up to O(n) if there are hash collisions | | O(n) when hash … Read more
They will have about equal performance. You should use the algorithm that best expresses what you are trying to do. To elaborate on that, generally count() will be implemented using find(). For example, in libcxx, count() is implemented as return (find(__k) != end());
C++ STL provides template specializations of std::hash for the various string classes. You could just specify std::string as key type for std::unordered_map: #include <string> #include <unordered_map> int main() { std::unordered_map<std::string, int> map; map[“string”] = 10; return 0; }
P0919R2 Heterogeneous lookup for unordered containers has been merged in the C++2a’s working draft! The abstract seems a perfect match w.r.t. my original question 🙂 Abstract This proposal adds heterogeneous lookup support to the unordered associative containers in the C++ Standard Library. As a result, a creation of a temporary key object is not needed … Read more
Since there was no hash table defined in the C++ standard library, different implementors of the standard libraries would provide a non-standard hash table often named hash_map. Because these implementations were not written following a standard they all had subtle differences in functionality and performance guarantees. Starting with C++11 a hash table implementation has been … Read more
You just do (for map and unordered_map) mydict[key]=value;
From the cplusplus.com page about the begin member function of unordered_map (link): Notice that an unordered_map object makes no guarantees on which specific element is considered its first element. So no, there is no guarantee the elements will be iterated over in the order they were inserted. FYI, you can iterate over an unordered_map more … Read more
unordered_map::insert copies or moves a key-value pair into the container. It is overloaded to accept reference-to-const or an rvalue reference: std::pair<iterator,bool> insert(const std::pair<const Key, T>& value); template<class P> std::pair<iterator,bool> insert(P&& value); unordered_map::emplace allows you to avoid unnecessary copies or moves by constructing the element in place. It uses perfect forwarding and a variadic template to … Read more