C++ C语言的constexpr（或同等语言）

我正在尝试使用哈希函数使基于字符串的开关表达式在C中工作。我已经能够使用干净的语法使用“CysExpRPR”，使用CLAN/LLVM转换为C++，即使代码是C.

<>当然，它编译成C++的奇特的副作用，如缺少空洞*隐式的铸造，变得非常尴尬。

因此，问题是如何解决这一困境（而不让C11委员会为为什么没有将其添加到C规范而大发雷霆）

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

<> LI>有没有一种方法可以用C++？

在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;
    }
}

---

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

这在C中不起作用。大小写标签的值必须是常量

您可以做的是预先计算

cHash（“first”）

等的输出，然后使用

案例中的值，例如：

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

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

}

为了扩展此功能，您可以构建另一个二进制文件，该二进制文件只计算哈希值，将其作为构建过程的一部分运行，并使用在编译行上作为预处理器定义生成的值

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

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

有没有一种方法可以用C++ ++？
不，C++具有指针的强制类型安全性。
在C11/C99中是否有另一种不需要重新计算散列的干净编码方法
唯一可以做到这一点的方法是使用宏的传统方法。若您使用这些参数创建了一个类似于宏的函数，并且只在编译时常量上使用它，那个么所有的计算都将在编译时完成。不幸的是，代码会变得相当难看，但在C中无法避免

最好的方法可能是使用外部脚本/程序准备所有此类编译时参数，然后将它们作为原始数据表存储在C程序中。
如果您使用内联函数并通过优化编译代码，一个合适的编译器应该能够应用于您的代码。下面是一个小例子：

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将优化对
散列（“hello”，basis）
的调用，并静态地将其替换为常量。如果生成LLVM字节码（
clang-S-emit LLVM example.c
），您可以看到优化：

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

这可能不像你想象的那么难，这取决于你的
constepr
s有多复杂。有无数的C解析器是用各种脚本语言编写的（例如Python）。然后你需要做的就是走你的C AST并应用你认为合适的自定义预处理过程。
我参加聚会有点晚，但最近遇到了同样的问题

对于这样一个简单的哈希函数，您可以使用C预处理器来实现它。缺点是预处理器无法将字符串拆分为字符，因此您必须编写
hash（'f'，'i'，'r'，'s'，'t'）
，而不是
hash（“first”）
。
HASH
宏是使用来实现的，它适用于最多包含八个字符的字符串

我还将散列函数从递归函数转换为迭代函数，这更易于阅读，并且不需要可选参数。生成的程序集几乎相同（）

#包括
typedef无符号长uint64；
#定义HASH_基17UL
#定义散列素数11UL
#定义散列1（ARG1）（（ARG1^散列基础）*散列素数）
#定义散列2（ARG1，ARG2）（（ARG2^散列1（ARG1））*散列素数）
#定义散列3（ARG1，ARG2，ARG3）（（ARG3^散列2（ARG1，ARG2））*散列素数）
#定义散列_4（ARG1、ARG2、ARG3、ARG4）\
（（ARG4^HASH_3（ARG1，ARG2，ARG3））*HASH_素数）
#定义散列_5（ARG1、ARG2、ARG3、ARG4、ARG5）\
（（ARG5^散列4（ARG1，ARG2，ARG3，ARG4））*散列素数）
#定义哈希_6（ARG1、ARG2、ARG3、ARG4、ARG5、ARG6）\
（（ARG6^HASH_5（ARG1、ARG2、ARG3、ARG4、ARG5））*HASH_PRIME）
#定义散列_7（ARG1、ARG2、ARG3、ARG4、ARG5、ARG6、ARG7）\
（（ARG7^HASH_6（ARG1、ARG2、ARG3、ARG4、ARG5、ARG6））*HASH_PRIME）
#定义散列_8（ARG1、ARG2、ARG3、ARG4、ARG5、ARG6、ARG7、ARG8）\
（（ARG8^HASH_7（ARG1、ARG2、ARG3、ARG4、ARG5、ARG6、ARG7））*HASH_PRIME）
#定义散列计数（ARG1、ARG2、ARG3、ARG4、ARG5、ARG6、ARG7、ARG8、func等）\
func
#定义散列（…）\
哈希计数（uuu VA_ARGS_uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu\
哈希值6（uuu VA_ARGS_uuuu）、哈希值5（uuu VA_ARGS_uuu）、哈希值4（uuu VA_ARGS_uuu）\
哈希值3（uuu VA_ARGS_uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
uint64哈希（常量字符*文本）{
uint64 h=散列基础；
字符c；
而（（c=*text++）！='\0'）{
h=（c^h）*散列素数；
}
返回h；
}
int main（int argc，char*argv[]）{
常量字符*text=argc>1？argv[1]：“”；
开关（散列（文本））{
大小写哈希（'f'，'i'，'r'，'s'，'t'）：
放置（文本）；
打破
大小写哈希（'s'，'e'，'c'，'o'，'n'，'d'）：
放置（文本）；
打破
大小写散列（'t'，'h'，'i'，'r'，'d'）：
放置（文本）；
布雷
; (...)
  %18 = icmp ne i32 %14, 20068367
  %19 = zext i1 %18 to i32
  br label %20
; (...)

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