Difference between revisions of "Intermediate C++ Game Programming Tutorial 24"
From Chilipedia
(→Video Timestamp Index) |
(→Video Timestamp Index) |
||
| Line 37: | Line 37: | ||
** The STL implementation is further optimized, e.g. it uses a red-black tree for BT rebalancing | ** The STL implementation is further optimized, e.g. it uses a red-black tree for BT rebalancing | ||
</div> | </div> | ||
| − | * A look at the <code>std::map</code> cppreference.com documentation [https://youtu.be/JlPsCoCO99o?t=7m35s 7:35] | + | * A look at the <code>std::map</code> cppreference.com documentation: Insert, Lookup, Find [https://youtu.be/JlPsCoCO99o?t=7m35s 7:35] |
<div class="mw-collapsible-content"> | <div class="mw-collapsible-content"> | ||
** <code>map.insert()</code> takes a pair type <code>std::pair<KeyType,ValueType></code>, the Map's elements | ** <code>map.insert()</code> takes a pair type <code>std::pair<KeyType,ValueType></code>, the Map's elements | ||
** C++ can deduce the pair Type, so <code>map.insert({keyX,valueXYZ});</code> with curly braces will do the job | ** C++ can deduce the pair Type, so <code>map.insert({keyX,valueXYZ});</code> with curly braces will do the job | ||
| − | ** An even better way to insert is through <code>map.emplace[]</code> operation; | + | ** An even better way to insert is through <code>map.emplace[]</code> operation; it will construct the pair in-place. |
** For lookup, you can use square braces, <code>map[x]</code> will return a reference to the corresponding value | ** For lookup, you can use square braces, <code>map[x]</code> will return a reference to the corresponding value | ||
** Note: a lookup with a new key value will create that element in the map with the default constructed ValueType value | ** Note: a lookup with a new key value will create that element in the map with the default constructed ValueType value | ||
** <code>insert</code> or <code>emplace</code> with a key that already exists will NOT override the existing value: <code>std::map::emplace</code> returns a <code>std::pair<iterator,bool></code> where the bool inidicates whether an insertion took place | ** <code>insert</code> or <code>emplace</code> with a key that already exists will NOT override the existing value: <code>std::map::emplace</code> returns a <code>std::pair<iterator,bool></code> where the bool inidicates whether an insertion took place | ||
| − | ** <code>map.find("xyz")<code> returns an iterator to the element if it exitst, and an iterator to <code>map.end()</code> if it doesn't exist (useful to check if a key already exists) | + | ** <code>map.find("xyz")</code> returns an iterator to the element if it exitst, and an iterator to <code>map.end()</code> if it doesn't exist (useful to check if a key already exists) |
** <code>std::map</code> comes with iterators and because it is a sorted map, when you iterate over its elements with <code>for (auto& el : map)</code>, it will be in order (of the keys) | ** <code>std::map</code> comes with iterators and because it is a sorted map, when you iterate over its elements with <code>for (auto& el : map)</code>, it will be in order (of the keys) | ||
</div> | </div> | ||
Revision as of 03:38, 20 January 2020
Associative containers are super useful, both as a convenient fast way to create dictionary or mapping for real-world problems like managing game resources, and as a data structure to help solve more abstract algorithmic computer science problems. And hash tables are fast as balls.
Contents
Topics Covered
Part 1
-
std::mapcontainer interface - Binary tree data structure
-
std::mapkey requirements (comparison) -
std::mapgotchas (std::remove_ifandconstkeys) -
std::set -
std::multimapandstd::multiset
Part 2
- Hash table performance vs. binary tree performance
- Hash table data structure
-
std::unordered_mapkey requirements - Hash combining
-
std::unordered_mapbucket interface and hashing policy - When to choose
std::mapoverstd::unordered_map
Video Timestamp Index
- The
std::map<KeyType,ValueType>class 0:46
- Maps consist of keys to lookup (associated with) values
-
map.insert( {key,value} )to insert (key,value) pairs -
map[key]returns a reference to the ValueType for a KeyType
- The Binary tree data structure 2:46
-
std::mapperforms lookup in O(log(n)), it uses a Binary tree data structure - Key properties of a Binary Tree (BT):
- - Nodes can have at most 2 children (hence: binary)
- - Each left child is smaller and each right child is larger than its parent
- - Insertion is done by navigating the tree along a route Left for smaller, Right for larger such that the order property always holds
- The big advantage of the BT properties is that retrieval is very fast
- The beauty of
std::mapis that we don't have to implement any of this; it's all there in the STL 7:00 - The STL implementation is further optimized, e.g. it uses a red-black tree for BT rebalancing
-
- A look at the
std::mapcppreference.com documentation: Insert, Lookup, Find 7:35
-
map.insert()takes a pair typestd::pair<KeyType,ValueType>, the Map's elements - C++ can deduce the pair Type, so
map.insert({keyX,valueXYZ});with curly braces will do the job - An even better way to insert is through
map.emplace[]operation; it will construct the pair in-place. - For lookup, you can use square braces,
map[x]will return a reference to the corresponding value - Note: a lookup with a new key value will create that element in the map with the default constructed ValueType value
-
insertoremplacewith a key that already exists will NOT override the existing value:std::map::emplacereturns astd::pair<iterator,bool>where the bool inidicates whether an insertion took place -
map.find("xyz")returns an iterator to the element if it exitst, and an iterator tomap.end()if it doesn't exist (useful to check if a key already exists) -
std::mapcomes with iterators and because it is a sorted map, when you iterate over its elements withfor (auto& el : map), it will be in order (of the keys)
-
- Requirements on KeyType 14:30
- The KeyType has to be comparable. The third template parameter is a functor for KeyType Comparison that defaults to
std::less<KeyType> - So by default keys have to implement the "less than" comparison operator or provide your own comparison functor when defining the map
- The KeyType has to be comparable. The third template parameter is a functor for KeyType Comparison that defaults to
- [WORK-IN-PROGRESS]
Homework Assignment
The homework for this video is to enable use of a custom datatype in unordered_map hashing over multiple (4) members of that datatype. The solution video is here.
