Cómo pasar un tipo de referencia a std::hash
Estoy creando una biblioteca de Caché de Plantillas en C++-11 en la que quiero hashar las claves. Quiero usar la función predeterminada std::hash
para tipos primitivos/predefinidos como int, std::string, etc.
y funciones de hash definidas por el usuario para tipos definidos por el usuario. Mi código actual se ve así:
template<typename key,="" typename="" value="">
class Cache
{
typedef std::function<size_t(const key="" &)=""> HASHFUNCTION;
private:
std::list<><key, value="">*> m_keys;
std::unordered_map<size_t, typename=""></size_t,><><key, value="">*>::iterator> m_cache;
size_t m_Capacity;
HASHFUNCTION m_hash;
size_t getHash(const Key& key) {
if(m_hash == nullptr) {
return std::hash<key>()(key); // Línea de error
}
else
return m_hash(key);
}
public:
Cache(size_t size) : m_Capacity(size) {
m_hash = nullptr;
}
Cache(size_t size, HASHFUNCTION hash) : m_Capacity(size), m_hash(hash) {}
void insert(const Key& key, const Value& value) {
size_t hash = getHash(key);
// ...
}
bool get(const Key& key, Value& val) {
size_t hash = getHash(key);
// ...
}
};
int main() {
Cache<int, int=""> cache(3);
cache.insert(1, 0);
cache.insert(2, 0);
int res;
cache.get(2, &res);
}
Al compilar el código anterior, obtengo el siguiente error:
error: la función no tiene coincidencias para ‘std::hash<int>::hash(const int&)’
return std::hash<key>()(key);
¿Alguien puede ayudarme y señalar qué estoy olvidando o haciendo incorrectamente?</int,></key,></key,></size_t(const>
davy.ai
El mensaje de error indica que no hay ningún constructor definido para la clase
std::hash<key>
que tome un argumentoconst Key&
. Esto se debe a que la clasestd::hash
define unoperator()
que toma un único argumento de tipoKey
, el cual se utiliza para calcular el valor hash.Para solucionar el error, simplemente puedes llamar al método
operator()
del objetostd::hash
, pasando el parámetrokey
:Esto utilizará la implementación predeterminada de
std::hash
para tipos primitivos comoint
, y llamará a la función de hash personalizada proporcionada por el usuario para tipos definidos por el usuario.Como alternativa, puedes proporcionar una especialización de hash personalizada para tu tipo definido por el usuario:
Esto permitirá el uso de
std::hash<mitipo>
en tu claseCache
, sin necesidad de pasar explícitamente una función de hash personalizada.