blocks|key|1760635|text|来自C%2B%2B11+Wiki页面|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1760636|如果用非常量表达式的参数调用一个constexpr函数或构造函数，则调用的行为就好像该函数不是constexpr一样，并且得到的值不是一个常量表达式。类似地，如果一个constexpr函数的返回语句中的表达式不计算为一个特定调用的常量表达式，则结果不是一个常量表达式。|blockquote|1760637|因此，constexpr说明符表达了在编译时计算某些内容的可能性，并且在使用时受一些限制约束。|style|CODE|1760638|对于您的特定片段，在我看来，C%2B%2B11约束：|1760639|正好有一个返回语句，它只包含文字值、constexpr变量和函数。|1760640|未实现，因为hash_code被定义为：|1760641|size_t+hash_code()+const;|code-block|syntax|javascript|1760642|在这种情况下，标准草案n3242说：|1760643|对于一个constexpr函数，如果不存在函数参数值，以致函数调用替换将产生一个常量表达式(5.19)，则程序的格式不正确；不需要诊断。|1760644|我相信你的例子很适合这里。|1760645|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/C%2B%2B11#constexpr_.E2.80.93_Generalized_constant_expressions|1|http://en.cppreference.com/w/cpp/language/constexpr|2|http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf^0|2|C|0|0|0|3|9|14|4|1|0|0|0|0|0|7|9|2|0|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@$A|1E|B|1F|1|1G]]|C|$]]|$1|D|3|E|5|F|7|1H|8|@]|9|@]|C|$]]|$1|G|3|H|5|6|7|1I|8|@$A|1J|B|1K|I|J]]|9|@$A|1L|B|1M|1|1N]]|C|$]]|$1|K|3|L|5|6|7|1O|8|@]|9|@]|C|$]]|$1|M|3|N|5|F|7|1P|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|Q|3|R|5|S|7|1R|8|@]|9|@]|C|$T|U]]|$1|V|3|W|5|6|7|1S|8|@]|9|@$A|1T|B|1U|1|1V]]|C|$]]|$1|X|3|Y|5|F|7|1W|8|@]|9|@]|C|$]]|$1|Z|3|10|5|6|7|1X|8|@]|9|@]|C|$]]|$1|11|3|-4|5|6|7|1Y|8|@]|9|@]|C|$]]]|12|$13|$5|14|15|16|C|$17|18]]|19|$5|14|15|16|C|$17|1A]]|1B|$5|14|15|16|C|$17|1C]]]]

From the <a href="http://en.wikipedia.org/wiki/C++11#constexpr_.E2.80.93_Generalized_constant_expressions" rel="nofollow">C++11 Wiki page</a>:

<blockquote>
 If a constexpr function or constructor is called with arguments which
 aren't constant expressions, the call behaves as if the function were
 not constexpr, and the resulting value is not a constant expression.
 Likewise, if the expression in the return statement of a constexpr
 function does not evaluate to a constant expression for a particular
 invocation, the result is not a constant expression.
</blockquote>

The <code>constexpr</code> specifier thus expresses the possibility to evaluate something at compile time and is subject to <a href="http://en.cppreference.com/w/cpp/language/constexpr" rel="nofollow">some restrictions</a> when used.

<hr>

For your particular snippet it seems to me that the C++11 constraint:

<blockquote>
 exactly one return statement that contains only literal values,
 constexpr variables and functions
</blockquote>

is not fulfilled, as hash_code is defined to be:

<pre><code>size_t hash_code() const;
</code></pre>

In this case the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf" rel="nofollow">standard draft n3242</a> says:

<blockquote>
 For a constexpr function, if no function argument values exist such
 that the function invocation substitution would produce a constant
 expression (5.19), the program is ill-formed; no diagnostic required.
</blockquote>

I believe your example fits here.

blocks|key|1760680|text|compile函数可用于计算编译时间常数。因此，可以这样使用它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1760681|+constexpr+int+func(int+a)+{+return+a%2B2;+}

