如何使用C++内置vector库全局分配矩阵？求可行方案

你原来的代码存在明显问题：外层数组开了row*col个指针，但实际上只需要row个——每个对应一行、col个元素的数组。而且这种分散分配的内存不仅不连续，还得手动释放每一行，极易漏删导致内存泄漏。下面给你几种用vector实现全局矩阵的靠谱方案：

直接声明全局的嵌套vector，初始化时指定行列数即可，内存自动管理，无需手动释放。

#include <vector>

// 全局声明矩阵
std::vector<std::vector<double>> global_matrix;

// 在初始化逻辑里（比如main开头）设置大小
void init_matrix(int row, int col) {
    // 第二个参数是元素初始值，可选，默认0.0
    global_matrix.resize(row, std::vector<double>(col, 0.0));
}

• 优点：语法直观，直接用global_matrix[i][j]访问元素
• 缺点：内存非连续（每一行是单独的vector），缓存友好度略低

用一维vector存储所有元素，通过i*col + j计算索引，内存连续，效率更高，同样适合全局分配。

#include <vector>

std::vector<double> global_matrix;
int matrix_row, matrix_col; // 全局记录行列数，方便计算索引

void init_matrix(int row, int col) {
    matrix_row = row;
    matrix_col = col;
    global_matrix.resize(row * col, 0.0);
}

// 封装访问函数，避免手动算索引出错
double& get_element(int i, int j) {
    return global_matrix[i * matrix_col + j];
}

使用示例：

// 赋值
get_element(2, 3) = 10.5;
// 取值
double val = get_element(2, 3);

• 优点：内存连续，缓存命中率高，计算效率更好
• 缺点：需要手动计算索引（或封装访问函数）

如果需要更严谨的封装（比如边界检查、运算符重载），可以写个简单的矩阵类，内部用vector存储，全局实例化。

#include <vector>
#include <stdexcept>

class Matrix {
private:
    std::vector<double> data;
    int rows;
    int cols;

public:
    Matrix() : rows(0), cols(0) {}

    void resize(int row, int col, double init_val = 0.0) {
        rows = row;
        cols = col;
        data.resize(row * col, init_val);
    }

    double& operator()(int i, int j) {
        if (i < 0 || i >= rows || j < 0 || j >= cols) {
            throw std::out_of_range("Matrix index out of bounds");
        }
        return data[i * cols + j];
    }

    const double& operator()(int i, int j) const {
        if (i < 0 || i >= rows || j < 0 || j >= cols) {
            throw std::out_of_range("Matrix index out of bounds");
        }
        return data[i * cols + j];
    }

    int get_rows() const { return rows; }
    int get_cols() const { return cols; }
};

// 全局矩阵实例
Matrix global_matrix;

使用示例：

global_matrix.resize(5, 5);
global_matrix(2, 3) = 10.5;
double val = global_matrix(2, 3);

• 优点：封装性好，自带边界检查，代码可读性高
• 缺点：需要编写少量类代码，但逻辑简单易懂

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