c++ - 如何制作动态大小的双整数数组？

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();   }
};

只是一个俗气的演示来展示它的通用性：住在 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 向量的向量来解决这个问题，但是我会遭受巨大的速度损失。

假的。那是错误的。 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;