es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Cómo pasar un tipo de referencia a std::hash

01 Aug, 2023 Programación

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>

Tags:  , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    El mensaje de error indica que no hay ningún constructor definido para la clase std::hash<key> que tome un argumento const Key&. Esto se debe a que la clase std::hash define un operator() que toma un único argumento de tipo Key, el cual se utiliza para calcular el valor hash.

    Para solucionar el error, simplemente puedes llamar al método operator() del objeto std::hash, pasando el parámetro key:

    return std::hash<key>()(key);

    Esto utilizará la implementación predeterminada de std::hash para tipos primitivos como int, 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:

    namespace std {
    template<>
    struct hash<mitipo> {
        size_t operator()(const MiTipo& obj) const {
            // implementación de la función de hash personalizada aquí
        }
    };
}

    Esto permitirá el uso de std::hash<mitipo> en tu clase Cache, sin necesidad de pasar explícitamente una función de hash personalizada.

Comments are closed.