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 中可用

基本示例 ​

cpp
#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;
}

不能做的事 ​

cpp
// 错误: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 vectorconstexpr string
GCC12.0支持支持
Clang15.0支持支持
MSVC19.29支持支持

总结 ​

C++20 允许在 constexpr 求值中使用 new/delete 和 std::allocator,使得 std::vector、std::string 等动态容器可以在编译期使用。核心限制是"瞬态分配"——编译期分配的内存必须在同一个常量表达式求值结束前全部释放。这意味着不能有 constexpr std::vector 全局变量,但可以在 constexpr 函数中自由使用 vector 和 string 做中间计算,把最终结果转成 std::array 或标量类型。编译期动态分配不会产生运行期的内存操作——编译器只是在内部跟踪虚拟的内存块,最终程序中只有计算结果。一个额外的好处是编译期内存泄漏会导致编译错误,相当于免费的内存泄漏检测。