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

您不需要“元素类”。您不需要“下一个元素的地址”。国际海事组织，你正在使这个不必要地变得复杂。

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

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....
}

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

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

希望这有帮助！

如何使用动态分配的元素实现矩阵类？

3 个答案: