24

想象一下你有一个简单的矩阵类

template <typename T = double>
class Matrix {

  T* data;
  size_t row, col;

public:

  Matrix(size_t m, size_t n) : row(m), col(n), data(new T[m*n]) {}
  //...       

  friend std::ostream& operator<<(std::ostream& os, const Matrix& m) {
    for (int i=0; i<m.row; ++i) {
      for (int j=0; j<m.col; ++j)
        os<<" "<<m.data[i + j*m.row];
      os<<endl;
    }
    return os;
  }
};

有没有办法可以用初始化列表初始化这个矩阵？我的意思是从初始化列表中获取矩阵和元素的大小。类似于以下代码：

Matrix m = { {1., 3., 4.}, {2., 6, 2.}};

会打印

 1 3 4
 2 6 2

期待您的回答。谢谢你们。啊

编辑

因此，我根据您的建议制作了一个使用初始化列表初始化元素的通用数组。但这是我能得到的最通用的。如果你们中的任何人对使它成为更通用的类有任何建议，我将不胜感激。另外，还有几个问题：

  • 派生类初始化基类的状态可以吗？因此，我没有调用基本构造函数，但无论如何我应该调用它吗？
  • 我将 Generic_base 类的析构函数定义为受保护的，这是正确的方法吗？
  • 是否有任何可预见的方式以更通用的方式执行属于初始化程序的构造函数的代码？我的意思是有一个通用的构造函数来处理所有情况？

我只包含了必要的代码来说明在构造中使用初始化列表。当进入更高维度时，它会变得混乱，但我只是为了检查代码而做了一个。

#include <iostream>
#include <cassert>

using std::cout;
using std::endl;


template <int d, typename T>
class Generic_base {

protected:

  typedef T value_type;

  Generic_base() : n_(), data_(nullptr){}

  size_t n_[d] = {0};
  value_type* data_;
};



template <int d, typename T>
class Generic_traits;


template <typename T>
class Generic_traits<1,T> : public Generic_base<1,T> {

protected:

  typedef T value_type;
  typedef Generic_base<1,T> base_type;
  typedef std::initializer_list<T> initializer_type;

  using base_type::n_;
  using base_type::data_;


public:

  Generic_traits(initializer_type l) {

    assert(l.size() > 0);
    n_[0] = l.size();
    data_ = new T[n_[0]];

    int i = 0;
    for (const auto& v : l)
      data_[i++] = v;
  }
};


template <typename T>
class Generic_traits<2,T> : public Generic_base<2,T> {

protected:

  typedef T value_type;
  typedef Generic_base<2,T> base_type;

  typedef std::initializer_list<T> list_type;
  typedef std::initializer_list<list_type> initializer_type;

  using base_type::n_;
  using base_type::data_;

public:

  Generic_traits(initializer_type l) {

    assert(l.size() > 0);
    n_[0] = l.size();
    n_[1] = l.begin()->size();

    data_ = new T[n_[0]*n_[1]];

    int i = 0, j = 0;
    for (const auto& r : l) {

      assert(r.size() == n_[1]);
      for (const auto& v : r) {
        data_[i + j*n_[0]] = v;
        ++j;
      }
      j = 0;
      ++i;
    }
  }
};


template <typename T>
class Generic_traits<4,T> : public Generic_base<4,T> {

protected:

  typedef T value_type;
  typedef Generic_base<4,T> base_type;

  typedef std::initializer_list<T> list_type;
  typedef std::initializer_list<list_type> llist_type;
  typedef std::initializer_list<llist_type> lllist_type;
  typedef std::initializer_list<lllist_type> initializer_type;

  using base_type::n_;
  using base_type::data_;

public:

  Generic_traits(initializer_type l) {

    assert(l.size() > 0);
    assert(l.begin()->size() > 0);
    assert(l.begin()->begin()->size() > 0);
    assert(l.begin()->begin()->begin()->size() > 0);

    size_t m = n_[0] = l.size();
    size_t n = n_[1] = l.begin()->size();
    size_t o = n_[2] = l.begin()->begin()->size();
    n_[3] = l.begin()->begin()->begin()->size();

    data_ = new T[m*n*o*n_[3]];

    int i=0, j=0, k=0, p=0;
    for (const auto& u : l) {
      assert(u.size() == n_[1]);
      for (const auto& v : u) {
        assert(v.size() == n_[2]);
        for (const auto& x : v) {
          assert(x.size() == n_[3]);
          for (const auto& y : x) {
            data_[i + m*j + m*n*k + m*n*o*p] = y;
            ++p;
          }
          p = 0;
          ++k;
        }
        k = 0;
        ++j;
      }
      j = 0;
      ++i;
    }
  }
};



