blocks|key|175103|text|在5.19中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175104|175105|+...expression是一个常量表达式，除非它包含以下内容之一...：|blockquote|175106|175107|175108|175109|左值到右值的转换(4.1)，除非它应用于|unordered-list-item|175110|175111|-+a+glvalue+of+integral+or+enumeration+type+that+refers+to+a+non-volatile+const+object+with+a+preceding+initialization,+initialized+with+a+constant+expression,+or
-+a+glvalue+of+literal+type+that+refers+to+a+non-volatile+object+defined+with+constexpr,+or+that+refers+++to+a+sub-object+of+such+an+object,+or
-+a+glvalue+of+literal+type+that+refers+to+a+non-volatile+temporary+object+initialized+with+a+constant+++expression|code-block|syntax|javascript|175112|​|175113|简单地说，左值到右值的转换只能在满足以下条件的常量表达式中完成：|175114|使用常量expression...初始化的带有constant：const+int+x+=+3;.|offset|length|style|CODE|175115|a声明的constant：constexpr+int+x[]+=+{1,2,3};.|175116|
|175117|a临时对象初始化的常量整数(或枚举)声明constexpr|175118|175119|您的示例确实包含了左值到右值的转换，但没有任何例外，因此x不是常量表达式。但是，如果您将其更改为：|175120|constexpr+int+x[]+=+{1,2,3};

static_assert(x[0]+==+1,+"yay");

int+main()+{}|175121|那么一切都很好。|175122|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|W|G|0|D|S|0|0|K|9|0|0|S|1|0|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1I|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1M|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1O|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|1P|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1R|8|@$X|1S|Y|1T|Z|10]]|9|@]|A|$]]|$1|11|3|12|5|K|7|1U|8|@$X|1V|Y|1W|Z|10]]|9|@]|A|$]]|$1|13|3|14|5|6|7|1X|8|@]|9|@]|A|$]]|$1|15|3|16|5|K|7|1Y|8|@$X|1Z|Y|20|Z|10]]|9|@]|A|$]]|$1|17|3|-4|5|6|7|21|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|22|8|@$X|23|Y|24|Z|10]]|9|@]|A|$]]|$1|1A|3|1B|5|O|7|25|8|@]|9|@]|A|$P|Q]]|$1|1C|3|1D|5|6|7|26|8|@]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|27|8|@]|9|@]|A|$]]]|1F|$]]

In 5.19:

<blockquote>
 A [...]expression is a constant expression unless it involves one of the following [...]:
 
 <ul>
 <li>an lvalue-to-rvalue conversion (4.1) unless it is applied to
 
 <ul>
 <li>a glvalue of integral or enumeration type that refers to a non-volatile const object with a preceding initialization, initialized with a constant expression, or</li>
 <li>a glvalue of literal type that refers to a non-volatile object defined with constexpr, or that refers
 to a sub-object of such an object, or</li>
 <li>a glvalue of literal type that refers to a non-volatile temporary object initialized with a constant
 expression</li>
 </ul></li>
 </ul>
</blockquote>

Putting it plainly, lvalue-to-rvalue conversion can only be done in constant expressions if:

<ul>
<li>a constant integral (or enum) declaration initialized with a constant: <code>const int x = 3;</code>.</li>
<li>a declaration with <code>constexpr</code>: <code>constexpr int x[] = {1,2,3};</code>.</li>
<li>a temporary object initialized with a constant expression...</li>
</ul>

Your example does include lvalue-to-rvalue conversion, but has none of these exceptions, so <code>x</code> is not a constant expression. If, however, you change it to:

<pre><code>constexpr int x[] = {1,2,3};

static_assert(x[0] == 1, "yay");

int main() {}
</code></pre>

Then all is well.

