C语言中的constexpr（或等效语言）

Question

我正在尝试使用哈希函数在C中使用基于字符串的开关表达式。我已经能够使用'constexpr'使它与干净的语法一起使用，并且Clang / LLVM转换为C ++，即使代码是C。

但是，将其作为C ++进行编译当然会有一些奇怪的副作用，例如缺少void *隐式转换会变得很尴尬。

因此，问题是如何解决这个难题（为什么不将C11委员会的掌声压在C规范上）

1. 有没有办法用C打开constexpr选项？
2. 有没有办法让C ++启用隐式void *强制转换？
3. 是否有另一种干净的方法可以在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

如果您使用内联函数并通过优化来编译代码，那么优秀的编译器应该能够将常量传播应用于您的代码。这是一个小例子：

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 的建议）。

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

Answer 2

如果您知道要提前散列的值，那么您可以使用gperf并生成一个完美的散列吗？C 不能很好地与 constexpr 配合使用。

Answer 3

有没有办法用 C 打开 constexpr 选项？

不，C 中不存在这样的东西。

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

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

在 C11/C99 中是否有另一种不需要重新计算散列的干净方法来编码它？

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

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

Answer 4

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

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

我还把散列函数从递归函数变成了迭代函数，它比较容易阅读，不需要可选参数。生成的程序集几乎相同（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)                       \
    ((ARG7 ^ 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;
    }
}