Question

考虑以下课程：

    <tr style="padding: 15px ;text-align: center">


         <td style="padding: 15px">MON</td>


         <td style="padding: 15px"> JAVA</td>
         <td> FLAT</td>          
         <td>TEA BREAK </td>
         <td> .NET</td>
         <td> E M</td>
         <td>LUNCH BREAK </td>
         <td> .NET</td>
         <td> CN</td>
         <td> DBMS</td>         
    </tr>

我可以使用这样的数组初始化它：

template <size_t nb_rows, size_t nb_cols>
class ButtonMatrix
{
  public:
    ButtonMatrix(const pin_t (&rowPins)[nb_rows], const pin_t (&colPins)[nb_cols], const uint8_t (&addresses)[nb_rows][nb_cols])
      : rowPins(rowPins), colPins(colPins), addresses(addresses) { }
  private:
    const pin_t (&rowPins)[nb_rows], (&colPins)[nb_cols];
    const uint8_t (&addresses)[nb_rows][nb_cols];
};

它运作得很好。但是，我希望能够使用大括号括起来的初始化列表来初始化它：

const pin_t rows[2] = {0, 1};
const pin_t cols[2] = {2, 3};

const uint8_t addresses[2][2] = {
  {0x01, 0x02},
  {0x03, 0x04}
};

ButtonMatrix<2, 2> bm(rows, cols, addresses);

它编译没有问题，但它显然不起作用，因为ButtonMatrix<2, 2> bm({0, 1}, {2, 3}, addresses);和rowPins仅在构造函数的持续时间内存在，并且不能在类的其他方法中使用。为了解决这个问题，我可以复制colPins和rowPins：

的内容

colPins

这样，我可以使用数组引用或使用大括号括起来的初始化列表来初始化它唯一的缺点是，当使用数组引用时，会有两个相同数据的副本。目标平台是Arduino，所以我想将内存使用量降到最低有没有办法确定初始化列表是否用于初始化它，如果是，则为数组的动态内存？这些内容：C++ overload constructor with const array and initializer_list

如果初始值设定项列表的维度与template <size_t nb_rows, size_t nb_cols> class ButtonMatrix { public: ButtonMatrix(const pin_t (&rowPins)[nb_rows], const pin_t (&colPins)[nb_cols], const uint8_t (&addresses)[nb_rows][nb_cols]) : addresses(addresses) { memcpy(this->rowPins, rowPins, sizeof(rowPins[0]) * nb_rows); memcpy(this->colPins, colPins, sizeof(colPins[0]) * nb_cols); } private: pin_t rowPins[nb_rows], colPins[nb_cols]; const uint8_t (&addresses)[nb_rows][nb_cols]; };和nb_rows不匹配，那么编译时错误会很好，所以排除nb_cols的排序（请纠正我，如果我错了。）

Answer 1

如果我们可以用> fibs 10 [0,1,1,2,3,5,8,13,21,34] >替换裸数组（它们更容易为多维数组动态分配），部分解决方案是依赖于临时数更喜欢作为右值引用传递的事实：

std::array

现在，当你这样做时，传递的静态数组将被指针存储并且不会被删除：

template <typename T>
void no_deleter(T*) { }

template <typename T>
void default_deleter(T *p) {
    delete p;
}

template <size_t nb_rows, size_t nb_cols>
class ButtonMatrix
{
  public:
    using row_array_t = std::array<pin_t, nb_rows>;
    using col_array_t = std::array<pin_t, nb_cols>;
    using address_array_t = std::array<std::array<uint8_t, nb_cols>, nb_rows>;

  private:
    template <typename T>
    using array_ptr = std::unique_ptr<T, void (*)(T*)>;

  public:
    ButtonMatrix(const row_array_t &rowPins, const col_array_t &colPins, const address_array_t &addresses)
      : rowPins(&rowPins, no_deleter<const row_array_t>),
        colPins(&colPins, no_deleter<const col_array_t>),
        addresses(&addresses, no_deleter<const address_array_t>) { }

    ButtonMatrix(row_array_t &&rowPins, col_array_t &&colPins, address_array_t &&addresses)
      : rowPins(new row_array_t(std::move(rowPins)), default_deleter<const row_array_t>),
        colPins(new col_array_t(std::move(colPins)), default_deleter<const col_array_t>),
        addresses(new address_array_t(std::move(addresses)), default_deleter<const address_array_t>) { }

  private:
    array_ptr<const row_array_t> rowPins;
    array_ptr<const col_array_t> colPins;
    array_ptr<const address_array_t> addresses;
};

但是，如果你内联传递所有内容，副本将被转换为堆分配的数组，会被正确删除：

ButtonMatrix<2, 2>::row_array_t rows{{0, 1}};
ButtonMatrix<2, 2>::col_array_t cols{{2, 3}};

ButtonMatrix<2, 2>::address_array_t addresses = {{
  {{0x01, 0x02}},
  {{0x03, 0x04}}
}};

ButtonMatrix<2, 2> bm(rows, cols, addresses);

（请注意，由于ButtonMatrix<2, 2> bm2({{0, 1}}, {{2, 3}}, {{{{1, 2}}, {{3, 4}}}});构造函数的工作方式，您需要对所有内容进行双括号。）

这有点危险，因为 temporaries也可以绑定到const引用 - 如果你在同一个构造函数调用中混合静态和临时数据，第一个构造函数将被调用，< strong>你会存储一个指向暂时离开的指针。不好。

^{更好的解决方案（在同一个构造函数调用中同时允许静态和临时数据）将需要大量的模板魔法。我可能会试着想出这个，但我可能没有时间。}

即使它有点冗长，我也会选择一个解决方案，你在调用网站指定是否必须复制参数。它会更安全，更容易证明你不能存储长期指向临时指针。

具有可变数组大小的模板类：使用数组引用或大括号括起初始化列表初始化

1 个答案: