c++ - 矩阵类的转置方法

Question

我目前正在处理一个矩阵类，我无法决定哪种方法最适合处理矩阵转置。

一开始我采用的是经典方式:

Matrix Matrix::Transpose()
{
    Matrix M(m_cols, m_rows);

    for(int i=0; i < m_rows; ++i)
    {
        for(int j=0; j < m_cols; ++j)
        {
            M(j,i) = this->m_matrix[i][j];
        }
    }

    return M;
}

但转念一想，我想知道这种方式在内存管理方面是否更好:

Matrix& Matrix::Transpose()
{
    std::unique_ptr<Matrix> M(new Matrix(*this));

    m_matrix.resize(m_cols);
    for(unsigned long i = 0; i < m_matrix.size(); ++i)
    {
        m_matrix[i].resize(m_rows, 0.0);
    }
    m_rows = M->Get_Cols();
    m_cols = M->Get_Rows();

    for(unsigned long i=0; i < M->Get_Rows(); ++i)
    {
        for(unsigned long j=0; j < M->Get_Cols(); ++j)
        {
            this->m_matrix[j][i] = (*M)(i,j);
        }
    }

    return *this;
}

现在这两种方法都有效，但我对 C++ 的“内存管理”方面还很陌生，就“良好实践”而言，我真的无法判断哪种方法更好...

Answer 1

出于多种原因，您的第一个构造更可取，我在下面进行了讨论。仅供引用:您可能会发现 return value optimization也很有趣。

保持简单

第二种解决方案不必要地复杂。您已经用 9 行代码替换了本质上是 4 行的代码。您还介绍了另一个 for 循环和堆内存的使用。第二种解决方案速度较慢，几乎从定义上讲，因为您正在做更多的工作。

使用堆栈

当使用临时数据结构时，正如您在第二个示例中所做的那样，您应该更喜欢堆栈内存。引入额外的内存分配会引入您不需要的开销。

避免意外行为+副作用

你的第二个构造修改了你的实例，对于这种类型的转换来说这可能是令人惊讶的。

提示

使用 C++ 的一些额外提示。

• 不要指定this-> unless necessary - 这是暗示的
• 尽可能将您的方法标记为 const - 请参阅 Cpp Core Guidelines
• 在您自己的类中使用私有(private)实现

关于上面的第三点，private 关键字适用于类型级别，而不适用于实例。看看下面的代码。你认为输出是什么？请注意，在我们自己的类方法中，我们可以引用另一个实例的私有(private)变量。 action 方法被标记为 const - 所以我们知道它不会影响我们的实例，但参数是一个可变实例，我们可以修改它。

#include <iostream>
using namespace std;

class Test
{
public:
    Test() = default;
    ~Test() = default;
    int x;
    int y;
    void setZ()
    {
        m_z = x * y;
    }
    void action(Test& other) const
    {
        other.m_z = m_z;
    }
    int z() const { return m_z; }
private:
    int m_z;
};

int main()
{
    Test a;
    Test b;
    a.x = 5;
    a.y = 3;
    a.setZ();
    a.action(b);
    cout << b.z() << endl;

    return 0;
}