Question

我正在尝试用C ++制作一个通用矩阵结构，但现在我所拥有的只是

struct matrix{
    int cells[dim][dim];
}

其中dim是一个const int。

但是我想让事情变得更有活力，所以我可以声明不同大小的矩阵。我可以通过将所有内容转换为int向量的向量来解决这个问题，但随后我遭受了巨大的速度损失。

Answer 1

您也可以使用单个向量进行矩阵类，因为根据基于行或列的存储，数据将是连续的。例如

Struct Matrix {
    std::vector<int> cells;
    int nrows, ncols;

    Matrix(int rows, int cols) : cells(rows * cols), nrows(rows), ncols(cols) 
    {}

    int& operator()(int row, int col){
        return cells[row * ncols + col];
    }

    void resize(int rows, int cols){
        cells.resize(rows*cols);
        nrows = rows; 
        ncols = cols;
    }
}

这是一个很好的矢量包装器，可以避免你需要使用c风格的东西。

Answer 2

FWIW我总是使用平面矢量（预先保留/大小）或Boost MultiArray。

然而，模板出了什么问题？

template<typename T, size_t N, size_t M=N>
struct matrix {
    typedef T row_type[M];
    row_type cells[N];

    row_type*       begin()       { return std::begin(cells); }
    row_type*       end()         { return std::end(cells);   }
    row_type const* begin() const { return std::begin(cells); }
    row_type const* end()   const { return std::end(cells);   }
};

甚至更好，std::array：

#include <array>

template<typename T, size_t N, size_t M=N>
struct matrix {
    typedef std::array<T, M> row_type;
    std::array<row_type, N> cells;

    row_type*       begin()       { return cells.begin(); }
    row_type*       end()         { return cells.end();   }
    row_type const* begin() const { return cells.begin(); }
    row_type const* end()   const { return cells.end();   }
};

只是一个俗气的演示，以显示它的通用性： Live on Coliru

#include <algorithm>

template<size_t N, typename T=int>
T test()
{
    using std::begin;
    using std::end;
    typedef matrix<T, N, N*3+2> Mtx;
    Mtx the_matrix;

    size_t next_gen {};
    auto gen = [&](){ return next_gen++ * 3.14; };

    for(auto& row : the_matrix)
        std::generate(begin(row), end(row), gen);

    return std::accumulate(
            begin(the_matrix), end(the_matrix), T{},  
            [](T accum, typename Mtx::row_type& row) 
            { 
                return accum + std::accumulate(begin(row), end(row), T{}); 
            });
}

#include <iostream>
#include <string>

int main()
{
    std::cout << test<3, int>()    << "\n";
    std::cout << test<3, double>() << "\n";
}

Answer 3

我可以通过将所有内容转换为int向量的向量来解决这个问题，但后来我遭受了巨大的速度损失。

FAUX。 这是错误的。 std::vector几乎与原始数组一样快。 请使用vector<vector<int> >。

但是，如果您仍然坚持使用原始数组：

int **p = new int *[rows];
for (size_t i = 0; i < rows; i++)
    p[i] = new int[columns];

释放：

for (size_t i = 0; i < rows; i++)
    delete [] p[i];

delete [] p;

如何制作动态大小的双int数组？

3 个答案: