Clarification of converted constant expression definition

Question

(Following my recent question, and another question.)

[expr.const]/4 says that:

A converted constant expression of type T is an expression, implicitly converted to type T, where the converted expression is a constant expression and the implicit conversion sequence contains only

... (list omitted)

and where the reference binding (if any) binds directly.

(Emphasis mine.)

There are two points that I do not quite understand here.

First, which expression does "the converted expression" (emphased) refer to?

Consider, for example

class A; // assume it can be implicitly converted to `int`
A foo(); // or maybe constexpr
template<int n> void bar();

Now, if I write

bar<foo()>();

then which expression should be constant expression? Should the whole foo() expression be constant, or just something like static_cast<int>(foo())?

From what I understand from my recent question, only the latter needs to be constant. Is this true?

Second, what stage of the whole process does "reference binding" refer to? Does it refer only to cases when the template parameter itself is a reference (template<int& x>...)? Or does it require that any reference binding that occurs somewhere during the type conversion or evaluation of converted expression, should be direct? Or does it refer to the case when the non-yet-converted expression is a reference itself (A& a=...; bar<a>();)?

Columbo · Accepted Answer · 2015-12-01T12:05:07.257

5

First, which expression does "the converted expression" (emphased) refer to?

Implicit conversion introduces a correspondingly initialized temporary:

T e = /* original expression */;

e is the "converted expression". T = int in your case.

then which expression should be constant expression?

e.

Moreover, foo and the conversion operator function that has been implicitly invoked must be constexpr functions as per [expr.const]/(2.2).

Second, what stage of the whole process does "reference binding" refer to?

When T is a reference type, that reference - e in the above example - shall bind directly. No binding necessitated inside the expression or before it is of interest.

edited Dec 01 '15 at 12:05

answered Dec 01 '15 at 10:56

Columbo

60,038
8
155
203

But if _both_ expressions must be `constexpr`, then why [here](http://coliru.stacked-crooked.com/a/db7921267ecacd99) only the latter call fails? Neither `a` neither `x` there is `const`, but `a` has a `constexpr` conversion. – Petr Dec 01 '15 at 11:25
@Petr That's a completely different example. – Columbo Dec 01 '15 at 11:34
But what is essential in this difference? In all cases the original expression is not constant, is it? – Petr Dec 01 '15 at 11:42
@Petr The original expression `a` is constant. `x` is not. I've adjusted the answer, however, it was unclear indeed, thanks. – Columbo Dec 01 '15 at 11:54
Ok, with your final edit I think I now understand. `foo()` is anyway evaluated, and therefore it should be `constexpr`. While in `A a; bar();` only the conversion operator is evaluated, and it does not evaluate anything in `a`, so `a` is not required to be `constexpr`. Still your last comment is unclear (though it then seems not quite relevant to main question); what part of standard differentiates between `a` and `x` so that `a` is constant and `x` is not? – Petr Dec 01 '15 at 12:29
@Petr Sorry. `x` is also a constant expression. Mea culpa. In my head I was already including the l-t-r conversion, which is only applied during the implicit conversion… – Columbo Dec 01 '15 at 12:32
But wait, if `x` is constant, why can't I use it as a template parameter? – Petr Dec 01 '15 at 12:34
2

@Petr Simple: `x` *itself* is a constant expression, but the converted expression performed an lvalue-to-rvalue conversion during the implicit conversion. This l-t-r conversion on `x` is, however, not allowed in a constant expression as per [expr.const]/(2.7.1), since `x` is not const. – Columbo Dec 01 '15 at 12:36

Clarification of converted constant expression definition

1 Answers1

Linked