C++ C+中的多维复数数组+；

我必须生成一个多维数组

N（j，k，m，l）

，它是复数，大约是10*100*100*1000

我想做以下操作来计算N并返回

for j<10 ...
{
  for k<100 ...
  {
     ......
     some matrix multiplication to generate a 2D complex valued matrix n(100*1000)
     ......
     N(j,k,:,:)= n
   }
}

---

对于j你说的是10*100*100*1000=100000000个复数，如果2
float
s，每个可能有8个字节，或者2
加倍时有16个字节，因此大约有800兆字节或1.6千兆字节。在普通台式电脑的容量范围内，这是一个良好的开端

高效分配的主要任务是确保内存布局使分配处理的是连续内存。您可以编写几个类来提供一个漂亮的界面，比如说
Matrix\u 2D
然后是
Matrix\u 4D
，比如：

template <typename T>
class Matrix_4D
{
  public:
    Matrix_4D(size_t j, size_t k, size_t l, size_t m)
      : j_(j), k_(k), l_(l), m_(m), data_(new T[j * k * l * m]),
        klm_(k * l * m), lm_(l * m),
    { /* optionally, initialise elements */ }

    ~Matrix_4D() { delete data_; }

    T& operator()(size_t j, size_t k, size_t l, size_t m)
    {
        return data_[j * klm_ + k * lm_ + l * m_ + m];
    }

    const T& operator()(size_t j, size_t k, size_t l, size_t m) const
    {
        return data_[j * klm_ + k * lm_ + l * m_ + m];
    }

    void set(size_t l, size_t m, const Matrix_2D& m2)
    {
        if (m2.j_ != l_ || m2.k_ != m_)
            throw std::runtime_error("mismatched dimensions");
        std::copy(m2.data_[0], m2.data_[lm_], (*this)(l, m, 0, 0));
    }

  private:
    size_t j_, k_, l_, m_;
    size_t klm_, lm_; // needed so often -> save
    T* data_;
};

然后你可以这样做：

Matrix_4D m4(10, 20, 30, 40);
Matrix_2D m2(30, 40);
... set stuff in m2 ...
m4(2, 4) = m2;


<>编辑：对于注释中的代码，请将代码> M2*M2 *转置（m2）——如果你想用这种自给的实现来学习C++，而不是使用像模板表达式之类的高性能技术来抓取现有的高效库（这太复杂了，不能进入这里），那么在<代码> MatRIX2D2>代码>：

    Matrix_2D transpose() const
    {
        Matrix_2D result(m_, l_);
        for (size_t l = 0; l < l_; ++l)
            for (size_t m = 0; m < m_; ++m)
                result(m, l)= (*this)(l, m);
        return result;
    }

    Matrix_2D& operator+=(const Matrix_2D& rhs)
    {
        for (size_t l = 0; l < l_; ++l)
            for (size_t m = 0; m < m_; ++m)
                (*this)(l, m) += rhs(l, m);
        return *this;
    }

    Matrix_2D operator+(const Matrix_2D& rhs) const
    {
        Matrix_2D result(*this); // copy *this
        return result += rhs;
    }

<> p>这将是合理的效率。
什么是<代码> LHS和< /Cord> RHS？你在说？@ MurasbCiela，我的意思是N和N的大小不是同一个，有一些C++库可以帮助你矩阵：10×100×100×1000复值数组，这相当大。你确定这是你真正需要的吗？如果这是一个双数组，一个这样的N需要80000000。你的计划中还有其他的大人物吗10x100矩阵是否密集地填充了这些100x1000元素？100x1000矩阵是否人口密集考虑使用STD：：数组，它允许使用<代码> = 分配数组。需要添加<代码> Jy> <代码>…作为一名成员，'@TonyD一个愚蠢的问题，当我在m2中设置东西时，我是否可以自由使用m2=m2*转置（m2）之类的东西？抱歉，这里有一个新手…@lorniper:如果你在Matrix_2D中编写一个专用的成员函数，将矩阵乘以其转置，效率会更高。。。然后，它可以直接索引元素，而无需任何额外内存，用于
m2
转置的临时2d数组，然后用于
m2*
该临时数组的另一个临时数组，仅用于赋值完成后丢弃的元素。这种类型的复杂C++库使用“模板表达式”来允许直观的符号，如“代码> M2= M2 *转置（m2）< /代码>，同时尽可能高效：例如@ Tunyd BTW，下划线‘y’的广泛用法只表示私有成员”@ LoNiPuli，无论数据访问是否指定，都使用该数据成员。（即public/protected/private）…可能比m_u前缀不太常见，但我觉得它非常可读。不客气。干杯。
    Matrix_2D transpose() const
    {
        Matrix_2D result(m_, l_);
        for (size_t l = 0; l < l_; ++l)
            for (size_t m = 0; m < m_; ++m)
                result(m, l)= (*this)(l, m);
        return result;
    }

    Matrix_2D& operator+=(const Matrix_2D& rhs)
    {
        for (size_t l = 0; l < l_; ++l)
            for (size_t m = 0; m < m_; ++m)
                (*this)(l, m) += rhs(l, m);
        return *this;
    }

    Matrix_2D operator+(const Matrix_2D& rhs) const
    {
        Matrix_2D result(*this); // copy *this
        return result += rhs;
    }

template <typename T>
class Transpose_2D
{
  public:
    Transpose_2D(Matrix_2D<T>& m) : m_(m) { }

    T& operator()(size_t l, size_t m) { return m_(m, l); }
    const T& operator()(size_t l, size_t m) const { return m_(m, l); }

  private:
    Matrix_2D<T>& m_;
};

template <typename U>
Matrix_2D& operator+=(const U& rhs)
...

m2 += Transpose_2D(m2);