blocks|key|2994137|text|根据标准的当前措辞，它是一个编译器错误，并且该程序是格式良好的。现在正在考虑它是否应该是一个标准缺陷，因为它将很难实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2994138|有关详细说明，请参阅：|2994139|https://groups.google.com/a/isocpp.org/forum/?fromgroups#!topic/std-discussion/Nv5_2dCHm6M|offset|length|2994140|报告复制如下：|2994141|2994142|+C%2B%2B11官方到N3690的当前措辞如下：|blockquote|2994143|2994144|条件表达式e是核心常量表达式，除非e的求值将计算以下表达式之一：|2994145|2994146|除非使用常量expression初始化的整数或枚举类型的非易失性GL值引用具有先前初始化的非易失性常量对象，否则|2994147|左值到右值转换(4.1)|unordered-list-item|2994148|2994149|​|2994150|以下是全局范围内的声明：|2994151|const+int+x2+=+{42，43}；|2994152|定义一个包含2个常量int对象的数组，使用{42,+++43}进行列表初始化|style|CODE|2994153|在8.5.1+dcl.init.aggr/2中：|2994154|当集合由初始化器列表初始化时，如8.5.4中所指定的，初始化器列表的元素以递增的下标或成员顺序作为集合成员的初始化器。|2994155|因此，第一个元素对象的初始化器是42，第二个元素对象的初始化器是43。|2994156|表达式*x是一个左值和核心常量表达式。它需要数组到指针的转换和间接性--这两者都不会使表达式丧失作为核心常量表达式的资格。glvalue表达式引用x的第一个element对象。*x是整数类型(const+int)的非易失性glvalue，它引用具有前面初始化的非易失性const对象，并使用常量表达式42进行初始化。|2994157|因此，在常量表达式中允许对glvalue+*x应用左值到右值的转换，因此下面的表达式格式良好：|2994158|constexpr+int+y=+*x；|2994159|无论是gcc还是clang目前都不接受这一常量表达，尽管根据标准它是很好的形式。|2994160|这是故意的吗？|2994161|完整的演示程序：|2994162|const+int+x2+=+{42，43}；const+main+int+y=+*x；int+main()+{}|2994163|同样，使用等效的左值x[0]实现也会失败。|2994164|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|2I|0|0|0|0|0|0|0|0|0|0|0|0|0|0|L|A|0|0|0|G|2|W|2|0|3|2|21|1|2G|2|46|2|0|L|2|0|0|0|0|0|0|A|4|0^^$0|@$1|2|3|4|5|6|7|20|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|21|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|22|8|@]|9|@$F|23|G|24|1|25]]|A|$]]|$1|H|3|I|5|6|7|26|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|27|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|28|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|29|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|2A|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|2C|8|@]|9|@]|A|$]]|$1|T|3|U|5|V|7|2D|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|2F|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2G|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|2H|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|2I|8|@$F|2J|G|2K|15|16]]|9|@]|A|$]]|$1|17|3|18|5|6|7|2L|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|2M|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|2N|8|@$F|2O|G|2P|15|16]|$F|2Q|G|2R|15|16]]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|2S|8|@$F|2T|G|2U|15|16]|$F|2V|G|2W|15|16]|$F|2X|G|2Y|15|16]|$F|2Z|G|30|15|16]]|9|@]|A|$]]|$1|1F|3|1G|5|6|7|31|8|@$F|32|G|33|15|16]]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|34|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|6|7|35|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|6|7|36|8|@]|9|@]|A|$]]|$1|1N|3|1O|5|6|7|37|8|@]|9|@]|A|$]]|$1|1P|3|1Q|5|6|7|38|8|@]|9|@]|A|$]]|$1|1R|3|1S|5|6|7|39|8|@$F|3A|G|3B|15|16]]|9|@]|A|$]]|$1|1T|3|-4|5|6|7|3C|8|@]|9|@]|A|$]]]|1U|$1V|$5|1W|1X|1Y|A|$1Z|E]]]]

By the current wording of the standard it is a compiler bug, and the program is well-formed. It is now being considered whether it should be a standard defect, as it would be difficult to implement.

For a detailed explanation see:

