C++编译期未知固定大小本地数组的内存管理最优方案

我需要在类的成员函数中处理一个指针传递的数组，数组大小n在编译期无法确定，但类实例初始化后n的值保持固定。在foo函数的处理流程中，需要创建一个大小为n的数组isNull来完成后续操作。我尝试了三种实现方案，以下是各方案的细节、优缺点以及最终选择：

方案1：myClassA - 堆上动态分配临时数组 #

class myClassA {
private:
    const int n; // 编译期未知
public:
    myClassA(int n) : n(n) {}

    void foo(int* arr) { // 处理大小为n的数组arr
        bool* isNull = new bool[n];
        for (int i = 0; i < n; i++) {
            isNull[i] = arr[i] == 0;
        }
        // 后续处理逻辑

        delete[] isNull;
    }
};

• 特点：每次调用foo时在堆上动态分配和释放isNull数组，逻辑简单，能正常运行。
• 缺点：频繁调用foo时，堆内存的分配与释放会带来明显的性能开销。

方案2：myClassB - 栈上固定大小数组 #

class myClassB {
private:
    const int n; // 编译期未知
    static const int MAXN = 100; // 所有类实例的n上限
public:
    myClassB(int n) : n(n) {}

    void foo(int* arr) { // 处理大小为n的数组arr
        bool isNull[MAXN];
        for (int i = 0; i < n; i++) { // 仅使用前n个元素
            isNull[i] = arr[i] == 0;
        }
        // 后续处理逻辑
    }
};

• 特点：利用栈上分配的固定大小数组，无需动态内存操作，性能优异。
• 缺点：需要预先设定n的上限MAXN，会限制n的取值范围，同时会浪费部分栈空间。

方案3：myClassC - 类成员变量复用数组 #

class myClassC {
private:
    const int n; // 编译期未知
    bool* foo_isNull; // 供foo函数使用的成员变量
public:
    myClassC(int n) : n(n), foo_isNull(new bool[n]) {}
    ~myClassC() { delete[] foo_isNull; }

    void foo(int* arr) { // 处理大小为n的数组arr
        for (int i = 0; i < n; i++) {
            foo_isNull[i] = arr[i] == 0;
        }
        // 后续处理逻辑
    }
};

• 特点：仅在类构造时分配一次内存，后续调用foo可复用该数组，避免了重复的内存分配开销。
• 缺点：将仅用于单个函数的临时数组升级为类成员，增加了类结构的复杂度，不符合单一职责原则。

注：将isNull声明为static不可行，因为类的多个实例可能拥有不同的n值。

性能测试结果 #

当n=10、foo调用10^7次时，各方案的运行时长如下：

• myClassA：2.221s
• myClassB：0.346s
• myClassC：0.220s
• 使用vector的方案耗时显著高于上述三者。

最终选择 #

我最终选择了myClassB，理由如下：

1. 性能表现接近最优的myClassC，远优于堆分配的myClassA；
2. 不会污染类的成员变量，保持了类结构的简洁性；
3. 可以将foo标记为const，符合代码的const正确性要求。

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