Compile-Time Evaluation

We covered in our previous lessons how templates are instantiated at compile time. Because of this, any arguments we provide to templates must be known at compile time.

Below, we try to instantiate a template by providing an int variable as an argument, which results in an error:

1template <int SomeInt>
2struct Resource {
3  int Value{SomeInt};
4};
5
6int main() {
7  int SomeValue{3};
8  Resource<SomeValue> A;  
9}

1error C2971: 'Resource': template parameter 'SomeInt': 'SomeValue': a variable with non-static storage duration cannot be used as a non-type argument

As we introduced in our beginner lessons, we can declare a variable as constexpr, letting the compiler ensure that the value of the variable can be determined at compile time:

1template <int SomeInt>
2struct Resource {
3  int Value{SomeInt};
4};
5
6int main() {
7  constexpr int SomeValue{3};  
8  Resource<SomeValue> A;
9}

When we do this, the compiler will prevent us from using any expression in the initialization that cannot be evaluated at compile time.

For example, if we attempt to initialize a constexpr variable using a function call, we'll typically get a compilation error:

1#include <iostream>
2
3int GetInt() {
4  return 42;
5}
6
7int main() {
8  constexpr int SomeValue{GetInt()};
9}

1error C2131: expression did not evaluate to a constant

Similar to variables, we can mark functions as constexpr. This asks the compiler to ensure that the function can be evaluated at compile time and, as a result, makes the function usable in constexpr contexts:

1constexpr int GetInt() {
2  return 42;
3}
4
5int main() {
6  // This now works
7  constexpr int SomeValue{GetInt()};
8}

1Value: 3

Because of this, the value returned by a constexpr function can be used to provide an argument to a template:

1#include <iostream>
2
3constexpr int GetInt() {
4  return 42;
5}
6
7template <int SomeInt>
8struct Resource {
9  int Value{SomeInt};
10};
11
12int main() {
13  Resource<GetInt()> A;  
14
15  std::cout << "Value: " << A.Value;
16}

1Value: 42

When we have a constexpr function, the compiler will prevent that function from doing anything that may not be possible at compile time.

For example, our function won't be able to call other functions (or operators), unless those functions are also marked as constexpr.

The following won't work, as the << operator on std::cout is not constexpr, and therefore cannot be used at compile time:

1#include <iostream>
2
3constexpr int GetInt() {
4  // We can't do this at compile time:
5  std::cout << "Getting an int"; 
6  return 42;
7}
8
9int main() {
10  constexpr int x{GetInt()};
11}

1error C3615: constexpr function 'GetInt' cannot result in a constant expression
2failure was caused by call of undefined function or one not declared 'constexpr'

When we mark a function as constexpr, the compiler ensures that our function can be used at compile time. But, that does not mean our function can only be used at compile time.

It is possible for a constexpr function to be executed at run time. Add() in the following example demonstrates this:

1#include <iostream>
2
3int GetNumber() {
4  int x;
5  std::cout << "Enter A Number: ";
6  std::cin >> x;
7  return x;
8}
9
10constexpr int Add(int x, int y) {
11  return x + y;
12}
13
14int main() {
15  std::cout << Add(GetNumber(), GetNumber());
16}

1Enter A Number: 2
2Enter A Number: 3
35

When we need to know whether a function is being executed at compile time or run time, we can use the std::is_constant_evaluated() from the <type_traits> header.

It returns true if it was invoked at compile time, or in other contexts where a constant expression is required, such as array bounds or template arguments. In any other context, std::is_constant_evaluated() will return false.

We can use this to change the behaviour of a function based on the context in which it was executed:

1#include <iostream>
2#include <type_traits>
3
4constexpr int GetValue() {
5  if (std::is_constant_evaluated()) {
6    return 1;
7  } else {
8    return 2;
9  }
10}
11
12int main() {
13  constexpr int CompileTimeResult{GetValue()};
14  std::cout << "Compile time result: "
15    << CompileTimeResult;
16
17  int RunTimeResult{GetValue()};
18  std::cout << "\nRun time result: "
19    << RunTimeResult;
20}

1Compile time result: 1
2Run time result: 2

One of the main use cases for this is performance optimization. For example, if we have a function that performs an expensive calculation, we may prefer that the function prioritise speed at run time, but accuracy at compile time.

