c++ - 是否可以将固定大小的数组作为 unordered_map 键

Question

我想知道是否可以让 std::unordered_map 使用固定大小的数组作为键。例如，这是一个简单的缓存，它保存字符串作为值，但需要 uint8_t[] 作为键:

using UserKeyV1 = uint8_t[16];
using UserKeyV2 = uint8_t[32];

template <typename T>
class StringCache
{
   public:
      bool addString(const T &userKey, const std::string &value)
      {
         auto [it, result] = m_cache.try_emplace(userKey, value);
         // ^^^^^^^ this line won't compile: array initializer must be an initializer list or string literal

      }
   private:
      struct EqualToFn {
        bool operator()(const T &left, const T &right) const {
            return std::memcmp(&left[0],
                               &right[0],
                               sizeof(T)) == 0;
        }
      };

      struct HashFn {
        size_t operator()(const T &k) const {
            return std::_Hash_impl::hash(k);
        }
      };

      std::unordered_map<T, std::string, HashFn, EqualToFn> cache_;
}

在使用中会是这样的:

StringCache<UserKey1> cache1;

uint8_t uniqueKey[16];  // this key was provided by 3rd party lib
cache1.addString(uniqueKey, strUsername)

由于上面列出的错误，这不会编译，但我不确定为什么。我为数组创建了自定义哈希函数和相等函数，以便它知道如何处理这样的键。我可能可以用 std::array 解决这个问题，然后先将 key 复制到它，但我想尽可能避免这种情况，因为它会涉及一个拷贝，并且这段代码可能每秒被调用 1000 次。

我正在努力实现的目标是可能的还是我只是使用 std::array 作为键？

Answer 1

它与 std::array 配合良好

  #include <cstdlib>                                                                 
  #include <iostream>                                                                
  #include <unordered_map>                                                           
  #include <cstring>                                                                 
  #include <array>                                                                   
                                                                                     
  using UserKeyV1 = std::array<unsigned char,16>;                                    
                                                                                     
  template <typename T>                                                              
  class StringCache                                                                  
  {                                                                                  
     public:                                                                         
        bool addString(const T &userKey, const std::string &value)                   
        {                                                                            
           auto [it, result] = m_cache.try_emplace(userKey, value);                  
           // ^^^^^^^ this line won't compile: array initializer must be an initializer list or string literal
           return result;                                                         
                                                                                  
        }                                                                         
     private:                                                                        
        struct EqualToFn {                                                           
          bool operator()(const T &left, const T &right) const {                     
              return std::memcmp(&left[0],                                           
                                 &right[0],                                          
                                 sizeof(T)) == 0;                                    
          }                                                                          
        };                                                                           
                                                                                     
        struct HashFn {                                                              
          size_t operator()(const T &k) const {                                      
              return std::_Hash_impl::hash(k);                                       
          }                                                                          
        };                                                                           
                                                                                     
        std::unordered_map<T, std::string, HashFn, EqualToFn> m_cache;               
  };                                                                                 
                                                                                     
  int main()                                                                         
  {                                                                                  
      StringCache<UserKeyV1> cache1;                                                 
                                                                                     
      //uint8_t uniqueKey[16];  // this key was provided by 3rd party lib            
      UserKeyV1 uniqueKey;                                                           
      std::string strUsername = "username";                                          
      cache1.addString(uniqueKey, strUsername);                                      
  }