template <int d, typename T>
class Generic : public Generic_traits<d,T> {

public:

  typedef Generic_traits<d,T> traits_type;
  typedef typename traits_type::base_type base_type;

  using base_type::n_;
  using base_type::data_;

  typedef typename traits_type::initializer_type initializer_type;

  // initializer list constructor
  Generic(initializer_type l) : traits_type(l) {}

  size_t size() const {
    size_t n = 1;
    for (size_t i=0; i<d; ++i)
      n *= n_[i];
    return n;
  }

  friend std::ostream& operator<<(std::ostream& os, const Generic& a) {
    for (int i=0; i<a.size(); ++i)
      os<<" "<<a.data_[i];
    return os<<endl;
  }      
};


int main()
{

  // constructors for initializer lists

  Generic<1, double> y = { 1., 2., 3., 4.};
  cout<<"y -> "<<y<<endl;

  Generic<2, double> C = { {1., 2., 3.}, {4., 5., 6.} };
  cout<<"C -> "<<C<<endl;

  Generic<4, double> TT = { {{{1.}, {7.}, {13.}, {19}}, {{2}, {8}, {14}, {20}}, {{3}, {9}, {15}, {21}}}, {{{4.}, {10}, {16}, {22}}, {{5}, {11}, {17}, {23}}, {{6}, {12}, {18}, {24}}} };
  cout<<"TT -> "<<TT<<endl;

  return 0;
}

按预期打印：

y ->  1 2 3 4

C ->  1 4 2 5 3 6

TT ->  1 4 2 5 3 6 7 10 8 11 9 12 13 16 14 17 15 18 19 22 20 23 21 24
4

4 回答 4

22

为什么不？

  Matrix(std::initializer_list<std::initializer_list<T>> lst) :
  Matrix(lst.size(), lst.size() ? lst.begin()->size() : 0)
  {
     int i = 0, j = 0;
     for (const auto& l : lst)
     {
        for (const auto& v : l)
        {
           data[i + j * row] = v;
           ++j;
        }
        j = 0;
        ++i;
     }
  }

正如 stardust_ 所建议的那样 - 你应该在这里使用向量，而不是数组。

于 2013-04-04T11:53:34.770 回答
3

使用初始化列表来解决这个问题的主要问题是它们的大小在编译时不容易访问。看起来这个特定的类是用于动态矩阵的，但是如果您想在堆栈上执行此操作（通常出于速度/局部性原因），这里提示您需要什么（C++17）：

template<typename elem_t, size_t ... dim>
struct matrix
{
    template<size_t ... n>
    constexpr matrix(const elem_t (&...list)[n]) : data{}
    {
        auto pos = &data[0];
        ((pos = std::copy(list, list + n, pos)), ...);
    }

    int data[dim...];
};

template<typename ... elem_t, size_t ... n>
matrix(const elem_t (&...list)[n]) -> matrix<std::common_type_t<elem_t...>, sizeof...(n), (n * ...) / sizeof...(n)>;

我必须在我的线性代数库中解决同样的问题，所以我一开始就明白这是多么不直观。但是，如果您改为将 C 数组传递给构造函数，您将获得传入值的类型和大小信息。还要注意构造函数模板参数推导 (CTAD) 以抽象出模板参数。

然后，您可以像这样创建 constexpr 矩阵对象（或者，省略 constexpr 以在运行时在堆栈上简单地执行此操作）：

constexpr matrix mat{ {1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12} };

这将在编译时初始化一个对象类型：

const matrix<int, 4, 3>

如果您的编译器支持 C++20，我建议在 CTAD 中添加“requires”子句以确保所有子数组的大小相同（从数学上讲，n1 == n2 == n3 == n4， ETC）。

于 2020-08-24T21:05:17.690 回答
1

使用std::vector::emplace_back()（更长）

使用std::vector, 而不是普通的旧数组，您可以使用它std::vector::emplace_back()来填充向量：

