constexpr and Dynamic Memory

When you try to use dynamic memory allocation in a constexpr function, you'll run into limitations. constexpr functions are designed to be evaluated at compile-time, and dynamic memory allocation is inherently a runtime operation. Let's break this down:

Basic Rule

In general, you cannot use dynamic memory allocation (like new, delete, malloc(), free()) in constexpr functions. This includes standard library functions that might use dynamic allocation internally, such as std::vector or std::string.

1#include <iostream>
2
3constexpr int* create_array(int size) {
4  // This will compile, but not allowed in
5  // a constant expression context
6  return new int[size];
7}
8
9int main() {
10  // This will cause a compile-time error
11  constexpr int* arr = create_array(5);
12}

1error: expression did not evaluate to a constant
2note: (sub-)object points to memory which was heap allocated during constant evaluation

Compile-Time Error

If you try to use dynamic allocation in a constexpr function, you'll get a compile-time error. The exact error message may vary depending on your compiler, but it will generally indicate that the operation is not allowed in a constant expression.

1#include <iostream>
2#include <string>
3
4constexpr std::string get_greeting() {
5  // Will not compile in a constant expression context
6  return std::string("Hello");
7}
8
9int main() {
10  // This will cause a compile-time error
11  constexpr auto greeting = get_greeting();  
12  std::cout << greeting << std::endl;
13}

1error: expression did not evaluate to a constant
2note: (sub-)object points to memory which was heap allocated during constant evaluation

Alternatives

Instead of dynamic allocation, you can use fixed-size arrays or other compile-time data structures. For example:

1#include <array>
2#include <iostream>
3
4constexpr std::array<int, 5> create_array() {
5  return {1, 2, 3, 4, 5};
6}
7
8int main() {
9  constexpr auto arr = create_array();
10  for (int i : arr) {
11    std::cout << i << ' ';
12  }
13}

11 2 3 4 5

C++20 and Beyond

C++20 introduces constexpr versions of some standard library components, including std::vector and std::string.

However, these still don't use actual dynamic allocation at compile-time. Instead, they use a special allocator that simulates dynamic allocation within fixed-size memory blocks.

This code will work in C++20 with a supporting compiler and standard library implementation.

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5constexpr int get_number() {
6  std::vector<int> vec = {3, 1, 2};
7  std::sort(vec.begin(), vec.end());
8  return vec.back();
9}
10
11int main() {
12  constexpr int num = get_number();
13  std::cout << "Number: " << num;
14}

1Number: 3

Remember, the goal of constexpr is to enable compile-time computation. While recent C++ standards have expanded what's possible in constant expressions, they still maintain a clear distinction between compile-time and runtime operations.

When writing constexpr functions, focus on algorithms and computations that don't require runtime resources or side effects.