31

Consider this program:

template <int F(), int N = F()>
void f() { }
constexpr int g() { return 1; }
int main() { f<g>(); }

Is this valid? Are compilers required to see at template definition time, that F could potentially refer to a constexpr function, and therefore the default argument for N could be valid?

gcc and clang accept this, but Intel1 rejects the template function at template definition time because F() is not a constant expression. Intel does accept f<g, g()>() if the default argument is removed, so clearly it understands that g() is usable in a constant expression in general.

It's not clear to me what the standard says. It's clear that (C++11 [expr.const]p2)

an invocation of a function other than a constexpr constructor for a literal class or a constexpr function

renders an expression non-constant, but it's not clear to me whether that applies here. At template definition time, it certainly does seem to apply, since F is not declared to be a constexpr function, but at the same time, errors at template definition time are supposed to be diagnosed only if there is no possible valid instantiation of the template, and there does appear to be a valid instantiation here.

I can see the arguments for both answers, so I'm getting confused. Is there a definitive answer to this question?

1. Re-testing with the current release of Intel's compiler shows that it works just fine, so presumably the Intel developers considered it a bug and have since fixed it. This is a huge hint that the code is meant to be valid. It would still be nice to get a conclusive answer based on the standard, though.

Improve this question
13
  • 2
    Side note: that's adjusted to a pointer-to-function. Commented Jan 12, 2015 at 19:19
  • I'd guess this is ill-formed, since F() is not constexpr so wouldn't qualify as a "constant expression" as per [temp.arg.nontype]. Commented Jan 12, 2015 at 19:23
  • Possibly relevent? N4198 Commented Jan 12, 2015 at 19:25
  • @T.C. Sure. A reference to a function works the same way, FWIW: accepted by gcc and clang, rejected by Intel. Commented Jan 12, 2015 at 19:26
  • 7
    @dyp Heh, nice. template <typename T> int f(); template <> constexpr int f<int>() { return 0; } template <typename T, int N = f<T>()> int g() { return N; } int main() { return g<int>(); } produces "internal error: assertion failed at: "shared/cfe/edgcpfe/exprutil.c", line 11056". :) Commented Jan 12, 2015 at 21:40

1 Answer 1

Reset to default
8
+50

Introduction

template<int F(), int N = F()> void func ();

In this answer we will go through the relevant sections of the International Standard, step by step, to prove that the above snippet is well-formed.

What does the International Standard (N3337) say?

The Standardese

14.1p9 Template parameters [temp.param]

A default template-argument is a template-argument (14.3) specified after = in a template-parameter. [...]

14.3p6 Template arguments [temp.arg]

If the use of a template-argument gives rise to an ill-formed construct in the instantiation of a template specialization, the program is ill-formed.

14.3.2p1 Template non-type arguments [temp.arg.nontype]

A template-argument for a non-type, non-template template-parameter shall be one of:

  • for a non-type template-parameter of integral or enumeration type, a converted constant expression (5.19) of the type of the template-parameter; or
  • the name of a non-type template-parameter; or
  • a constant expression (5.19) that designates the address of an object [...]; or
  • a constant expression that evaluates to a null pointer value (4.10); or
  • a constant expression that evaluates to a null member pointer value (4.11); or
  • a pointer to member expressed as described in 5.3.1

5.19p3 Constant expressions [expr.const]

A literal constant expression is a prvalue core constant expression of literal type, but not pointer type. An integral constant expression is a literal constant expression of integral or unscoped enumeration type. A converted constant expression of type T is a literal constant expression, implicitly converted to the type T, [...]

8.3.6p3 Default arguments [dcl.fct.default]

A default argument shall be specified only in the parameter-declaration-clause of a function declaration or in a template-parameter (14.1); in the latter case, the initializer-clause shall be an assignment-expression.


The Verdict

The above sections makes us come to the following conclusions:

  • A default template-argument is a template-argument, and;
  • when instantiating a template, all template-arguments must be usable in the context where they appear, and;
  • every template-argument for a non-type, non-template template-parameter that appears in a program must be a literal constant expression, and;
  • the default-argument for a template-parameter shall be an assignment-expression.

The Explanation

template<int F(), int N = F()>
void func ();


constexpr int (*F)() = <some_initializer>;                    // (A)
constexpr int N      = <explicit_template_argument> OR <F()>  // (B)

The snippet above can be used as a mental helper to ease reasoning about what the template-parameters will be equivalent to, given a set of template-arguments.

To see whether (B) is valid or not, where an explicit template-argument is not given for N, we must evaluate (A) - and the evaluation of (A) might yield a value for F that is usable in the constant-expression required by (B).

With that said; Yes, the template is legal C++11.

Legal

constexpr int g () { ... }


// func<&g> 
constexpr int (*F)() = &g;  // ok
constexpr int N      = F(); // ok

Ill-formed

          int f () { ... }


// func<&f>
constexpr int (*F)() = &f;  // ok
constexpr int N      = F(); // ill-formed, not a constant-expression

Bonus

The same set of rules apply to the following template;

template<int X, int N = 100/X>
void gunc ();


gunc<0> (); // ill-formed, `100/0` is not mathematically defined,
            //              and is therefore not a constant-expression


For the language-lawyer

And this, pointless use of a default template-argument, is actually legal since F() might be a constant-expression.

F() can however not be a converted constant-expression to give N a value, but this doesn't happen until (if ever) the default argument is actually used.

template<void F(), int N = F()>
void hunc ();


void f ();

hunc<&f, 10> (); // legal
hunc<&f    > (); // ill-formed
Improve this answer
Sign up to request clarification or add additional context in comments.

9 Comments

Your bonus gives an interesting case where GCC and clang disagree. template <int = 1/0> void f() { } int main() { f<0>(); } Valid or not? GCC thinks so (accepting it even with -std=c++11 -pedantic-errors), clang rejects it regardless of command-line options. As for the rest of your answer, thanks, you raise some interesting points. I'm not entirely convinced yet, but I'll re-read it in a bit to check if perhaps I missed something that you did already address.
@hvd I'll add another bonus shortly, template<int = 1/0> void f; is ill-formed because 1/0 is not a constant-expression (whereas F(), in the previous examples, can be a constant-expression).
But your answer doesn't say that template default arguments must be constant expressions, and indeed that wouldn't be a reasonable requirement, since 100/X isn't a constant expression at template definition time, it only becomes a constant expression after a non-zero value is substituted for X during instantiation. In my example, that never happens, because the only template instantiation explicitly specifies an argument.
@hvd mind the use of "converted constant-expression", this says that the expression itself must be a constant-expression; I'll make this more explicit by adding the relevant section of the standard to the answer.
I certainly agree that f<> or f<1 / 0> would be invalid. That is indeed ruled out by what you quote: a template argument must be a (converted) constant expression, and 1 / 0 doesn't qualify. But in template <int = 1/0> void f() { }, there is no template argument that has a non-constant value, because a template default argument isn't a template argument, except if it eventually ends up used. (N3337 incorrectly talks about the requirements of template parameters, that has been fixed to refer to template arguments in later drafts.)
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.