用std::vector創建矩陣class，如何在構造函數中設置std::vector的大小？

Question

我正在創建一個名為“matrix”的 class，它具有std::vector<std::vector<T>>的 class 成員，在 ZA2F2ED4F8EBC2CBB4C21A29DZ40AB616 構造函數中設置其大小的最佳優化方法是什么？ 我在m行的構造函數中使用matrix_.resize(m) ，然后使用 for 循環設置其行值（matrix mxn ）。 我的問題是：

1. use.resize() 是一個好方法嗎？ 聽說效率不高，但我想不出別的

2. 當我使用std::vector<std::vector<T>> = matrix_; ，例如，我使用matrix_.resize(m) ， matrix_現在將為“m” std::vector<T>對象提供“m”個空間，但是如果matrix_不知道大小，它將如何管理 memory它的對象（ std::vector<T> ）？ 如果每個對象的大小（1000）或更大怎么辦？

#include <iostream>
#include <vector>

// Matrix of shape m x n, 'm' lines and 'n' columns
template <typename T>
class matrix {
private:
    typedef T value_type;
    typedef std::vector<value_type> row;
    std::vector<row> matrix_;
    
public:
    // Default constructor, initializes a matrix of size 1x1, with element 0.
    matrix() {
        matrix_.resize(1);
        row temp = {0};
        matrix_[0] = temp;
    };
    matrix(size_t m, size_t n) {
        matrix_.resize(m);
        // Appends 'm' rows to the matrix_
        for (size_t i = 0; i < m; i++) {
            row temp(n);    // Creates a row of 'n' columns
            matrix_[i] = temp;
        }
    }
    value_type& at (size_t m, size_t n) {
        return matrix_[m][n];
    }
};

int main() {
    matrix<double> first(2, 2);
    first.at(0, 0) = 3.3;
    first.at(0, 1) = 5.2;
    first.at(1, 0) = 8.9;
    first.at(1, 1) = 1.4;

    return 0;
}

Answer 1

最好的方法是不要。 向量的向量是一個壞主意，尤其是在小尺寸時，因為您希望 memory 是連續的。

template <typename T>
class matrix {
public:
  typedef T value_type; // expose this
private:
  std::size_t m_size = 0;
  std::size_t n_size = 0
  std::vector<T> data;
public:
  // Default constructor, initializes a matrix of size 0
  matrix():matrix(0,0) {};
  // square matrix
  explicit matrix(std::size_t n):matrix(n,n) {};
  matrix(std::size_t m, std::size_t n):
    m_size(m), n_size(n),
    data(m*n, 0)
  {}
  value_type& operator()(size_t m, size_t n) {
    return data[m*n_size + n];
  }
  value_type const& operator()(size_t m, size_t n) const {
    return data[m*n_size + n];
  }
};

添加array_view或span ：

template<class It>
struct range {
  It b, e;
  It begin()const{return b;}
  It end()const{return e;}
  std::size_t size()const{ return end()-begin(); }
  bool empty()const{ return begin()==end(); }
};
template<class T>
struct array_view:range<T*> {
  T& operator[](std::size_t i)const{
    return this->begin()[i];
  }
  array_view(T* start, T* finish):range<T*>{ start, finish }{}
  array_view():array_view(nullptr, nullptr){}
  array_view(T* start, std::size_t length):array_view( start, start+length ) {}
};

我們可以添加

   array_view<T> operator[](std::size_t m) {
     return {std::addressof(data[m*n_size]), n_size};
   }
   array_view<T const> operator[](std::size_t m) const {
     return {std::addressof(data[m*n_size]), n_size};
   }

你現在得到了高效matrix[a][b]語法。 （ addressof只是我偏執）。