Início / coding / Perguntas / 77812929
Accepted
Jeroen Boschma
Asked: 2024-01-14 04:07:15 +0800 CST

Calcule o hash da string 'const char *' em tempo de compilação

  • 772

Eu tenho uma função que calcula o hash de uma string literal:

inline consteval uint64_t HashLiteral(const char* key)
{
   // body not important here...
   return 0;
}

Em outra função, preciso da string literal e do hash que desejo calcular em tempo de compilação:

void function(const char* s)
{
   worker(s, HashLiteral(s));
}

No entanto, parece impossível fazer tal chamada function("string")e ter o hash calculado em seu corpo em tempo de compilação. O melhor que descobri agora é usar uma macro e redefinir a função:

#define MakeHashParms(s)   s,HashLiteral(s)
void function(const char* s, const uint64_t hash)
{
   worker(s, hash);
}
function(MakeHashParms("string"));

É possível uma solução mais direta?

c++

2 respostas

  1. Best Answer

    Você pode modificar functionpara aceitar uma estrutura de "string com hash" que pode ser construída implicitamente a partir de um arquivo const char*. Se você fizer o construtor de conversão consteval, poderá garantir que o hash será sempre computado em tempo de compilação.

    #include <cstdint>

inline consteval std::uint64_t HashLiteral(const char*)
{
   // body not important here...
   return 0;
}

struct HashedString {
    const char* str;
    std::uint64_t hash;

    consteval HashedString(const char* s)
        : str{s}, hash{HashLiteral(s)} {}
};

void worker(const char*, std::uint64_t) {};

void function(HashedString s)
{
    worker(s.str, s.hash);
}

int main() 
{
    function("string");  // OK: hash computed at compile time

    const char* x = "runtime string";
    // function(x);      // error: x is not constant expression
}

    Experimente online no godbolt

    • 3

  2. O problema é que o compilador precisa gerar a versão em tempo de execução function()e não existe uma versão em tempo de execução HashLiteral()para fazer isso.

    Você tem que calcular o hash externo à function()função, mas não precisa usar macros para isso. Você pode usar uma estrutura como Brian sugeriu em sua resposta ou apenas fazer com que sua HashLiteral()função agrupe a string original com o hash, por exemplo:

    #include <cstdint>
#include <tuple>

inline consteval auto HashLiteral(const char* s)
{
   // body not important here...
    return std::make_tuple(s, 0);
}

void worker(const char*, uint64_t)
{
    // do work
}

void function(const std::tuple<const char*, uint64_t>& sh)
{
    worker(std::get<0>(sh), std::get<1>(sh));
}

int main()
{
    function(HashLiteral("string"));
}

    Veja aqui: https://godbolt.org/z/b16MejEqG

    ATUALIZAR:

    Para maior brevidade (obrigado Brian) e legibilidade, você também pode fazer o seguinte:

    #include <cstdint>
#include <tuple>

consteval auto HashLiteral(const char* s)
{
    std::uint64_t hash = 0;
    // body not important here...
    return std::make_tuple(s, hash);
}

void worker(const char*, std::uint64_t)
{
    // do work
}

void function(const auto& sh)
{
    const auto& [s, hash] = sh;
    worker(s, hash);
}

consteval auto operator""_hashed(const char* s, std::size_t) { return HashLiteral(s); }

int main()
{
    function("string"_hashed);
}

    Ref: https://godbolt.org/z/ssqoz91qs

    • 2

relate perguntas