Question

我似乎错过了一些相当基本的东西。我正在尝试在编译时使用const数组成员。

const int list[3] = { 2, 5, 7 };
const int a = list[2]; // this doesn't error?

template<int N1, int N2>
struct tmax {
  enum { value = ((N1 > N2) ? N1 : N2) };
};

const int b = tmax<2,4>::value;
const int c = tmax<list[0],list[1]>::value; // error is here

int main()
{
  return 0;
}

错误：

prog.cpp:10:24: error: 'list' cannot appear in a constant-expression
prog.cpp:10:30: error: an array reference cannot appear in a constant-expression

以下是relevent IDEOne link

那么为什么这不起作用？我错过了什么？我该怎么办？

Answer 1

仅仅因为对象是const并不意味着它是编译时常量表达式。

main.cpp:10:20: error: non-type template argument is not a constant expression
const int c = tmax<list[0],list[1]>::value; // error is here
                   ^~~~~~~
main.cpp:10:20: note: read of non-constexpr variable 'list' is not allowed in a constant expression
main.cpp:1:11: note: declared here
const int list[3] = { 2, 5, 7 };
          ^

这是constexpr：

的原因

constexpr int list[3] = { 2, 5, 7 };

template<int N1, int N2>
struct tmax {
    enum { value = ((N1 > N2) ? N1 : N2) };
};

const int b = tmax<2,4>::value;
const int c = tmax<list[0],list[1]>::value; // works fine now

至于为何这样做：

const int a = list[2]; // this doesn't error?

初始化const变量不需要常量表达式：

int foo(int n) {
    const int a = n; // initializing const var with a non-compile time constant

Answer 2

表达式不是常量表达式，如果它们包含许多不允许的子表达式中的任何一个。一类这样的不允许的子表达式是：

左值 - 右值转换（4.1），除非它适用于


一个整数或枚举类型的glvalue，它引用具有前面的非易失性const对象   初始化，用常量表达式初始化，或

一个文字类型的glvalue，它引用一个用constexpr定义的非易失性对象，或者引用   到这样一个对象的子对象，或

文字类型的glvalue，指的是一生中没有的非易失性临时对象   结束，用常量表达式初始化;

特别是，使用常量初始值设定项初始化的枚举或整数类型的const对象的名称形成常量表达式（读取其值是导致左值到右值转换的原因）， const聚合对象的子对象（例如示例中的list，数组）不会，但如果声明为constexpr。

const int list[3] = { 2, 5, 7 };
const int a = list[2];

这是有效的，但a不构成常量表达式，因为它未使用常量表达式进行初始化。

通过更改list的声明（我们不必更改a的声明），我们可以使a形成一个常量表达式。

constexpr int list[3] = { 2, 5, 7 };
const int a = list[2];

由于list[2]现在是常量表达式，a现在是使用常量表达式初始化的整数类型的const对象所以a现在可以用作常量表达式。

编译时数组常量

2 个答案: