C++矩阵类

Question

在 C 中，如果我想创建一个矩阵结构，我会使用：

struct matrix {
  int col, row;
  double data[1]; // I want the matrix entries stored
                  // right after this struct
}

然后我可以使用分配它

matrix* allocate_matrix(int row, int col) {
  matrix* m = malloc(sizeof(matrix) + sizeof(double) * (row * col - 1));
  m->row = row; m->col = col;
  return m;
}

现在我在 C++ 中做等价吗？

编辑：

我想知道在 C++ 中实现矩阵类的规范方法。

Answer 1

注意。

这个答案现在有 20 票赞成，但它并不是对 std::valarray 的认可。

根据我的经验，最好花时间安装和学习使用成熟的数学库，例如 Eigen。 Valarray 的功能比竞争对手少，但它并不更高效或特别易于使用。

如果您只需要一点点线性代数，并且您坚决反对向工具链中添加任何内容，那么也许 valarray 会适合。但是，无法用数学上正确的方式表达问题的解决方案是一个非常糟糕的处境。数学是无情且无情的。使用适合工作的正确工具。

---

标准库提供 std::valarray。 std::vector<>，由其他一些人建议，旨在作为对象的通用容器。 valarray 由于更加专业化（不使用“专业化”作为 C++ 术语）而鲜为人知，它具有以下几个优点：

• 它不分配额外的空间。 向量在分配时向上舍入到最接近的2的幂，因此您可以调整它的大小，而无需每次都重新分配。 （您仍然可以调整 valarray 的大小；它仍然与 realloc() 一样昂贵。）
• 您可以对其进行切片以轻松访问行和列。
• 算术运算符按您的预期工作。

当然，相对于使用 C 的优点是不需要管理内存。维度可以驻留在堆栈上或切片对象中。

std::valarray<double> matrix( row * col ); // no more, no less, than a matrix
matrix[ std::slice( 2, col, row ) ] = pi; // set third column to pi
matrix[ std::slice( 3*row, row, 1 ) ] = e; // set fourth row to e

Answer 2

C++ 主要是 C 的超集。您可以继续做您正在做的事情。

也就是说，在 C++ 中，您应该做的是定义一个适当的 Matrix 类来管理自己的内存。例如，它可以由内部 std::vector 支持，并且您可以覆盖 operator[] 或 operator() 以索引到适当地向量（例如，请参阅：如何为Matrix 类？ 来自 C++ FAQ）。

让您开始使用：（

class Matrix
{
public:
    Matrix(size_t rows, size_t cols);
    double& operator()(size_t i, size_t j);
    double operator()(size_t i, size_t j) const;

private:
    size_t mRows;
    size_t mCols;
    std::vector<double> mData;
};

Matrix::Matrix(size_t rows, size_t cols)
: mRows(rows),
  mCols(cols),
  mData(rows * cols)
{
}

double& Matrix::operator()(size_t i, size_t j)
{
    return mData[i * mCols + j];
}

double Matrix::operator()(size_t i, size_t j) const
{
    return mData[i * mCols + j];
}

请注意，上面的内容不执行任何边界检查，我将其作为模板化的练习，以便它适用于 double 之外的其他内容。）

Answer 3

您可以那样做。唯一的区别是您需要从 malloc 转换结果。

相反，您可以使用向量，作为具有计算索引的一维数组或嵌入向量。 （前者更符合您的代码。）

例如：

template <typename T> // often, they are templates
struct matrix
{
    // should probably be hidden away, and the class would
    // provide `at` and `operator()` for access
    int col, row;
    std::vector<T> data;

    matrix(int columns, int rows) :
    col(columns), row(rows), 
    data(col * row)
    {}

}

matrix m(4, 4);
m.data[1 + 1 * 4] = /* ... */;

或者：

template <typename T>
struct matrix
{
    int col, row;
    std::vector<std::vector<T> > data;

    matrix(int columns, int rows) :
    col(columns), row(rows), 
    data(col, std::vector(row))
    {}
}

matrix m(4, 4);
m.data[1][1] = /* ... */;

但这些只是示例。你想要开设一个成熟的课程；如果您需要更多建议，请编辑您的问题并澄清您想知道实现矩阵类的规范方法。

有预先存在的矩阵类。我最喜欢的是 boost，UBLAS。

Answer 4

设置高效且高质量的矩阵类有很多微妙之处。值得庆幸的是，有一些很好的实现。

