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:

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

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

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 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.