C语言中多次栈分配固定数组与单次堆分配访问哪个更快？

核心结论 #

对于你这个场景（k数组仅包含4个double，总大小32字节），方案2（栈上分配k）的性能会显著优于方案1，甚至现代编译器可能直接把k的元素优化到CPU寄存器中，完全不需要占用栈空间。

两种方案的性能细节分析 #

方案1（堆分配k） #

• 堆内存的k通过malloc申请，属于全局内存池，访问时需要通过指针间接寻址，CPU缓存命中率更低。
• 虽然你只做了一次堆分配，避免了重复malloc/free的开销，但每次访问k[0]到k[3]都要经过指针地址解析，相比栈变量的直接访问多了一层开销。
• 堆内存地址通常不在CPU的L1缓存中（除非极端频繁访问），而栈内存因为函数调用的局部性，几乎肯定处于L1缓存，两者访问延迟差几个数量级。

方案2（栈上分配k） #

• 栈上定义double k[4];时，只是栈指针做一次减法（分配32字节），几乎没有额外开销——所谓“每次迭代重新分配”本质上只是栈指针的移动，完全没有堆内存管理的复杂操作。
• 栈变量的地址是编译时确定的偏移量，CPU可以直接通过栈基址+偏移访问，属于直接寻址，速度极快。而且因为rk4Step被频繁调用，栈上的k会一直驻留在L1缓存中，访问延迟可以忽略。
• 更关键的是，由于k的大小固定且极小，现代编译器会自动把k[0]到k[3]优化为单个寄存器变量，连栈空间都不会占用，直接在寄存器内完成计算，性能进一步提升。

额外优化建议 #

1. 修改方案2的rk4Step实现
   直接在函数内定义栈上k数组，无需传入指针，代码更简洁：

void rk4Step(double t, double dt, double* p, double* y, int n_eqns, ODE* f) {
    double k[4]; // 栈上分配k数组
    double y_orig_val;
    for (int i = 0; i < n_eqns; i++) {
        y_orig_val = y[i];
        k[0] = dt * (*f)(p, t, y, i);

        y[i] += 0.5 * k[0];
        k[1] = dt * (*f)(p, t + 0.5 * dt, y, i);
        y[i] = y_orig_val;

        y[i] += 0.5 * k[1];
        k[2] = dt * (*f)(p, t + 0.5 * dt, y, i);
        y[i] = y_orig_val;

        y[i] += k[2];
        k[3] = dt * (*f)(p, t + dt, y, i);
        y[i] = y_orig_val;

        y[i] += (k[0] + 2*k[1] + 2*k[2] + k[3]) / 6.0; // 简化计算式，减少除法次数
    }
}

2. 预计算常数
   把1.0/6.0这类常数提前定义为全局常量，避免每次循环重复计算除法：

const double RK4_WEIGHT = 1.0/6.0;

3. 聚焦核心瓶颈
   如果你的ODE函数f计算量较大，那这部分才是性能的核心瓶颈，k数组的开销相比之下可以忽略。此时应重点优化f的实现，比如减少重复计算、利用SIMD指令等。

内容的提问来源于stack exchange，提问作者Martin