<a href="https://groups.google.com/a/isocpp.org/forum/?fromgroups#!topic/std-discussion/Nv5_2dCHm6M" rel="nofollow">https://groups.google.com/a/isocpp.org/forum/?fromgroups#!topic/std-discussion/Nv5_2dCHm6M</a>

Report copied below:

<blockquote>
 The current wording of the C++11 official through to N3690 inclusive
 has the following:
 
 <blockquote>
 A conditional-expression e is a core constant expression unless the evaluation of e would evaluate one of the following expressions:
 
 <ul>
 <li>an lvalue-to-rvalue conversion (4.1) unless it is applied to</li>
 <li><ul>
 <li>a non-volatile glvalue of integral or enumeration type that refers to a non-volatile const object with a preceding initialization,
 initialized with a constant expression</li>
 </ul></li>
 </ul>
 </blockquote>
 
 The following declaration at global scope:

<pre><code>const int x[2] = {42, 43};
</code></pre>
 
 defines an array of 2 const int objects, list-initialized with <code>{42,
 43}</code>
 
 In 8.5.1 [dcl.init.aggr]/2:
 
 <blockquote>
 When an aggregate is initialized by an initializer list, as specified in 8.5.4, the elements of the initializer list are taken as
 initializers for the members of the aggregate, in increasing subscript
 or member order.
 </blockquote>
 
 So the initializer of the first element object is <code>42</code> and the
 initializer of the second element object is <code>43</code>.
 
 The expression <code>*x</code> is an lvalue and a core constant expression. It
 entails an array-to-pointer conversion, and an indirection - neither
 of which disqualify the expression as a core constant expression. The
 glvalue expression refers to the first element object of <code>x</code>. <code>*x</code> is a
 non-volatile glvalue of integral type (const int) that refers to a
 non-volatile const object with a preceding initialization, and
 intialized with the constant expression <code>42</code>.
 
 Therefore an lvalue-to-rvalue conversion applied to the glvalue <code>*x</code>
 is allowed in a constant expression, and so the following is
 well-formed:

<pre><code>constexpr int y = *x;
</code></pre>
 
 Neither gcc or clang trunk currently accept this as a constant
 expression, despite it being well-formed according to the standard.
 
 Is this intended?
 
 A full demo program:

<pre><code>const int x[2] = {42, 43};
constexpr int y = *x;
int main() {}
</code></pre>
 
 Implementations similarly fail with the equivalent lvalue <code>x[0]</code> as
 well.
</blockquote>

Is the following C++11 program ill-formed?

<pre><code>const int x[] = {1,2,3};

static_assert(x[0] == 1, "yay");

int main() {}
</code></pre>

gcc and clang seem to think so, but why isn't <code>x[0] == 1</code> a constant expression?

<pre><code>x[0] == 1
subscript operator
*(x+0) == 1
array-to-pointer conversion (int* p = x)
*(p+0) == 1
pointer addition
*p == 1
indirection (lvalue y = x[0])
y == 1
lvalue-to-rvalue conversion:
</code></pre>

<blockquote>
 a non-volatile glvalue (yes, x[0] is a glvalue and non-volatile) of integral (yes it has type const int) or enumeration type that refers to a non-volatile const object (yes it has type const int) with a preceding initialization (yes initialized with 1), initialized with a constant expression (yes 1 is constant expression)
</blockquote>

Seems true, the first element of the <code>x</code> array satisfies these conditions.

<pre><code>1 == 1
</code></pre>

?

Is this a compiler bug, standard defect, or am i missing something?

What part of 5.19 [expr.const] says this isn't a constant expression?

x[0] == 1 constant expression in C++11 when x is const int[]?

编译器

下面的C++11程序是不是格式错误？const int x[] = {1,2,3};static_assert(x[0] == 1, "yay");int main() {}gcc和clang似乎是这么认为的，但是为什么x[0] == 1不是一个恒定的表达呢？x[0] == 1subscript operator*(x...

问当x为常量时，C++11中的x[0] == 1常量表达式？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当x为常量时，C++11中的x[0] == 1常量表达式？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当x为常量时，C++11中的x[0] == 1常量表达式？
EN