GCC与Clang在C++常量求值上下文的行为差异及合规性问询

我发现GCC和Clang对C++常量求值上下文的判定存在不一致，为此编写了测试代码验证这一差异：

#include <iostream>
#include <type_traits>

consteval auto ceval(auto x) { return x * x; }

constexpr auto constexprif(auto x) {
    if constexpr (std::is_integral_v<decltype(x)>) {
        return ceval(x);
    } else {
        return x + 2.;
    }
}
constexpr auto constexprif_consteval(auto x) {
    if constexpr (std::is_integral_v<decltype(x)>) {
        if consteval {
            return ceval(x);
        } else {
            return x * x + 1;
        }
    } else {
        return x + 2.;
    }
}

constexpr auto constevalif(auto x) {
    if consteval {
        return ceval(x);
    } else {
        return static_cast<decltype(x)>(x + 2.);
    }
}

constexpr auto isconstantevaluated(auto x) {
    if (std::is_constant_evaluated()) {
        return ceval(x);
    } else {
        return static_cast<decltype(x)>(x + 2.);
    }
}

int main() {
#ifdef __clang__  // GCC KO
    auto a = constexprif(42);
    const auto b = constexprif(42);
    constexpr auto c = constexprif(42);
    std::cout << "constexprif " << a << '\t' << b << '\t' << c << '\n';
#endif
    auto d = constexprif_consteval(42);
    const auto e = constexprif_consteval(42);
    constexpr auto f = constexprif_consteval(42);
    std::cout << "constexprif_consteval " << d << '\t' << e << '\t' << f
              << '\n';
    auto g = constevalif(42);
    const auto h = constevalif(42);
    constexpr auto i = constevalif(42);
    std::cout << "constevalif " << g << '\t' << h << '\t' << i << '\n';
// auto j = isconstantevaluated(42);
#ifdef __clang__  // GCC KO
    const auto k = isconstantevaluated(42);
    constexpr auto l = isconstantevaluated(42);
    std::cout << "isconstantevaluated " << k << '\t' << l << '\n';
#endif
}

测试函数说明 #

• ceval：基础consteval函数，用于验证其在constexpr函数中的调用上下文；
• constexprif：尝试在参数为整数类型时返回ceval(x)，存在错误；
• constexprif_consteval：修复版本，仅在常量求值上下文调用ceval；
• constevalif：通过if consteval分支在常量上下文调用ceval；
• isconstantevaluated：使用std::is_constant_evaluated()替代if consteval。

编译器输出 #

GCC输出

constexprif_consteval 1765    1764    1764
constevalif 44    1764    1764

Clang输出

constexprif 1764    1764    1764
constexprif_consteval 1764    1764    1764
constevalif 1764    1764    1764
isconstantevaluated 1764    1764

行为差异分析 #

GCC行为

• 拒绝constexprif的所有调用：认为整数类型的实例化版本可能在运行时被调用，而consteval函数仅允许在常量求值上下文执行；
• 对constexprif_consteval和constevalif，根据变量初始化上下文选择分支：运行时初始化（非constexpr变量）走非consteval分支，编译期初始化（constexpr变量）走consteval分支；
• 始终拒绝isconstantevaluated的调用：std::is_constant_evaluated()是运行时判断，无法保证ceval只在常量上下文被调用。

Clang行为

• 只要参数在编译期可知，就接受constexprif的调用并选择常量求值分支；
• 对constexprif_consteval、constevalif和isconstantevaluated，均在参数为编译期常量时选择常量求值分支，所有初始化方式都得到ceval(x)的结果。

标准一致性判断 #

GCC的行为更贴合C++标准的严格要求：

1. constexpr函数必须保证所有可能的执行路径都能在常量求值上下文执行（除非用if consteval等条件分支隔离运行时路径）。constexprif中直接调用consteval函数，未隔离运行时路径，因此GCC拒绝该函数实例化是合规的——因为该函数可能被用于运行时上下文，而consteval调用在运行时属于非法操作。
2. std::is_constant_evaluated()是运行时可用的判断，它不能改变函数的常量可用性。即使参数是编译期常量，isconstantevaluated函数中仍存在运行时调用ceval的可能路径，因此GCC拒绝它是正确的。
3. if consteval是C++20引入的常量上下文分支，能确保分支内代码仅在常量求值上下文执行，因此GCC根据初始化上下文选择分支的行为符合标准。

Clang采取了更宽松的推断策略，认为当参数为编译期常量时，函数不会进入非法运行时路径，因此接受了相关调用，但这种行为并不完全符合标准的严格定义。

内容的提问来源于stack exchange，提问作者Oersted