5.6 — Constexpr variables

In the previous lesson 5.5 -- Constant expressions, we defined what a constant expression is, discussed why constant expressions are desirable, and concluded with when constant expressions actually evaluate at compile-time.

In this lesson, we’ll take a closer look at how we create variables that can be used in constant expressions in modern C++. We’ll also explore our first method for ensuring that code actually executes at compile-time.

The compile-time const challenge

In the prior lesson, we noted that one way to create a variable that can be used in a constant expression is to use the const keyword. A const variable with an integral type and a constant expression initializer can be used in a constant expression. All other const variables cannot be used in constant expressions.

However, the use of const to create variables that can be used in constant expressions has a few challenges.

First, use of const does not make it immediately clear whether the variable is usable in a constant expression or not. In some cases, we can figure it out fairly easily:

int a { 5 };       // not const at all
const int b { a }; // clearly not a constant expression (since initializer is non-const)
const int c { 5 }; // clearly a constant expression (since initializer is a constant expression)

In other cases, it can be quite difficult:

const int d { someVar };    // not obvious whether d is usable in a constant expression or not
const int e { getValue() }; // not obvious whether e is usable in a constant expression or not

In the above example, variables d and e may or may not be usable in a constant expressions, depending on how someVar and getValue() are defined. That means we have to go inspect the definitions of those initializers and infer what case we’re in. And that may not even be sufficient -- if someVar is const and initialized with a variable or a function call, we’ll have to go inspect the definition of its initializer too!

Second, use of const does not provide a way to inform the compiler that we require a variable that is usable in a constant expression (and that it should halt compilation if it isn’t). Instead, it will just silently create a variable that can only be used in runtime expressions.

Third, the use of const to create compile-time constant variables does not extend to non-integral variables. And there are many cases where we would like non-integral variables to be compile-time constants too.

The constexpr keyword

Fortunately, we can enlist the compiler’s help to ensure we get a compile-time constant variable where we desire one. To do so, we use the constexpr keyword (which is shorthand for “constant expression”) instead of const in a variable’s declaration. A constexpr variable is always a compile-time constant. As a result, a constexpr variable must be initialized with a constant expression, otherwise a compilation error will result.

For example:

#include <iostream>

// The return value of a non-constexpr function is not a constant expression 
int five()
{
    return 5;
}

int main()
{
    constexpr double gravity { 9.8 }; // ok: 9.8 is a constant expression
    constexpr int sum { 4 + 5 };      // ok: 4 + 5 is a constant expression
    constexpr int something { sum };  // ok: sum is a constant expression

    std::cout << "Enter your age: ";
    int age{};
    std::cin >> age;

    constexpr int myAge { age };      // compile error: age is not a constant expression
    constexpr int f { five() };       // compile error: return value of five() is not a constant expression

    return 0;
}

Because functions normally execute at runtime, the return value of a function is not a constant expression (even when the value returned by the return statement is). This is why five() is not a legal initialization value for constexpr int f.

Additionally, constexpr works for variables with non-integral types:

constexpr double d { 1.2 }; // d can be used in constant expressions!

The meaning of const vs constexpr for variables

For variables:

• const means that the value of an object cannot be changed after initialization. The value of the initializer may be known at compile-time or runtime. The const object can be evaluated at runtime.
• constexpr means that the object can be used in a constant expression. The value of the initializer must be known at compile-time. The constexpr object can be evaluated at runtime or compile-time.

Constexpr variables are implicitly const. Const variables are not implicitly constexpr (except for const integral variables with a constant expression initializer). Although a variable can be defined as both constexpr and const, in most cases this is redundant, and we only need to use either const or constexpr.

Unlike const, constexpr is not part of an object’s type. Therefore a variable defined as constexpr int actually has type const int (due to the implicit const that constexpr provides for objects).

int arr[5]; // an array of 5 int values, length of 5 is known at compile-time

const int arrLen = 5;
int arr[arrLen]; // ok: array of 5 ints

Const and constexpr function parameters

Normal function calls are evaluated at runtime, with the supplied arguments being used to initialize the function’s parameters. Because the initialization of function parameters happens at runtime, this leads to two consequences:

1. const function parameters are treated as runtime constants (even when the supplied argument is a compile-time constant).
2. Function parameters cannot be declared as constexpr, since their initialization value isn’t determined until runtime.

Nomenclature recap