+char+x[func(10)];|code-block|syntax|javascript|1760682|如果在运行时调用func，编译器可以在可能的情况下对该表达式进行计算。但是，如果输入也是const，则这不是必须的，但通常是这样做的。|1760683|同样重要的是，要有警察建设者。这是获得非POD类constexpr对象的唯一机会。|1760684|++++class+Point
++++{+++
++++++++private:++++
++++++++++++int+x;
++++++++++++int+y;
++++++++public:
++++++++++++constexpr+Point(+int+_x,+int+_y)+:+x(_x),+y(_y)+{}++
++++++++++++constexpr+int+GetX()+const+{+return+x;+}
++++};++

++++constexpr+Point+p{1,2};

++++int+main()
++++{+++

++++++++char+i[p.GetX()];
++++++++return+0;
++++}+++|1760685|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

constexpr functions can be used to evaluate compile time constants. So it is possible to use it like:

<pre><code> constexpr int func(int a) { return a+2; }

 char x[func(10)];
</code></pre>

If func is called during runtime, the compiler can evaluate this expression before if possible. But that is not a must but normally done if the input is also const.

It is also important to have constexpr constructors. This is the only chance to get non POD classes constexpr objects.

<pre><code> class Point
 { 
 private: 
 int x;
 int y;
 public:
 constexpr Point( int _x, int _y) : x(_x), y(_y) {} 
 constexpr int GetX() const { return x; }
 }; 

 constexpr Point p{1,2};

 int main()
 { 

 char i[p.GetX()];
 return 0;
 } 
</code></pre>

blocks|key|1760742|text|你的问题的完整答案有两个方面：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1760743|当所有参数都可以在编译时计算时，constexpr函数只能在编译时进行计算。它仍然可以用作在运行时计算的正常函数。|ordered-list-item|1760744|必须使用编译时求值的值初始化constexpr变量.如果编译器不能这样做，则必须引发错误。|1760745|您可以将哈希代码分配给一个constexpr变量，然后得到一个编译器输出：|1760746|#include+<typeinfo>
#include+<array>

template<typename+T>+
std::size_t+constexpr+getID()+{+

++++return+[]()+{constexpr+size_t+id+=+typeid(T).hash_code();+return+id;}();+}

int+main()+{
++++//+both+statement+generate+compiler+errors
++++//std::array<int,+typeid(int).hash_code()>+a;
++++//constexpr+size_t+y+=+typeid(int).hash_code();

++++size_t+x+=+getID<int>();
}|code-block|syntax|javascript|1760747|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|T|8|@]|9|@]|A|$L|M]]|$1|N|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|O|$]]

The complete answer to your question has two aspects:

<ol>
<li>A constexpr function can only be evaluated at compile-time when all
arguments can be evaluated at compile-time. It can still be used as
a normal function which is evaluated at runtime.</li>
<li>An constexpr variable must be initialized with a value evaluated at compile-time.
The compiler has to raise an error if it cannot do this.</li>
</ol>

You could assign the hash code to a constexpr variable and then get a compiler output:

<pre><code>#include &lt;typeinfo&gt;
#include &lt;array&gt;

template&lt;typename T&gt; 
std::size_t constexpr getID() { 

 return []() {constexpr size_t id = typeid(T).hash_code(); return id;}(); }

int main() {
 // both statement generate compiler errors
 //std::array&lt;int, typeid(int).hash_code()&gt; a;
 //constexpr size_t y = typeid(int).hash_code();

 size_t x = getID&lt;int&gt;();
}
</code></pre>

