2

So generally constexpr functions are functions, that are executed in compile time, when arguments passed to it are also constexpr so following:

constexpr int function(int x, int y){
   return x+y;
}

with arguments declared as follows:

constexpr int x = 5;
constexpr int y = 6;

will be executed in compile time, but with following declaration of arguments:

int x=5;
int y=6;

It will not. I wonder what would happen if we call this function in a following way:

function(5,6);

From technical point of view 5 and 6 are rvalues but there is no way (I guess), that they can be casted to constexpr (if we can say generally about casting to constexpr), so in my opinion it will be executed in a runtime. However there is no practical reason to execute it in a run time as both x and y are known during compilation time.

So my question is How is it in real life? Will this function be executed in run-time or compile time

Improve this question
3
  • 4
    Literal is also constant expression. Commented Oct 13, 2015 at 6:55
  • If it is so please post this as an answer and I will accept it :) Commented Oct 13, 2015 at 6:56
  • A call function(x, y) with non-const x and y might also be evaluated at compile time if the optimizer realizes that x and y will always have the same value. It just isn't required to do so, and the result cannot be used where a constexpr is required. Commented Oct 13, 2015 at 7:08

2 Answers 2

Reset to default
2 
constexpr int fun(int x, int y) { return x+y; }
fun(5,6) // << constant expression?

tl;dr

5 and 6 are constant expressions. Thus fun(5,6) also is a constant expression and will be evaluated at compile time where this is mandatory (non-type templates for instance).

stuff... I had a quick look into the standard and I hope I didn't miss any important points.

We already know from @42's answer:

  • According to N4527 int is a valid paramter type for a constexpr function since it is a literal type (since it is a scalar type which is by §3.9/10 of the same document a literal type). Therefore, fun is a valid constexpr function.

  • It provides code that puts fun(5,6) into a context where a constant expression is required and it seems to be accepted by certain compilers.

Now the question is whether this is valid, standard-conformant behaviour.

§5.20 from N4527 says:

A conditional-expression e is a core constant expression unless the evaluation of e, following the rules of the abstract machine (1.9), would evaluate one of the following expressions:

  • here comes a large list of things that prevent expressions from being core constant expression

That list does not contain "constexpr function with constant expression arguments" which are therefore core constant expressions (unless they are undefined when used).

Thus, if 5 and 6 are constant expressions, then fun(5,6) is a constant expression if fun is a valid constexpr function and is defined before using it. The given function satisfies the required constraints in §7.1.5/3 and is a valid constexpr function.

Both 5 and 6 are integer literals of type int as per §2.13.2

1) An integer literal is a sequence of digits that has no period or exponent part, with optional separating single quotes that are ignored when determining its value. [...]

2) The type of an integer literal is the first of the corresponding list in Table 5 in which its value can be represented.

Suffix: none, Decimal literal: int, long int, long long int

Now looking at §5.20 again we see: both are constant expressions.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

"Thus, if 5 and 6 are constant expressions, then fun(5,6) is a constant expression if fun is declared constexpr and is defined before using it." ... nope you have to know what fun is doing in its body to give a verdict - check this. You are over complicating a simple question
@101010 Yes, the function must be a valid constexpr function.
2

According to the draft standard N4527 7.1.5/3 The constexpr specifier [dcl.constexpr] (Emphasis mine):

The definition of a constexpr function shall satisfy the following constraints:

(3.1) — it shall not be virtual (10.3);

(3.2) — its return type shall be a literal type;

(3.3) — each of its parameter types shall be a literal type;

...

Thus, calling function(5,6); satisfies the definition of a constexpr function and execution will take place at compile time.

Moreover, you can test it by yourself by using std::integral_constant:

#include <iostream>
#include <type_traits>

constexpr int fun(int x, int y) {
   return x + y;
}

int main() {
    std::cout << std::integral_constant<int, fun(5, 6)>::value << std::endl;
}

LIVE DEMO

If input parameters in fun are not constexpr compilation will fail.

Improve this answer

5 Comments

"It is valid/guaranteed because it compiles" isn't a very good argument. Could be a compiler extension, a compiler bug or whatever.
@Pixelchemist std::integral_constant is not a compiler extension. It's in the standard [20.10.2 Header <type_traits> synopsis [meta.type.synop] ].
I think your answer becomes better if you add the standard reference (and remove the possible misconception of: it compiles = it is correct).
I am sorry to be nitpicking, but 3.3 refers to constexpr int function(int x, int y), not function(5, 6).
@101010 It is not about integral_constant. Any non-type-template parameter of type int can be used in this case to check whether the compiler will accept function(5,6) where a constant expression is required. There is still no prove that function(5,6) is a constant expression. The fact that one or multiple compilers allow it to appear at a point where a constant expression is required doesn't prove its validity.

Your Answer

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

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.