我之前在做数值计算的时候刚好碰到过类似的需求，针对你提到的问题，给你几个实用的解决方案，应该能帮到你：

1. 基于连续内存+Eigen::Map的自定义封装（最优选择） #

你的第一个方案用嵌套vector的问题确实是内存碎片化严重，每个子vector都是独立的内存块，缓存命中率低，效率上会打折扣。而用unique_ptr封装数组确实没必要，std::vector本身就是更安全、更易用的连续内存容器。

这里的核心思路是：用单个std::vector存储4阶张量的所有元素（内存完全连续），然后通过索引计算+Eigen::Map来将子区域映射为Eigen的MatrixXd，直接利用Eigen的运算能力。

示例代码 #

#include <Eigen/Dense>
#include <vector>
#include <stdexcept>

class FourOrderTensor {
private:
    std::vector<double> storage_;
    int dims_[4]; // 存储四个维度的大小：d1, d2, d3, d4
    // 预计算步长，避免每次计算索引都做乘法
    int strides_[3]; // stride2 = d3*d4, stride3 = d4, stride4=1（省略）

public:
    // 构造函数：传入四个维度的大小
    FourOrderTensor(int d1, int d2, int d3, int d4) {
        if (d1 <=0 || d2 <=0 || d3 <=0 || d4 <=0) {
            throw std::invalid_argument("Dimensions must be positive integers");
        }
        dims_[0] = d1;
        dims_[1] = d2;
        dims_[2] = d3;
        dims_[3] = d4;
        
        strides_[0] = d3 * d4;    // 第2维的步长
        strides_[1] = d4;         // 第3维的步长
        
        // 分配连续内存
        storage_.resize(d1 * d2 * d3 * d4, 0.0);
    }

    // 重载()运算符，直接访问张量元素
    double& operator()(int i, int j, int k, int l) {
        // 检查索引合法性
        if (i <0 || i >= dims_[0] || j <0 || j >= dims_[1] ||
            k <0 || k >= dims_[2] || l <0 || l >= dims_[3]) {
            throw std::out_of_range("Tensor index out of bounds");
        }
        // 计算线性索引
        int idx = i * dims_[1] * strides_[0] + j * strides_[0] + k * strides_[1] + l;
        return storage_[idx];
    }

    // 获取第(i,j)位置的二维矩阵视图（无拷贝，直接操作底层内存）
    Eigen::Map<Eigen::MatrixXd> getSubMatrix(int i, int j) {
        if (i <0 || i >= dims_[0] || j <0 || j >= dims_[1]) {
            throw std::out_of_range("Submatrix index out of bounds");
        }
        int offset = i * dims_[1] * strides_[0] + j * strides_[0];
        return Eigen::Map<Eigen::MatrixXd>(storage_.data() + offset, dims_[2], dims_[3]);
    }

    // 获取底层数据的指针（如果需要直接操作内存）
    double* data() { return storage_.data(); }
    const double* data() const { return storage_.data(); }
};

方案优势 #

• 内存连续：所有元素存在一个vector里，避免碎片化，缓存友好，效率高；
• 无缝对接Eigen：通过Eigen::Map可以直接将子区域转为MatrixXd，直接使用Eigen的矩阵运算、线性代数功能，无需额外拷贝；
• 安全易用：用std::vector管理内存，自动处理内存分配/释放，避免内存泄漏；
• 可扩展性：可以根据需求添加更多接口（比如获取三维子张量、批量操作等）。

2. 简化版：直接用std::vector+手动索引映射 #

如果你不想写完整的类，也可以直接用单个std::vector存储数据，手动计算索引，用Eigen::Map临时生成矩阵视图：

#include <Eigen/Dense>
#include <vector>

int main() {
    // 定义4阶张量的四个维度
    int d1 = 2, d2 = 3, d3 = 4, d4 = 5;
    // 分配连续内存
    std::vector<double> tensor_data(d1 * d2 * d3 * d4, 0.0);

    // 操作第(i=0, j=1)位置的子矩阵
    int i = 0, j = 1;
    int offset = i * d2 * d3 * d4 + j * d3 * d4;
    // 映射为Eigen矩阵，直接操作
    Eigen::Map<Eigen::MatrixXd> sub_mat(tensor_data.data() + offset, d3, d4);
    sub_mat = Eigen::MatrixXd::Random(d3, d4); // 随机填充数据

    // 访问张量元素：tensor[i][j][k][l]对应tensor_data[i*d2*d3*d4 + j*d3*d4 + k*d4 + l]
    double val = tensor_data[0*d2*d3*d4 + 1*d3*d4 + 2*d4 + 3];
    return 0;
}

这个方案适合快速原型开发，缺点是每次计算索引需要手动写公式，容易出错，适合维度固定或者简单场景。

为什么不推荐你原来的两个方案？ #

• 嵌套std::vector：每个子vector都是独立分配的内存块，内存碎片化严重，缓存命中率低，在大规模计算时效率会明显下降；
• std::unique_ptr封装数组：虽然可以实现连续内存，但std::vector本身已经提供了更安全、更便捷的连续内存管理（比如自动扩容、边界检查、迭代器支持等），完全没必要用unique_ptr来重复造轮子。

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