基于Repast HPC与MPI，C++11如何实现类的二维柔性数组成员？

问题描述 #

我目前正在参与一个涉及Repast HPC和MPI的大型项目，需要实现跨进程共享的二维数组，但Repast HPC本身未提供该功能。我需在类中添加数组成员，但编译时无法确定数组大小，且要求能以常量时间访问和修改元素。以下是当前头文件代码：

template <typename Value>
class SharedValueField {
    private:
        Value[][] values;
        std::queue<ValueChangePackage<Value>> changes;
    public:
        void initializeValueChange(int x, int y, Value value);
        Value getValue(int x, int y);
        void update();
};

我已尝试使用std::array，但遇到相同问题；无法使用std::vector，因为它不支持常量时间的随机元素值操作。请问如何在C++11中实现类似上述代码中values的数组成员？

关键纠正 #

首先明确：std::vector完全支持常量时间O(1)的随机访问，它的底层是连续内存数组，operator[]和at()的访问效率与原生数组一致。你可能混淆了它的动态扩容操作，但扩容不影响单个元素的访问性能。如果数组大小初始化后不再改变，使用std::vector是最简洁安全的方案。

可行实现方案 #

方案1：std::vector（推荐，简洁安全）

利用vector的连续内存特性模拟二维数组，无需手动管理内存，天然支持拷贝/赋值：

template <typename Value>
class SharedValueField {
    private:
        std::vector<Value> values;
        int width;
        int height;
        std::queue<ValueChangePackage<Value>> changes;
    public:
        // 新增构造函数初始化数组大小
        SharedValueField(int w, int h) : width(w), height(h), values(w * h) {
            // 可选：初始化所有元素为默认值
            std::fill(values.begin(), values.end(), Value());
        }

        Value getValue(int x, int y) {
            // 边界检查，避免越界访问
            if (x < 0 || x >= width || y < 0 || y >= height) {
                throw std::out_of_range("Invalid array indices");
            }
            // 通过一维下标映射二维坐标，可根据存储顺序调整（y*width+x或x*height+y）
            return values[y * width + x];
        }

        void setValue(int x, int y, Value val) {
            if (x < 0 || x >= width || y < 0 || y >= height) {
                throw std::out_of_range("Invalid array indices");
            }
            values[y * width + x] = val;
        }

        void initializeValueChange(int x, int y, Value value);
        void update();
};

方案2：原生动态数组+std::unique_ptr（手动内存管理但自动释放）

如果偏好原生数组的管理方式，用std::unique_ptr托管数组，避免内存泄漏：

template <typename Value>
class SharedValueField {
    private:
        std::unique_ptr<Value[]> values;
        int width;
        int height;
        std::queue<ValueChangePackage<Value>> changes;
    public:
        SharedValueField(int w, int h) : width(w), height(h), values(new Value[w * h]) {
            std::fill(values.get(), values.get() + w * h, Value());
        }

        Value getValue(int x, int y) {
            if (x < 0 || x >= width || y < 0 || y >= height) {
                throw std::out_of_range("Invalid array indices");
            }
            return values[y * width + x];
        }

        void setValue(int x, int y, Value val) {
            if (x < 0 || x >= width || y < 0 || y >= height) {
                throw std::out_of_range("Invalid array indices");
            }
            values[y * width + x] = val;
        }

        void initializeValueChange(int x, int y, Value value);
        void update();
};

• unique_ptr会在对象析构时自动释放数组内存，无需手动调用delete[]
• 若需要支持拷贝，需手动实现拷贝构造函数（创建新数组并复制元素）

方案3：嵌套std::unique_ptr（直观二维数组写法）

如果希望代码中直接用values[y][x]的形式访问，可采用嵌套的unique_ptr：

template <typename Value>
class SharedValueField {
    private:
        std::unique_ptr<std::unique_ptr<Value[]>[]> values;
        int width;
        int height;
        std::queue<ValueChangePackage<Value>> changes;
    public:
        SharedValueField(int w, int h) : width(w), height(h), values(new std::unique_ptr<Value[]>[h]) {
            for (int y = 0; y < h; ++y) {
                values[y] = std::unique_ptr<Value[]>(new Value[w]);
                std::fill(values[y].get(), values[y].get() + w, Value());
            }
        }

        Value getValue(int x, int y) {
            if (x < 0 || x >= width || y < 0 || y >= height) {
                throw std::out_of_range("Invalid array indices");
            }
            return values[y][x];
        }

        void setValue(int x, int y, Value val) {
            if (x < 0 || x >= width || y < 0 || y >= height) {
                throw std::out_of_range("Invalid array indices");
            }
            values[y][x] = val;
        }

        void initializeValueChange(int x, int y, Value value);
        void update();
};

• 此方案内存是分散的（每行独立分配），缓存友好性略差于前两种方案，但写法更贴近原生二维数组

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