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

How to make a dynamically-sized double-int array?

本文关键字：数组 int 动态 一个 何制作      更新时间：2023-10-16

我正试图用C++制作一个通用矩阵结构，但现在我只得到

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

其中dim是常数int.

然而，我希望使事情更加动态，这样我就可以声明不同大小的矩阵。我可以通过将所有内容转换为int向量的向量来解决这个问题，但随后我会遭受巨大的速度损失。

您也可以为矩阵类使用一个向量，它工作得很好，因为数据将是顺序的，这取决于基于行或列的存储。例如

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样式的东西。

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";
}

我可以通过将所有内容转换为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;
相关文章：