c++ - 如何实现具有动态分配元素的矩阵类？

Question

我有一个家庭作业要求我做implement a matrix class with that uses dynamic allocation to store its elements。该类应允许加法和减法。它需要释放不再需要存储元素的内存。

我的想法是创建两个类：矩阵类和元素类。元素类有两个属性（一个键和下一个元素的地址）。问题是，我应该以某种方式存储矩阵类中的所有元素还是只存储第一个元素的地址，并根据第一个元素进行所有操作？你觉得我的做法怎么样？

Answer 1

也许如果你说你的意思，你不会让人们回答你写的东西。

您的矩阵需要动态分配以存储其成员。

做到这一点的最好方法不是二维的，而是一维的分配。您需要 M * N 个元素，因此一次性分配 M*N。

要找到元素（i，j），它实际上是元素（i * M）+ j。

因此你有类似的东西，如果元素是双重的

class Matrix
{
private:
     double * m_mem;
     size_t m_width;
     size_t m_height;
public:
     Matrix( size_t width, size_t height );
     ~Matrix();

     double operator()( size_t i, size_t j ) const
     {
         return m_mem[ i * m_width + j ];
     }
     double& operator()( size_t i, size_t j ) 
     {
         return m_mem[ i * m_width + j ];
     }

     size_t width() const
     {
         return m_width;
     }

     size_t height() const
     {
         return m_height;
     }

     Matrix(Matrix const& other ); // you implement
     Matrix& operator=( Matrix const& other ); // you implement
};

• 您将需要 operator() 的 2 个重载，一个用于设置这些成员的非常量。
• 您可能希望进行边界检查。

如此分配：

     Matrix::Matrix( size_t width, size_t height ) :
        m_mem( new double[width * height] ),
        m_width( width ),
        m_height( height )
     {
     }

因此免费：

     Matrix::~Matrix()
     {
           delete [] m_mem;
     }

鉴于规则 3，您将需要管理复制和分配。

无法释放部分矩阵。

如果要使 Matrix 通用，则必须编写模板。但我不知道你是否还没有学会如何编写模板。

对于加法和减法，您可以使用类成员或：

     Matrix operator+( Matrix const& left, Matrix const& right )
     {
         assert( left.width == right.width );
         assert( left.height == right.height );
         Matrix sum( left.width, left.height );
         for( size_t i = 0; i < left.width; ++i )
         {
             for( size_t j = 0; j < left.height; ++j )
             {
                 sum( i, j ) = left( i, j ) + right( i, j );
             }
         }
         return sum; // in C++11 return std::move(sum) and return-type Matrix&&
     }

如果您使用了类成员（或使运算符成为朋友），您可以通过在单个（而不是嵌套）循环中遍历一维数组中的每个元素来利用您的内部结构。它不会提高仍然是高度*宽度的算法的复杂性，尽管由于指针算法它可能会快一点。

Answer 2

您不需要“元素类”。您不需要“下一个元素的地址”。IMO，你让这变得不必要的复杂。

矩阵是二维数组。用行和列
表示 2D 数组的最简单方法是使用 size 制作 1D 数组。 在这样的数组中，单个元素（rowIndex、columnIndex）的偏移量可以计算为，其中两个索引都是从零开始的。而且您确实知道如何分配一维数组，对吗？numRowsnumColumnsnumRows * numColumns
rowIndex * numCOlumns + columnIndex

Answer 3

Class Matrix:
{
private:
int**m;
public:
Matrix();//allocate memory
Realocate_memory(int**, int rows, int cols); //in case you want to modify the size of the matrix - this will be the most complicated part as you need to handle memory allocation.
Free(int**m, int rows, int cols);

// other methods....
}

这里棘手的部分是删除未使用的元素 - 因为你必须保留矩阵结构，所以有一些限制： - 你只能删除整个行/列 - 你可以移动数据是允许的，这样你就结束了完整的行/列未使用的元素 - 但我个人不会打扰这种方法

您还可以在空间不足时分配更多内存 - 在这里您可以采用动态数组方法： - 分配一个 2 倍大小的新矩阵 - 将旧矩阵复制到新矩阵中 - 释放旧矩阵。

希望这可以帮助！