主页 / coding / 问题 / 77812929
Accepted
Jeroen Boschma
Asked: 2024-01-14 04:07:15 +0800 CST

在编译时计算“const char *”字符串哈希

  • 772

我有一个计算字符串文字的哈希值的函数：

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

在另一个函数中，我需要文字字符串及其哈希值，我想在编译时计算它：

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

然而，似乎不可能进行这样的调用function("string")，并在编译时在其主体中计算哈希值。我现在想到的最好方法是使用宏，并重新定义函数：

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

是否可以有更直接的解决方案？

c++

2 个回答

  1. Best Answer

    您可以修改function以接受“散列字符串”结构，该结构可以从const char*. 如果您进行转换构造函数consteval，则可以保证哈希值始终在编译时计算。

    #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
}

    在 godbolt 上在线尝试

    • 3

  2. 问题是编译器必须生成运行时版本function()，但没有运行时版本HashLiteral()来执行此操作。

    您必须计算function()函数外部的哈希值，但不必为此使用宏。您可以使用 Brian 在他的回答中建议的结构，或者只是让您的HashLiteral()函数将原始字符串与哈希捆绑在一起，例如：

    #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"));
}

    请参阅此处： https: //godbolt.org/z/b16MejEqG

    更新：

    为了更加简洁（感谢布莱恩）和可读性，你也可以这样做：

    #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);
}

    参考： https: //godbolt.org/z/ssqoz91qs

    • 2

相关问题