仔细考虑一下您是否需要固定大小的矩阵类还是可变大小的矩阵类。
即你能做到这一点吗？

// These tend to be fast and allocated on the stack.
matrix<3,3> M; 

或者你需要能够做到这一点吗？

// These tend to be slower but more flexible and partially allocated on the heap 
matrix M(3,3); 

有一些很好的库支持任一风格，有些库同时支持两种风格。
它们有不同的分配模式和不同的性能。

如果您想自己编码，那么模板版本需要一些模板知识（废话）。如果在紧密循环中使用，动态分配需要一些技巧来绕过大量小分配。

Answer 5

您可以使用类似的模板：

#include <iostream>
using std::cerr;
using std::endl;

//qt4type
typedef unsigned int quint32;

template <typename T>
void deletep(T &) {}
template <typename T>
void deletep(T* & ptr) {
    delete ptr;
    ptr = 0;
}
template<typename T>
class Matrix {
    public:
        typedef T value_type;
        Matrix() : _cols(0), _rows(0), _data(new T[0]), auto_delete(true) {};
        Matrix(quint32 rows, quint32 cols, bool auto_del = true);

        bool exists(quint32 row, quint32 col) const;
        T & operator()(quint32 row, quint32 col);
        T operator()(quint32 row, quint32 col) const;
        virtual ~Matrix();

        int size() const { return _rows * _cols; }
        int rows() const { return _rows; }
        int cols() const { return _cols; }
    private:
        Matrix(const Matrix &);
        quint32 _rows, _cols;
        mutable T * _data;
        const bool auto_delete;
};
template<typename T>
Matrix<T>::Matrix(quint32 rows, quint32 cols, bool auto_del) : _rows(rows), _cols(cols), auto_delete(auto_del) {
    _data = new T[rows * cols];
}
template<typename T>
inline T & Matrix<T>::operator()(quint32 row, quint32 col) {
    return _data[_cols * row + col];
}
template<typename T>
inline T Matrix<T>::operator()(quint32 row, quint32 col) const {
    return _data[_cols * row + col];
}

template<typename T>
bool Matrix<T>::exists(quint32 row, quint32 col) const {
    return (row < _rows && col < _cols);
}

template<typename T>
Matrix<T>::~Matrix() {
    if(auto_delete){
        for(int i = 0, c = size(); i < c; ++i){
            //will do nothing if T isn't a pointer
            deletep(_data[i]);
        }
    }
    delete [] _data;
}

int main() {
    Matrix< int > m(10,10);
    quint32 i = 0;
    for(int x = 0; x < 10; ++x) {
        for(int y = 0; y < 10; ++y, ++i) {
            m(x, y) = i;
        }
    }
    for(int x = 0; x < 10; ++x) {
        for(int y = 0; y < 10; ++y) {
            cerr << "@(" << x << ", " << y << ") : " << m(x,y) << endl;
        }
    }
}

*编辑，修复了拼写错误。

Answer 6

如果在编译时已知矩阵大小，您可以使用模板来完成此操作：

template <int width, int height>
class Matrix{
    double data[height][width];
    //...member functions
};

Answer 7

对于矩阵类，您希望避免重载 [] 运算符。
请参阅 C++ 常见问题解答 13.10

另外，搜索web 上有一些免费软件 Matrix 类。最坏的情况下，他们可以为您提供指导。最好的情况是，您需要编写和调试的软件更少。

Answer 8

在 C++ 中没有“规范”的方法来处理矩阵，STL 不提供像“矩阵”这样的类。然而，有一些第三方库可以这样做。我们鼓励您使用它们或编写自己的实现。您可以尝试我的实现，该实现源自互联网上的一些公共实现。

Answer 9

名为 Matrix 的库支持许多功能，包括数学运算、转储和日志记录功能、关联容器、多个维度等。

用法

其用法与c++数组类似。

Matrix<int> A(1, 2);
Matrix<int> B(2, 3);
Matrix<int> result(1, 3);

A[0][0] = 7;
A[0][1] = 10;

B[0][0] = 1;
B[0][1] = 4;
B[0][2] = 2;
B[1][0] = 1;
B[1][1] = 2;
B[1][2] = 100;

result = A * B;

result.dump.matrix();

结果：

Matrix view:
-            -
| 17 48 1014 |
-            -

这是文档和Github 页面。

Answer 10

在 C++ 中你可以这样使用：

matrix *p = new matrix;

之后，

delete p;