Difference between revisions of "Intermediate C++ Game Programming Tutorial 24"

From Chilipedia
Jump to: navigation, search
(→‎Tutorial 24.2: The unordered associative containers)
(→‎Tutorial 24.2: The unordered associative containers)
 
(7 intermediate revisions by the same user not shown)
Line 122: Line 122:
 
* Requirements for the KeyType of an <code>unordered_map</code> / a hash table [https://youtu.be/LsjFAx-dG5I?t=11m56s 11:56]
 
* Requirements for the KeyType of an <code>unordered_map</code> / a hash table [https://youtu.be/LsjFAx-dG5I?t=11m56s 11:56]
 
<div class="mw-collapsible-content">
 
<div class="mw-collapsible-content">
−
** There needs to be a working hash function defined for the KeyType
+
:* There needs to be a working hash function defined for the KeyType
−
** There need to be comparison and equality functor definitions for the KeyType
+
:* There need to be comparison and equality functor definitions for the KeyType
 
</div>
 
</div>
 
* Example: map from <code>Vec2</code> class (2D coordinates) to a string [https://youtu.be/LsjFAx-dG5I?t=12m46s 12:46]
 
* Example: map from <code>Vec2</code> class (2D coordinates) to a string [https://youtu.be/LsjFAx-dG5I?t=12m46s 12:46]
 
<div class="mw-collapsible-content">
 
<div class="mw-collapsible-content">
−
** In order to make this work, you need to define a hash function and the comparators for <code>Vei2</code>
+
:* In order to make this work, you need to define a hash function and the comparators for <code>Vei2</code>
−
** You can implement a comparison/equality functor as a <code>struct</code> that defines a <code>bool operator()( const T& lhs,const T& rhs ) const</code> member function, templated on <code>T</code>
+
:* You can implement a comparison/equality functor as a <code>struct</code> that defines a <code>operator()</code> member function, templated on <code>T</code>
−
** Defining a custom hashing function is an art, it requires knowledge of cryptography, abstract algebra, discrete math, etc.
+
::<syntaxhighlight lang="cpp" line>
−
** Luckily, we don't need this; you can revert to the standard hashing functions for the basic types that make up any custom type
+
struct EqVec2
 +
{
 +
    template <typename T>
 +
    bool operator()( const T& lhs,const T& rhs ) const
 +
    {
 +
        return (lhs.x == rhs.x) && (lhs.y == rhs.y);
 +
    }
 +
};
 +
</syntaxhighlight>
 +
:* Defining a custom hashing function is an art, it requires knowledge of cryptography, abstract algebra, discrete math, etc.
 +
:* Luckily, we don't need this; you can revert to the standard hashing functions for the basic types that make up any custom type
 
</div>
 
</div>
 
* Hash combining [https://youtu.be/LsjFAx-dG5I?t=14m25s 14:25]
 
* Hash combining [https://youtu.be/LsjFAx-dG5I?t=14m25s 14:25]
 
<div class="mw-collapsible-content">
 
<div class="mw-collapsible-content">
−
** Combining hashes from basic types to create a hash over your custom object  
+
:* Combining hashes from basic types to create a hash over your custom object  
−
** Stack Overflow question "How do I combine hash values in C++" give the example as used in the boost library
+
:* A simple google search will give you good examples of how to combine hash values in C++
−
** You can implement a hashing functor as a <code>struct</code> that defines a member function, templated on <code>T</code>, the basic type of the <code>Vec2</code> coordinates:
+
:* You can implement a hashing functor as a <code>struct</code> that defines a member function, templated on <code>T</code>, the basic type of the <code>Vec2</code> coordinates:
−
*: <code>size_t operator()( const _Vec2<T>& vec ) const</code>
+
::<syntaxhighlight lang="cpp" line>
−
*: <code>{</code>
+
struct HashVec2
−
*:: <code>std::hash<T> hasher;</code>
+
{
−
*:: <code>auto hashx = hasher ( vec.x );</code>
+
    template <typename T>
−
*:: <code>auto hashy = hasher ( vec.y );</code>
+
    size_t operator()( const _Vec2<T>& vec ) const
−
*:: <code>hashx ^= hashy + 0x9e3779b9 + (hashx << 6) + (hashx >> 2);</code>
+
    {
−
*:: <code>return hashx;</code>
+
        std::hash<T> hasher;
−
*: <code>}</code>
+
        auto hashx = hasher ( vec.x );
−
** You pass these functors when defining the map: <code>std::unordered_map<Vei2,std::string,HashVec2> map;</code> [https://youtu.be/LsjFAx-dG5I?t=17m15s 17:15].  
+
        auto hashy = hasher ( vec.y );
−
** Note that the comparison functor is not needed: we can revert back to the equality operator already defined in the <code>Vec2</code> class definition
+
        hashx ^= hashy + 0x9e3779b9 + (hashx << 6) + (hashx >> 2);
 +
        return hashx;
 +
    }
 +
};
 +
</syntaxhighlight>
 +
:* You pass this functors when defining the map: <code>std::unordered_map<Vei2,std::string,HashVec2> map;</code> [https://youtu.be/LsjFAx-dG5I?t=17m15s 17:15].  
 +
:* Note that the comparison functor is not needed: we can revert back to the equality operator already defined in the <code>Vec2</code> class definition
 
</div>
 
</div>
 
* Template Specialization [https://youtu.be/LsjFAx-dG5I?t=18m43s 18:43]
 
* Template Specialization [https://youtu.be/LsjFAx-dG5I?t=18m43s 18:43]
 
<div class="mw-collapsible-content">
 
<div class="mw-collapsible-content">
−
** Unordered map uses <code>std::hash</code> by default. You can inject Template Specialization for <code>std::hash</code> into the <code>std</code> Namespace for your own custom types only
+
:* Unordered map uses <code>std::hash</code> by default. You can inject Template Specialization for <code>std::hash</code> into the <code>std</code> Namespace for your own custom types only
−
*: <code>namespace std</code>
+
::<syntaxhighlight lang="cpp" line>
−
*: <code>{</code>
+
namespace std
−
*:: <code>template <> struct hash<Vei2></code>
+
{
−
*:: <code>{</code>
+
    template <> struct hash<Vei2>
−
*::: <code>size_t operator()( cont Vei2& vec ) const</code>
+
    {
−
*::: <code>{...}</code>
+
        size_t operator()( cont Vei2& vec ) const
−
*:: <code>};</code>
+
        {...}
−
*: <code>}</code>
+
    };
−
** Now you don't need to pass <code>HashVec2</code> in the map definition
+
}
 +
</syntaxhighlight>
 +
:* Now you don't need to pass <code>HashVec2</code> in the map definition
 
</div>
 
</div>
 
* The <code>std::unordered_map<></code> Bucket interface [https://youtu.be/LsjFAx-dG5I?t=20m00s 20:00]
 
* The <code>std::unordered_map<></code> Bucket interface [https://youtu.be/LsjFAx-dG5I?t=20m00s 20:00]
 
<div class="mw-collapsible-content">
 
<div class="mw-collapsible-content">
−
** Allows you to get information about the buckets in the hash table and access nodes
+
:* Allows you to get information about the buckets in the hash table and access nodes
−
** The bucket iterator takes an index of the bucket and allows you to iterate over all the elements in that specific bucket
+
:* The bucket iterator takes an index of the bucket and allows you to iterate over all the elements in that specific bucket
 
</div>
 
</div>
 
* The <code>std::unordered_map<></code> Hash policy interface [https://youtu.be/LsjFAx-dG5I?t=21m47s 21:47]
 
* The <code>std::unordered_map<></code> Hash policy interface [https://youtu.be/LsjFAx-dG5I?t=21m47s 21:47]
 
<div class="mw-collapsible-content">
 
<div class="mw-collapsible-content">
−
** Allows you to tune your hash table (and thus the growth behavior & performance of the map)
+
:* Allows you to tune your hash table (and thus the growth behavior & performance of the map)
−
** Load Factor = average number of elements per bucket. For performance, you typically want to keep this below 1
+
:* Load Factor = average number of elements per bucket. For performance, you typically want to keep this below 1
−
** You can set the maximum load factor above which the table gets rehashed
+
:* You can set the maximum load factor above which the table gets rehashed
−
** When the load factor becomes too high, it will automaticall rehash the table and increase the number of buckets
+
:* When the load factor becomes too high, it will automaticall rehash the table and increase the number of buckets
−
** You can manually rehash to a number of buckets you define
+
:* You can manually rehash to a number of buckets you define
−
** You can reserve space for max number of elements, is then derives (and manages) the required number of buckets
+
:* You can reserve space for max number of elements, is then derives (and manages) the required number of buckets
 
</div>
 
</div>
 
* When to choose <code>std::map</code> over <code>std::unordered_map</code>? [https://youtu.be/LsjFAx-dG5I?t=24m15s 25:15]
 
* When to choose <code>std::map</code> over <code>std::unordered_map</code>? [https://youtu.be/LsjFAx-dG5I?t=24m15s 25:15]
 
<div class="mw-collapsible-content">
 
<div class="mw-collapsible-content">
−
** For simplicity and when performance is not a critical issue, no need to define a hash function;
+
:* For simplicity and when performance is not a critical issue, no need to define a hash function;
−
** If you want to iterate in order;
+
:* If you want to iterate in order;
−
** When you want to be able to find keys that are close to a certain key (with <code>lower_bound</code> and <code>upper_bount</code>
+
:* When you want to be able to find keys that are close to a certain key (with <code>lower_bound</code> and <code>upper_bount</code>
 
</div>
 
</div>
 
* Homework assignment [https://youtu.be/LsjFAx-dG5I?t=26m04s 26:04]
 
* Homework assignment [https://youtu.be/LsjFAx-dG5I?t=26m04s 26:04]

Latest revision as of 23:47, 2 February 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.

Topics Covered

Part 1: ordered associative containers

  • std::map container interface
  • Binary tree data structure
  • std::map key requirements (comparison)
  • std::map gotchas (std::remove_if and const keys)
  • std::set
  • std::multimap and std::multiset

Part 2: unordered associative containers

  • Hash table performance vs. binary tree performance
  • Hash table data structure
  • std::unordered_map key requirements
  • Hash combining
  • std::unordered_map bucket interface and hashing policy
  • When to choose std::map over std::unordered_map

Video Timestamp Index

Tutorial 24.1: The ordered associative containers

[Expand]
  • The std::map<KeyType,ValueType> class 0:46
  • A Binary Tree data structure is used to manage the order of map elements 2:46
  • A look at the std::map cppreference.com documentation: insert, lookup & find 7:35
  • Requirements on KeyType 14:30
  • std::map cppreference.com documentation continued: erase 15:28
  • Two important things to know when working with associative containers 16:04
  • The std::set<KeyType> class 20:00
  • The std::multimap and std::multiset classes 21:28
  • Practical example of a multimap use case 22:30
  • Lookup in multimaps 25:21

Tutorial 24.2: The unordered associative containers

[Expand]
  • Main difference between ordered/unordered: performance 0:14
  • Using an unordered map 1:38
  • The Hash Table data structure 3:20
  • Requirements for the KeyType of an unordered_map / a hash table 11:56
  • Example: map from Vec2 class (2D coordinates) to a string 12:46
  • Template Specialization 18:43
  • The std::unordered_map<> Bucket interface 20:00
  • The std::unordered_map<> Hash policy interface 21:47
  • When to choose std::map over std::unordered_map? 25:15
  • Homework assignment 26:04

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.

Supplementary Link

See also

Retrieved from "https://wiki.planetchili.net/index.php?title=Intermediate_C%2B%2B_Game_Programming_Tutorial_24&oldid=2960"