blocks|key|1760762|text|constexpr是对编译器的“提示”(如内联)还是“绑定请求”？|type|blockquote|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1760763|两者都不是。忘记它什么时候被评估。每当编译器认为有必要产生C%2B%2B抽象机器的行为时(只有少数几个小例外，特别是涉及到C%2B%2B的情况)，都会对其进行评估。当事情被评估的时候，没有什么可说的了。|unstyled|1760764|编译器可以自由地生成代码，在不产生不同行为的情况下，可以在运行时计算什么是常量表达式。它可以自由地生成代码，在编译时评估没有标记constexpr的东西，如果它有智慧的话。|1760765|如果不是关于编译时和运行时，那么constexpr是关于什么的呢？|1760766|constexpr允许将事物视为常量表达式。任何标记为constexpr的内容都必须具有以某种方式生成常量表达式的可能性。|1760767|在函数的情况下，它们可以用某些参数生成常量表达式，但不能生成其他参数。但是，只要有一些参数可以导致一个常量表达式，一个函数就可以被标记为constexpr。如果在函数调用中使用了这样一组参数，则该表达式是一个常量表达式。这是否意味着在编译时对其进行评估？请参见上面的。当编译器认为合适时，会对其进行评估。它唯一的意思是，您可以在需要常量表达式的上下文中使用它。|1760768|对于变量，它们要么是常量表达式，要么不是常数表达式。它们没有参数，所以如果constexpr总是必须用常量表达式初始化。|1760769|TL;DR：constexpr是将事物标记为在常量表达式中可用，而不是决定何时对它们进行评估。|BOLD|1760770|这样一来，您的函数模板就会出现格式错误。没有一组参数可以导致常量表达式。不过，该标准不需要对此进行诊断。|1760771|entityMap^0|0|9|0|0|1S|9|0|G|9|0|0|9|R|9|0|1W|9|0|11|9|0|0|5|6|9|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$]]|$1|I|3|J|5|H|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|K|3|L|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|S|3|T|5|H|7|1K|8|@$9|1L|A|1M|B|U]|$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|V|3|W|5|H|7|1P|8|@]|D|@]|E|$]]|$1|X|3|-4|5|H|7|1Q|8|@]|D|@]|E|$]]]|Y|$]]

<blockquote>
 Is <code>constexpr</code> a “hint” (like inline) or “a binding request” to the compiler?
</blockquote>

It is neither. Forget about when it is evaluated. Everything (with a few minor exceptions, notably involving <code>volatile</code>) is evaluated whenever the compiler deems it necessary to produce the behaviour of the C++ abstract machine. There isn't much else to say about when things are evaluated.

The compiler is free to produce code that evaluates what would be constant expressions at runtime if that doesn't produce a different behaviour. It is free to produce code that evaluates things not marked <code>constexpr</code> at compile-time if it has the smarts.

<blockquote>
 If not about compile-time vs runtime, what is <code>constexpr</code> about, then?
</blockquote>

<code>constexpr</code> allows things to be treated as constant expressions. Anything marked <code>constexpr</code> must have the possibility of producing a constant expression in some way.

In the case of functions, they can be able to produce constant expressions with some arguments but not others. But as long as there is some set of arguments that can result in a constant expression, a function can be marked <code>constexpr</code>. If such a set of arguments is used in a function call, that expression is a constant expression. Does that mean it is evaluated at compile-time? See above. It's evaluated when the compiler deems appropriate. The only thing it means is that you can use it in a context requiring a constant expression.

For variables, either they are constant expressions or not. They have no arguments, so if <code>constexpr</code> they always have to be initialised with constant expressions.

TL;DR: <code>constexpr</code> is about tagging things as being usable in constant expressions, not about deciding when to evaluate them.

<hr>

With that out of the way, it appears your function template is ill-formed. There is no set of arguments that could result in a constant expression. The standard doesn't require a diagnostic for this, though.

Is <code>constexpr</code> an indicator for the compiler or does it mandate a behaviour ? 

The example at hand is the following : 

<pre><code>template&lt;typename T&gt; 
std::size_t constexpr getID() { return typeid(T).hash_code(); }
</code></pre>

<code>hash_code</code> is a runtime constant, yet this snippet would <a href="http://ideone.com/Zm2X92" rel="noreferrer">compile</a> even though a compile time evaluation is requested with <code>constexpr</code>. Only after the return value is used where a compile time constant is expected, would we get noticed that this <a href="http://ideone.com/LxcuMF" rel="noreferrer">is not usable as a constexpr function</a>.

So is <code>constexpr</code> a "hint" (much like the <code>inline</code> keyword) or "a binding request" to the compiler ?

Is constexpr a "hint" (like inline) or "a binding request" to the compiler?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

constexpr是编译器的指示符，还是强制的行为？下面是下面的例子：template<typename T> std::size_t constexpr getID() { return typeid(T).hash_code(); }hash_code是一个运行时常量，但是即使使用constexpr请求编译时计算，...

问是对编译器的“提示”(如内联)还是“绑定请求”？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是对编译器的“提示”(如内联)还是“绑定请求”？EN