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

我有一个家庭作业，要求我用

实现一个矩阵类，该类使用动态分配来存储其元素

。类应该允许加和减。 它需要释放不再需要存储元素的内存

---

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

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

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

做到这一点的最佳方法不是二维的，而是在其分配中是一维的。你需要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
};

• 运算符（）需要两个重载，一个用于设置这些成员的非常量重载
• 您可能希望检查边界

因此分配：

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

矩阵运算符+（矩阵常数和左、矩阵常数和右）
{
断言（left.width==right.width）；
断言（left.height==right.height）；
矩阵和（左.宽，左.高）；
对于（尺寸i=0；i

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

您不需要“元素类”。您不需要“下一个元素的地址”。依我看，你把事情弄得太复杂了

矩阵是二维数组。
使用

numRows

行和

numColumns

列表示二维数组的最简单方法是使用大小

numRows*numColumns

创建1D数组
在这种数组中，单个元素（rowIndex、columnIndex）的偏移量可以计算为

rowIndex*numCOlumns+columnIndex

，其中两个索引都是基于零的。您知道如何分配1D数组，对吗

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倍大小的新矩阵 -把旧的复制到新的 -释放旧的

---

希望这有帮助

看起来你把矩阵和链表搞混了。。。矩阵元素不应该知道其他元素的任何信息。您不需要元素类。您不需要下一个元素的地址。大小是在编译时已知的还是在运行时确定的（动态分配可以同时使用这两个元素完成；对于一个元素是必需的）？这是压缩稀疏矩阵的目的吗？根据说明，它看起来是这样的，在这种情况下，整个lotta指针管理即将出现。如果你选择你要采取的方法，你将需要额外的节点类型，但它仍然是可行的。@AlexFarber如我所知，数组可以实现为列表，如果你想完全控制元素的大小。@WhozCraig没有真正指定，但它要求我以后确定大小。有点奇怪，因为它应该是一个正方形矩阵。稀疏矩阵上也没有。没有。矩阵A+B之和意味着C[0][0]=A[0][0]+B[0][0]对不起，我没有说清楚。用一种非常不清楚的方式写你的问题并不是开始对答案进行向下投票的理由。你的问题是一个家庭作业，我不会再帮你了，事实上我会投票否决你的问题，投票结束它。你的矩阵之和是有意义的意思，但你说的是“动态分配元素的矩阵”，这不是。谢谢你，再一次，我为你的困惑感到抱歉。显然，我甚至不能对答案投票，所以我不会投你的反对票。再次感谢！我收回了否决票，也结束了投票，因为你的第二段表明你在回答的设计模型中有一些想法，因此你没有简单地问“给我看代码”。好的，我理解你的意思。现在，对于实现，我只是基于给定的某些元素构造了matrix类。我想我会用这个。谢谢