c++ - constexpr 和使用重新解释强制转换的静态 const void 指针的初始化，哪个编译器是正确的？

Question

考虑以下代码:

struct foo {
  static constexpr const void* ptr = reinterpret_cast<const void*>(0x1);
};

auto main() -> int {
  return 0;
}

上面的例子在 g++ v4.9 ( Live Demo ) 中编译良好，而在 clang v3.4 ( Live Demo ) 中编译失败并产生以下错误:

error: constexpr variable 'ptr' must be initialized by a constant expression

问题:

• 根据标准，这两个编译器哪个是正确的？

• 声明此类表达式的正确方法是什么？

Answer 1

TL;DR

clang 是正确的，这是已知的 gcc 错误。您可以改用 intptr_t 并在需要使用该值时进行强制转换，或者如果这不可行，则 gcc 和 clang 都支持一点记录在案的解决方法应该允许您的特定用例。

详情

所以如果我们转到 draft C++11 standard，clang 是正确的。 5.19 常量表达式 小节 2 说:

A conditional-expression is a core constant expression unless it involves one of the following as a potentially evaluated subexpression [...]

并包括以下项目符号:

— a reinterpret_cast (5.2.10);

一个简单的解决方案是使用 intptr_t :

static constexpr intptr_t ptr = 0x1;

然后在需要时再施放:

reinterpret_cast<void*>(foo::ptr) ;

这可能很诱人，但这个故事变得更有趣了。这是已知且仍然打开的 gcc 错误参见 Bug 49171: [C++0x][constexpr] Constant expressions support reinterpret_cast .从讨论中可以清楚地看出，gcc 开发人员对此有一些明确的用例:

I believe I found a conforming usage of reinterpret_cast in constant expressions useable in C++03:

//---------------- struct X {  X* operator&(); };

X x[2];

const bool p = (reinterpret_cast<X*>(&reinterpret_cast<char&>(x[1]))
- reinterpret_cast<X*>(&reinterpret_cast<char&>(x[0]))) == sizeof(X);

enum E { e = p }; // e should have a value equal to 1
//----------------

Basically this program demonstrates the technique, the C++11 library function addressof is based on and thus excluding reinterpret_cast unconditionally from constant expressions in the core language would render this useful program invalid and would make it impossible to declare addressof as a constexpr function.

但无法为这些用例生成异常，请参阅 closed issues 1384 :

Although reinterpret_cast was permitted in address constant expressions in C++03, this restriction has been implemented in some compilers and has not proved to break significant amounts of code. CWG deemed that the complications of dealing with pointers whose tpes changed (pointer arithmetic and dereference could not be permitted on such pointers) outweighed the possible utility of relaxing the current restriction.

BUT 显然 gcc 和 clang 支持一个小文档扩展，允许使用 __builtin_constant_p (exp) 对非常量表达式进行常量折叠因此 gcc 和 clang 都接受以下表达式:

static constexpr const void* ptr = 
  __builtin_constant_p( reinterpret_cast<const void*>(0x1) ) ? 
    reinterpret_cast<const void*>(0x1) : reinterpret_cast<const void*>(0x1)  ;

找到这方面的文档几乎是不可能的，但是 llvm commit is informative以下片段提供了一些有趣的阅读:

support the gcc __builtin_constant_p() ? ... : ... folding hack in C++11

和:

// __builtin_constant_p ? : is magical, and is always a potential constant.

和:

// This macro forces its argument to be constant-folded, even if it's not
// otherwise a constant expression.
#define fold(x) (__builtin_constant_p(x) ? (x) : (x))

我们可以在 gcc-patches 电子邮件中找到对此功能更正式的解释:C constant expressions, VLAs etc. fixes其中说:

Furthermore, the rules for __builtin_constant_p calls as conditional expression condition in the implementation are more relaxed than those in the formal model: the selected half of the conditional expression is fully folded without regard to whether it is formally a constant expression, since __builtin_constant_p tests a fully folded argument itself.