template <typename T = double>
class Matrix {
    std::vector<T> data;
    size_t row{}, col{}; // Non-static member initialization

public:
    Matrix(size_t m, size_t n) : data(std::vector<T>(m * n)), row(m), col(n)
    { //                         ^ Keep the order in which the members are declared
    }
    Matrix(std::initializer_list<std::initializer_list<T>> lst)
        : row(lst.size())
        , col(lst.size() ? lst.begin()->size() : 0) // Minimal validation
    {
        // Eliminate reallocations as we already know the size of matrix
        data.reserve(row * col);
        for (auto const& r : lst) {
            for (auto const &c : r) {
                data.emplace_back(c);
            }
        }
    }
};

int main() {
    Matrix<double> d = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
}

使用std::vector::insert()（更好更短）

正如@Bob在评论中提到的，您可以使用std::vector::insert()成员函数，而不是内部emplace_back循环：

template <typename T = double>
class Matrix {
    std::vector<T> data;
    size_t row{}, col{}; // Non-static member initialization

public:
    Matrix(size_t m, size_t n) : data(std::vector<T>(m * n)), row(m), col(n)
    { //                         ^ Keep the order in which the members are declared
    }
    Matrix(std::initializer_list<std::initializer_list<T>> lst)
        : row{lst.size()}
        , col{lst.size() ? lst.begin()->size() : 0} // Minimal validation
    {
        // Eliminate reallocations as we already know the size of the matrix
        data.reserve(row * col);
        for (auto const& r : lst) {
            data.insert(data.end(), r.begin(), r.end());
        }
    }
};

int main() {
    Matrix<double> d = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
}

所以，我们说：对于 中的每一行 ( r) lst，将行的内容从开头 ( r.begin()) 到结尾 ( r.end()) 插入到空向量的末尾data， (在空向量中，语义上我们有empty_vec.begin() == empty_vec.end()：) .

于 2021-11-03T08:53:42.643 回答
0

我可能有点晚了，但这里是一般初始化张量的代码，无论它们是矩阵、向量还是任何张量。当它不是矩阵时，你可以通过抛出运行时错误来限制它。下面是从 initilizer_list 中提取数据的源代码，它有点 hacky。整个技巧是使用正确的类型隐式调用构造函数。

#include <initializer_list>
#include <iostream>
using namespace std;

class ShapeElem{
public:
    ShapeElem* next;
    int len;

    ShapeElem(int _len,ShapeElem* _next): next(_next),len(_len){}

    void print_shape(){
        if (next != nullptr){
            cout <<" "<< len;
            next->print_shape();
        }else{
            cout << " " <<  len << "\n";
        }
    }

    int array_len(){
        if (next != nullptr){
            return len*next->array_len();
        }else{
            return len;
        } 
    }
};

template<class value_type>
class ArrayInit{
public:
    void* data = nullptr;
    size_t len;
    bool is_final;

    ArrayInit(std::initializer_list<value_type> init) : data((void*)init.begin()), len(init.size()),is_final(true){}

    ArrayInit(std::initializer_list<ArrayInit<value_type>> init): data((void*)init.begin()), len(init.size()),is_final(false){}

    ShapeElem* shape(){
        if(is_final){
            ShapeElem* out = new ShapeElem(len,nullptr);
        }else{
            ArrayInit<value_type>* first = (ArrayInit<value_type>*)data;
            ShapeElem* out = new ShapeElem(len,first->shape());
        }
    }
    void assign(value_type** pointer){
        if(is_final){
            for(size_t k = 0; k < len;k ++ ){
                (*pointer)[k] =  ( ((value_type*)data)[k]);
            }
            (*pointer) = (*pointer) + len;
        }else{
            ArrayInit<value_type>* data_array = (ArrayInit<value_type>*)data;
            for(int k = 0;k < len;k++){
                data_array[k].assign(pointer);
            }
        }
    }
};


int main(){
    auto x = ArrayInit<int>({{1,2,3},{92,1,3}});
    auto shape = x.shape();
    shape->print_shape();
    int* data = new int[shape->array_len()];
    int* running_pointer = data;
    x.assign(&running_pointer);
    for(int i = 0;i < shape->array_len();i++){
        cout << " " << data[i];
    }
    cout << "\n";
}

输出

 2 3
 1 2 3 92 1 3

shape() 函数将返回张量在每个维度上的形状。数组在写下时完全保存。创建类似形状的东西真的很重要，因为这会给你元素的顺序。

如果您想要张量中的特定索引，可以说 a[1][2][3] 正确的位置在 1*a.shape[1] a.shape[2] + 2 a.shape[2] + 3

一些小细节和技巧可以在：https ://github.com/martinpflaum/multidimensional_array_cpp

于 2021-07-22T11:35:48.250 回答