Question

我正在尝试使用哈希函数获取基于字符串的开关表达式在C中工作。我已经能够使用＆＃39; constexpr＆＃39;使用干净的语法来使用它。使用Clang / LLVM转向C ++，即使代码为C.

然而，编译为C ++当然有一些奇怪的副作用，就像缺少void *隐式转换一样，这会变得非常尴尬。

所以问题是如何解决这个难题（没有打破C11委员会对于为什么没有加入C规范的问题）

有没有办法让C语言启用constexpr选项？
有没有办法用C ++启用隐式void *转换？
在C11 / C99中是否有另一种干净的方法来编写这个并不需要重新计算哈希值？

这是我目前的示例代码：

constexpr uint64 cHash(char const* text, uint64 last_value = basis)
{
    return *str ? cHash(text+1, (*text ^ last_value) * prime) : last_value;
}

void SwitchFunction(char const* text)
{
    switch(Hash(text))
    {
        case cHash("first"):
            break;
        case cHash("second"):
            break;
        case cHash("third"):
            break;
        default:
            break;
    }
}

Answer 1

这不适用于C.案例标签的值必须保持不变。

您可以做的是预先计算cHash("first")等的输出，然后使用case中的值，例如：

#define CHASH_FIRST 0x831928 /* precalculated output for cHash ("first") */

switch (Hash(text))
{
   case CHASH_FIRST:
     break;

}

为了扩展它，你可以构建另一个只计算哈希值的二进制文件，在构建过程中运行它，并使用在编译行上使用预生成器定义生成的值。

Answer 2

如果您使用内联函数并使用优化编译代码，那么一个不错的编译器应该能够将constant propagation应用于您的代码。这是一个小例子：

const int basis = 17;
inline const int hash(const char* text, int last_value) {
  return *text ? hash(text + 1, (*text ^ last_value) * 11) : last_value;
}

int main(int argc, const char** argv) {
  if (hash(argv[0], basis) == hash("hello", basis)) {
    return 0;
  } else {
    return 1;
  }
}

如果使用-O3标记调用，则clang会优化对hash("hello", basis)的调用，并将其替换为静态常量。如果生成LLVM字节代码（clang -S -emit-llvm example.c），则可以看到优化：

; (...)
  %18 = icmp ne i32 %14, 20068367
  %19 = zext i1 %18 to i32
  br label %20
; (...)

不幸的是，这并不意味着您可以在代码中使用hash 作为实际常量表达式，因为无法告诉编译器hash必须是静态可优化的。因此，例如，您不能将它用作switch-case的值。对于这些特殊用例（没有双关语），你别无选择，只能使用预先计算的常量（即Lundin的建议）。

这可能不像你想象的那么难，取决于你constexpr的复杂程度。有无数的C语言分析器用各种脚本语言编写（例如Python的pycparser）。然后你需要做的就是走你的C AST并应用你认为合适的任何自定义预处理过程。

Answer 3

如果你知道要提前散列的值，那么你可以使用gperf并生成一个完美的哈希？ C与constexpr不会很好。

Answer 4

有没有办法让C开启constexpr选项？

不，C中没有这样的东西。

有没有办法用C ++启用隐式void *转换？

不，C ++具有强制类型指针安全性。

在C11 / C99中是否有另一种干净的方法来编写这个并不需要重新计算哈希值？

唯一可行的方法是使用宏的传统方式。如果您使用这些参数创建类似函数的宏，并且仅在编译时常量上使用它，那么所有计算都将在编译时完成。不幸的是，代码会变得相当丑陋，但是在C中没有办法避免这种情况。

最好的方法可能是使用外部脚本/程序准备所有这些编译时参数，然后将它们作为原始数据表存储在C程序中。

Answer 5

我参加聚会有点晚，但最近遇到了同样的问题。

对于这样一个简单的哈希函数，您只需使用C预处理器即可实现。缺点是预处理器无法将字符串拆分为字符，因此您必须编写hash("first")而不是HASH('f','i','r','s','t')。 HASH宏是使用__VA_ARGS__实现的，适用于最多八个字符的字符串。

我还把散列函数从递归函数变成了迭代函数，它比较容易阅读，不需要可选参数。生成的程序集几乎相同（https://godbolt.org/z/1g8LPI）。

#include <stdio.h>

typedef unsigned long uint64;

#define HASH_BASIS 17UL
#define HASH_PRIME 11UL

#define HASH_1(ARG1) ((ARG1 ^ HASH_BASIS) * HASH_PRIME)
#define HASH_2(ARG1, ARG2) ((ARG2 ^ HASH_1(ARG1)) * HASH_PRIME)
#define HASH_3(ARG1, ARG2, ARG3) ((ARG3 ^ HASH_2(ARG1, ARG2)) * HASH_PRIME)
#define HASH_4(ARG1, ARG2, ARG3, ARG4)                                         \
    ((ARG4 ^ HASH_3(ARG1, ARG2, ARG3)) * HASH_PRIME)
#define HASH_5(ARG1, ARG2, ARG3, ARG4, ARG5)                                   \
    ((ARG5 ^ HASH_4(ARG1, ARG2, ARG3, ARG4)) * HASH_PRIME)
#define HASH_6(ARG1, ARG2, ARG3, ARG4, ARG5, ARG6)                             \
    ((ARG6 ^ HASH_5(ARG1, ARG2, ARG3, ARG4, ARG5)) * HASH_PRIME)
#define HASH_7(ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7)                       \
    ((ARG6 ^ HASH_6(ARG1, ARG2, ARG3, ARG4, ARG5, ARG6)) * HASH_PRIME)
#define HASH_8(ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7, ARG8)                 \
    ((ARG8 ^ HASH_7(ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7)) * HASH_PRIME)

#define HASH_COUNT(ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7, ARG8, func, ...)  \
    func

#define HASH(...)                                                              \
    HASH_COUNT(__VA_ARGS__, HASH_8(__VA_ARGS__), HASH_7(__VA_ARGS__),          \
               HASH_6(__VA_ARGS__), HASH_5(__VA_ARGS__), HASH_4(__VA_ARGS__),  \
               HASH_3(__VA_ARGS__), HASH_2(__VA_ARGS__), HASH_1(__VA_ARGS__))

uint64 hash(const char *text) {
    uint64 h = HASH_BASIS;
    char c;
    while ((c = *text++) != '\0') {
        h = (c ^ h) * HASH_PRIME;
    }
    return h;
}

int main(int argc, char *argv[]) {
    const char *text = argc > 1 ? argv[1] : "";
    switch (hash(text)) {
    case HASH('f', 'i', 'r', 's', 't'):
        puts(text);
        break;
    case HASH('s', 'e', 'c', 'o', 'n', 'd'):
        puts(text);
        break;
    case HASH('t', 'h', 'i', 'r', 'd'):
        puts(text);
        break;
    default:
        puts("oops");
        break;
    }
}

c中的constexpr（或等价物）

5 个答案: