为什么常量指针不能是常量表达式？

Question

以下程序编译：

template <const int * P>
class Test{};

extern const int var = 42; //extern needed to force external linkage

int main()
{
    Test<&var> test;
}

然而，这个没有，这对我来说是一个惊喜：

template <const int * P>
class Test{};

extern const int var = 42; //extern needed to force external linkage
extern const int * const ptr = &var; //extern needed to force external linkage
int main()
{
    Test<ptr> test; //FAIL! Expected constant expression.
}

替代示例：

int main()
{
   const int size = 42;
   int ok[*&size]; //OK

   const int * const pSize = &size;
   int fail[*pSize]; //FAIL
}

我得出的结论是，指针不能是常量表达式，无论它是否为 const 并使用常量表达式进行初始化。

问题：

1. 我的结论是真的吗？
2. 如果是这样，为什么指针不能是常量表达式？如果没有，为什么上面的程序不能编译？
3. C++0x（C++11，如果你愿意的话）有什么改变吗？

感谢您的任何见解！

Answer 1

这有点复杂。在 C++03 和 C++11 中，如果 var 是本地静态/类静态或命名空间范围变量，则 &var 是常量表达式。这称为地址常量表达式。使用该常量表达式初始化类静态或命名空间范围指针变量保证在任何代码运行之前完成（静态初始化阶段），因为它是一个常量表达式。

但是只有从 C++11 开始，存储地址 &var 的 constexpr 指针变量也可以用作地址常量表达式，并且只有从 C++11 开始，您可以取消引用地址常量表达式（实际上，您可以取消引用更多 - 甚至是本地数组元素地址，但让我们保持主题）并且如果它引用在取消引用之前初始化的常量整数变量或 constexpr 变量，您将再次获得一个常量表达式（根据类型和值类别，常量表达式的种类可能会有所不同）。因此，以下是有效的 C++11：

int const x = 42;
constexpr int const *px = &x;

// both the value of "px" and the value of "*px" are prvalue constant expressions
int array[*px];
int main() { return sizeof(array); }

如果是这样，为什么指针不能是常量表达式？如果没有，为什么上面的程序不能编译？

这是标准措辞中的一个已知限制 - 它目前只允许其他模板参数作为参数或& object，用于指针类型的模板参数。即使编译器应该能够做更多的事情。

Answer 2

在 C++0x 中仍然不允许。 temp.arg.nontype 要求：

非类型、非模板模板参数的模板参数应为以下之一：

• 对于整数或枚举类型的非类型模板参数，模板参数类型的转换常量表达式 (5.19)；或
• 非类型模板参数的名称；或
• 一个常量表达式 (5.19)，它指定具有静态存储持续时间的对象的地址，并且 外部或内部链接或具有外部或内部链接的功能，包括功能模板 和函数模板 ID，但不包括非静态类成员，表示（忽略括号）为 & id-expression，但如果名称指的是函数或数组，则 & 可以省略，并且应该 如果相应的模板参数是引用，则省略；或
• 计算结果为空指针值的常量表达式 (4.10)；或
• 计算结果为空成员指针值的常量表达式 (4.11)；或
• 指向成员的指针，如 5.3.1 中所述。

---

原答案：

1. 在 C++03 中，只有整数表达式可以是常量表达式。
2. 因为标准是这样说的（自然）。
3. 在 C++0x 中，n3290 包括在指针上使用 constexpr 的示例。因此，您现在尝试的应该是可能的，尽管您现在必须使用 constexpr 关键字而不是顶级 const。

还有一个 gcc 错误，g++ rejects the standard draft's own examples of valid constexpr usage。

Answer 3

问题是因为您的 C++ 程序可以在内存中的任何位置加载，因此每次运行程序时全局var 的地址可能不同。如果你运行你的程序两次会发生什么？ var 那么显然在两个不同的位置。

更糟糕的是，在您的示例中，您获取了堆栈上变量的地址！看看这个：

void myfunction( unsigned int depth) {
     const int myvar = depth;
     const int * const myptr = &myvar;
     if (depth)
         myfunction(depth-1);
}

如果 main 调用 myfunction(3)，则在不同的位置创建 3 个 myvar。编译时甚至无法知道创建了多少 个 myvar，更不用说确切的位置了。

最后：将变量声明为const 意味着：“我保证”，not 是否意味着这是一个编译时间常数。看这个例子：

int main(int argc, char** argv) {
    const int cargc = argc;
    char* myargs[cargc]; //the size is constant, but not a _compile time_ constant.
}