So, if std::is_constant_evaluated() returns true, we perform the slower but more accurate algorithm, but if it's false, we use the algorithm that quickly returns an approximation.

1#include <type_traits>
2
3constexpr float Calculate(float x, float y) {
4  if (std::is_constant_evaluated()) {
5    return ExactAlgorithm(x, y);
6  } else {
7    return Approximation(x, y);
8  }
9}

If we want a function to only be usable at compile time, we can mark it as consteval. This imposes all the same restrictions as constexpr, but additionally, if an expression would result in a consteval function being invoked at run time, we will get a compilation error instead:

1#include <iostream>
2
3int GetNumber() {
4  int x;
5  std::cout << "Enter A Number: ";
6  std::cin >> x;
7  return x;
8}
9
10consteval int Add(int x, int y) {
11  return x + y;
12}
13
14int main() {
15  std::cout << Add(GetNumber(), GetNumber());
16}

1error C7595: 'Add': call to immediate function is not a constant expression

Functions annotated as consteval are sometimes referred to as immediate functions. This is because, once the compiler sees code attempting to invoke a consteval function, the compiler must perform the invocation immediately. It cannot be invoked later, at run time.

When working on larger projects, our build process can get quite elaborate. For example, our program may need to perform expensive calculations or format large amounts of supporting data.

By marking the functions that perform tasks like this consteval, we make their purpose clearer. Additionally, the compiler ensures nobody uses these functions in a context that would require them be shipped to users and invoked at run time.

Many object types can be constructed at compile time. We've seen examples of this using simple literals, and also standard library containers:

1#include <utility>
2
3int main() {
4  constexpr int SomeInt{42};
5  constexpr std::pair SomePair{42, true};
6}

When working with our custom types, we can mark constructors as constexpr or consteval. As such, that constructor can be invoked at compile time, meaning instances of our user-defined type can be created at compile time:

1struct SomeType {
2  constexpr SomeType(int init) : Value{init} {}
3  int Value;
4};
5
6int main() {
7  constexpr SomeType SomeObject{42};
8}

Like any other function, the compiler will prevent us from doing anything within a constexpr or consteval constructor that might not be possible at compile time, such as calling a non-constexpr function or operator:

1#include <iostream>
2
3struct SomeType {
4  constexpr SomeType(int init) : Value{init} {
5    std::cout << "Hello World";
6  }
7  int Value;
8};
9
10int main() {
11  constexpr SomeType SomeObject{42};
12}

1error C3615: constexpr function 'SomeType::SomeType' cannot result in a constant expression
2failure was caused by call of undefined function or one not declared 'constexpr'

Member functions can be made constexpr or consteval, with the same syntax and effect as any other function:

1class SomeType {
2 public:
3  constexpr SomeType(int init) : Value{init} {}
4  constexpr int GetValue() const {
5    return Value;
6  }
7
8 private:
9  int Value;
10};
11
12int main() {
13  constexpr SomeType SomeObject{42};
14  constexpr int SomeInt{SomeObject.GetValue()};
15}

Finally, operators can also be marked as constexpr or consteval:

1struct SomeType {
2  constexpr SomeType(int init) : Value{init} {}
3
4  constexpr int operator+(int Other) const {
5    return Value + Other;
6  }
7
8  int Value;
9};
10
11int main() {
12  constexpr SomeType SomeObject{42};
13  constexpr int SomeInt{SomeObject + 2};
14}

In this lesson, we learned that the constexpr and consteval keywords are used to enable compile-time evaluation of expressions, functions, and object constructions. Key points:

• constexpr variables and functions can be evaluated at compile-time if their initializers and expressions can be resolved as constant expressions.
• constexpr functions can be invoked at both compile-time and runtime.
• consteval functions, also known as immediate functions, can only be invoked at compile-time, preventing accidental runtime invocation.
• Both constructors and member functions can be marked as constexpr or consteval, enabling compile-time object construction and member function invocation.
• Operators can also be overloaded with constexpr or consteval specifiers, allowing compile-time evaluation of operator expressions.
• Compile-time evaluation can lead to optimized code performance, as computations are performed at compile-time rather than at runtime.