CODEWITHSUNDEEP
c++c++11runtimecompile-timeconstexpr
Byzantian
Byzantian

Reputation: 3348

When does a constexpr function get evaluated at compile time?

Since it is possible that a function declared as constexpr can be called during run-time, under which criteria does the compiler decide whether to compute it at compile-time or during runtime? 

template<typename base_t, typename expo_t>
constexpr base_t POW(base_t base, expo_t expo)
{
    return (expo != 0 )? base * POW(base, expo -1) : 1;
}

int main(int argc, char** argv)
{
    int i = 0;
    std::cin >> i;

    std::cout << POW(i, 2) << std::endl;
    return 0;
}

In this case, i is unknown at compile-time, which is probably the reason why the compiler treats POW() as a regular function which is called at runtime. This dynamic however, as convenient as it may appear to be, has some impractical implications. For instance, could there be a case where I would like the compiler to compute a constexpr function during compile-time, where the compiler decides to treat it as a normal function instead, when it would have worked during compile-time as well? Are there any known common pitfalls?

Upvotes: 74

Views: 23137

Answers (3)

Jan Schultke
Jan Schultke

Reputation: 39648

Even if you wrote POW(0, 2), that wouldn't ensure constant-evaluation. POW(0, 2) is a constant expression, but that just means it could be constant-evaluated if need be.

The relevant rules are in [expr.const] p20:

An expression or conversion is manifestly constant-evaluated if it is:

  • a constant-expression, or
  • the condition of a constexpr if statement ([stmt.if]), or
  • an immediate invocation, or
  • the result of substitution into an atomic constraint expression to determine whether it is satisfied ([temp.constr.atomic]), or
  • the initializer of a variable that is usable in constant expressions or has constant initialization ([basic.start.static]).

Note: In C++11, the rules were less restrictive, and constant expressions were much less powerful (see C++11 [expr.const] p4). This answer is based on the latest standard, which is more relevant to future readers.

Note that constant-expression is not the same as constant expression; it's a grammar rule which appears in productions such as:

label:
    attribute-specifier-seqopt case constant-expression :

In other words, constant-evaluation is about where an expression appears. In case POW(0, 2): constant-evaluation takes place; in std::cout << POW(0, 2);, it doesn't, or in C++11, it would have been up to the compiler (although in C++11, constexpr functions are so restrictive that it's very difficult to see a difference). In practice, compilers do the same in C++11 and in more recent standards.

Upvotes: 0

K-ballo
K-ballo

Reputation: 81349

constexpr functions will be evaluated at compile time when all its arguments are constant expressions and the result is used in a constant expression as well. A constant expression could be a literal (like 42), a non-type template argument (like N in template<class T, size_t N> class array;), an enum element declaration (like Blue in enum Color { Red, Blue, Green };, another variable declared constexpr, and so on.

They might be evaluated when all its arguments are constant expressions and the result is not used in a constant expression, but that is up to the implementation.

Upvotes: 109

Pubby
Pubby

Reputation: 53047

The function has to be evaluated at compile-time when a constant expression is needed.

The simplest method to guarantee this is to use a constexpr value, or std::integral_constant:

constexpr auto result = POW(i, 2); // this should not compile since i is not a constant expression
std::cout << result << std::endl;

or:

std::cout << std::integral_constant<int, POW(i, 2)>::value << std::endl;

or

#define POW_C(base, power) (std::integral_constant<decltype(POW((base), (power)), POW((base), (power))>::value)

std::cout << POW_C(63, 2) << std::endl;

or

template<int base, int power>
struct POW_C {
  static constexpr int value = POW(base, power);
};

std::cout << POW_C<2, 63>::value << std::endl;

Upvotes: 24

Related Questions