constexpr 动态内存分配
什么是 constexpr 动态内存分配
C++20 允许在 constexpr 求值过程中使用 new 和 delete 进行动态内存分配和释放。这意味着 std::vector、std::string 等依赖动态内存的容器可以在编译期使用了。
但有一个关键限制:编译期分配的内存必须在同一个常量表达式求值结束之前全部释放。这种分配叫做"瞬态分配"(Transient Allocation)。编译期分配的内存不能"逃逸"到运行期——你不能有一个 constexpr std::vector<int> 类型的全局变量。
瞬态分配规则
| 规则 | 说明 |
|---|---|
| 必须使用全局可替换分配函数 | 只能用默认的 operator new / operator delete 或 std::allocator |
| 分配的内存必须在同一表达式中释放 | 编译期 new 的内存必须在编译期 delete |
| 不能使用 placement new | 定位 new 不能在 constexpr 中使用 |
| 不能有内存泄漏 | 编译期如果有未释放的内存,编译错误 |
| std::allocator 可用 | std::allocator<T>::allocate() 和 deallocate() 在 constexpr 中可用 |
基本示例
#include <iostream>
#include <vector>
#include <string>
#include <numeric>
#include <algorithm>
#include <array>
// ============================
// 示例1:constexpr 中使用 new/delete
// ============================
// 在 constexpr 函数中使用动态内存分配
constexpr int sum_of_range(int n) {
// 编译期分配数组
int* arr = new int[n];
// 填充数组
for (int i = 0; i < n; ++i) {
arr[i] = i + 1;
}
// 计算总和
int total = 0;
for (int i = 0; i < n; ++i) {
total += arr[i];
}
// 编译期释放——必须在表达式结束前释放
delete[] arr;
return total;
}
void new_delete_demo() {
// 编译期求值
constexpr int result = sum_of_range(100);
static_assert(result == 5050, "1+2+...+100 应该等于 5050");
std::cout << "1+2+...+100 = " << result << std::endl;
}
// ============================
// 示例2:constexpr 中使用 std::vector
// ============================
// std::vector 在 C++20 中完全支持 constexpr
constexpr int vector_sum(int n) {
std::vector<int> v(n);
// 用 iota 填充 1, 2, 3, ..., n
std::iota(v.begin(), v.end(), 1);
// 用 accumulate 求和
return std::accumulate(v.begin(), v.end(), 0);
// vector 析构时自动释放内存——满足瞬态分配要求
}
constexpr int vector_max() {
std::vector<int> data = {42, 17, 93, 5, 68, 31};
// 排序
std::sort(data.begin(), data.end());
// 返回最大值
return data.back();
}
void vector_demo() {
constexpr int sum = vector_sum(10);
static_assert(sum == 55);
std::cout << "vector 求和: " << sum << std::endl;
constexpr int max_val = vector_max();
static_assert(max_val == 93);
std::cout << "vector 最大值: " << max_val << std::endl;
}
// ============================
// 示例3:constexpr 中使用 std::string
// ============================
// std::string 在 C++20 中完全支持 constexpr
constexpr std::size_t count_vowels(std::string_view text) {
std::string vowels = "aeiouAEIOU";
std::size_t count = 0;
for (char c : text) {
for (char v : vowels) {
if (c == v) {
count++;
break;
}
}
}
return count;
// string 析构时自动释放内存
}
constexpr bool is_palindrome(std::string_view text) {
std::string s(text);
std::string reversed(text);
std::reverse(reversed.begin(), reversed.end());
return s == reversed;
}
void string_demo() {
constexpr auto vowel_count = count_vowels("Hello World");
static_assert(vowel_count == 3);
std::cout << "元音数量: " << vowel_count << std::endl;
constexpr bool pal1 = is_palindrome("racecar");
constexpr bool pal2 = is_palindrome("hello");
static_assert(pal1 == true);
static_assert(pal2 == false);
std::cout << "racecar 是回文: " << std::boolalpha << pal1 << std::endl;
std::cout << "hello 是回文: " << pal2 << std::endl;
}
// ============================
// 示例4:编译期计算结果转为 constexpr 数组
// ============================
// 编译期用 vector 计算,结果转成 array(绕过瞬态分配限制)
template<std::size_t N>
constexpr std::array<int, N> make_squares() {
std::array<int, N> result{};
// 可以在 constexpr 中用 vector 做中间计算
std::vector<int> temp(N);
for (std::size_t i = 0; i < N; ++i) {
temp[i] = static_cast<int>((i + 1) * (i + 1));
}
// 把结果拷贝到 array 中(array 不需要动态内存)
for (std::size_t i = 0; i < N; ++i) {
result[i] = temp[i];
}
return result;
// vector 在这里析构,内存被释放——满足瞬态分配
// array 不需要动态内存,可以作为 constexpr 返回值
}
constexpr auto generate_primes() {
// 用筛法在编译期生成素数
constexpr int limit = 50;
std::vector<bool> is_prime(limit + 1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 2; i * i <= limit; ++i) {
if (is_prime[i]) {
for (int j = i * i; j <= limit; j += i) {
is_prime[j] = false;
}
}
}
// 收集素数
std::vector<int> primes;
for (int i = 2; i <= limit; ++i) {
if (is_prime[i]) primes.push_back(i);
}
// 转成固定大小的数组
std::array<int, 15> result{}; // 50以内有15个素数
for (std::size_t i = 0; i < primes.size() && i < result.size(); ++i) {
result[i] = primes[i];
}
return result;
}
void array_conversion_demo() {
constexpr auto squares = make_squares<10>();
std::cout << "平方表: ";
for (int s : squares) {
std::cout << s << " ";
}
std::cout << std::endl;
constexpr auto primes = generate_primes();
std::cout << "50以内的素数: ";
for (int p : primes) {
if (p > 0) std::cout << p << " ";
}
std::cout << std::endl;
}
// ============================
// 示例5:自定义 constexpr 缓冲区
// ============================
template<typename T>
class ConstexprBuffer {
public:
// constexpr 构造函数——编译期分配内存
constexpr ConstexprBuffer(std::size_t n)
: size_(n), data_(new T[n]{}) {}
// constexpr 析构函数——编译期释放内存
constexpr ~ConstexprBuffer() {
delete[] data_;
}
// 禁止拷贝
ConstexprBuffer(const ConstexprBuffer&) = delete;
ConstexprBuffer& operator=(const ConstexprBuffer&) = delete;
constexpr T& operator[](std::size_t i) { return data_[i]; }
constexpr const T& operator[](std::size_t i) const { return data_[i]; }
constexpr std::size_t size() const { return size_; }
private:
std::size_t size_;
T* data_;
};
constexpr int buffer_demo_calc() {
ConstexprBuffer<int> buf(5);
for (std::size_t i = 0; i < buf.size(); ++i) {
buf[i] = static_cast<int>(i * 10);
}
int sum = 0;
for (std::size_t i = 0; i < buf.size(); ++i) {
sum += buf[i];
}
return sum; // 0 + 10 + 20 + 30 + 40 = 100
}
void buffer_demo() {
constexpr int result = buffer_demo_calc();
static_assert(result == 100);
std::cout << "缓冲区求和: " << result << std::endl;
}
int main() {
std::cout << "=== new/delete ===" << std::endl;
new_delete_demo();
std::cout << "\n=== std::vector ===" << std::endl;
vector_demo();
std::cout << "\n=== std::string ===" << std::endl;
string_demo();
std::cout << "\n=== 转为 array ===" << std::endl;
array_conversion_demo();
std::cout << "\n=== 自定义缓冲区 ===" << std::endl;
buffer_demo();
return 0;
}不能做的事
// 错误:constexpr 变量不能持有动态分配的内存
// constexpr std::vector<int> global_vec = {1, 2, 3};
// 原因:vector 的内存在编译期分配后没有释放(非瞬态)
// 错误:constexpr string 变量
// constexpr std::string global_str = "hello";
// 原因同上
// 正确:在 constexpr 函数中用完就释放
constexpr int ok() {
std::vector<int> v = {1, 2, 3};
return v.size(); // v 在函数返回前析构,内存释放
}
constexpr int n = ok(); // 正确:n 是 int,不持有动态内存
// 正确:把结果转成不需要动态内存的类型
constexpr auto to_array() {
std::vector<int> v = {1, 2, 3};
return std::array<int, 3>{v[0], v[1], v[2]};
}
constexpr auto arr = to_array(); // 正确:array 不需要动态内存适用场景
- 编译期数据处理(排序、过滤、变换)后返回标量或 array 结果
- 编译期字符串处理(解析、验证、转换)
- 编译期查找表生成(先用 vector 计算,再转成 array)
- 编译期算法验证(用 static_assert 检查算法正确性)
- constexpr 类中使用动态内存作为内部实现
常见问题
为什么不能有 constexpr std::vector 全局变量?
因为 std::vector 持有动态分配的内存。C++20 要求编译期分配的内存必须在同一个常量表达式中释放(瞬态分配)。全局 constexpr std::vector 意味着编译期分配的内存要保留到运行期,这不允许。
有办法绕过瞬态分配限制吗?
可以把计算结果转成不需要动态内存的类型(如 std::array、标量、枚举等),然后用 constexpr 保存。在计算过程中可以自由使用 vector 和 string,只要最终结果不持有动态内存就行。
C++26 会放宽这个限制吗?
有提案(P2670 等)讨论允许非瞬态分配(编译期分配的内存提升到静态存储期),但截至 C++26 仍未被标准采纳。
constexpr 中可以用 std::allocator 吗?
可以。std::allocator<T>::allocate() 和 deallocate() 在 C++20 中是 constexpr 的。
编译期的 new 真的会分配内存吗?
不会真的分配堆内存。编译器在内部跟踪这些"虚拟"的内存块,确保它们都被释放。最终程序中只有计算结果,没有 new/delete 调用。
注意事项
- 编译期分配的内存必须在同一常量表达式中释放(瞬态分配)
- 不能有
constexpr std::vector或constexpr std::string类型的变量 - 只能使用全局可替换的分配函数(默认 new/delete 或 std::allocator)
- placement new 不能在 constexpr 中使用
- 编译期动态分配会增加编译时间
- 把编译期计算结果转成
std::array是常见的模式 - 编译期内存泄漏会导致编译错误(这其实是个好处——自动检测泄漏)
编译器支持情况
| 编译器 | 最低支持版本 | constexpr vector | constexpr string |
|---|---|---|---|
| GCC | 12.0 | 支持 | 支持 |
| Clang | 15.0 | 支持 | 支持 |
| MSVC | 19.29 | 支持 | 支持 |
总结
C++20 允许在 constexpr 求值中使用 new/delete 和 std::allocator,使得 std::vector、std::string 等动态容器可以在编译期使用。核心限制是"瞬态分配"——编译期分配的内存必须在同一个常量表达式求值结束前全部释放。这意味着不能有 constexpr std::vector 全局变量,但可以在 constexpr 函数中自由使用 vector 和 string 做中间计算,把最终结果转成 std::array 或标量类型。编译期动态分配不会产生运行期的内存操作——编译器只是在内部跟踪虚拟的内存块,最终程序中只有计算结果。一个额外的好处是编译期内存泄漏会导致编译错误,相当于免费的内存泄漏检测。