c++ - 具有可变数组大小的模板类 : initialize with array reference or brace-enclosed initializer list

Question

考虑以下类:

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 的内容:

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

这样，我可以使用数组引用或大括号括起来的初始化列表来初始化它。
唯一的缺点是当使用数组引用时，相同数据有两个拷贝。目标平台是 Arduino，所以我想将内存使用量保持在最低限度。
有没有办法确定是否使用了初始化列表来初始化它，如果是，则为数组动态分配内存？
沿着这些方向:C++ overload constructor with const array and initializer_list

如果初始化列表的维度与 nb_rows 和 nb_cols 不匹配，那么出现编译时错误会很好，这样就排除了 std::initializer_list(如有错误请指正)。

Answer 1

如果我们可以用 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}}}});

(请注意，由于 std::array 构造函数的工作方式，所有内容都需要双括号。)

---

但这有点危险，因为临时对象也可以绑定(bind)到常量引用——如果您在同一个构造函数调用中混合静态和临时数据，第一个构造函数将被调用并且 < strong>您将存储一个指向即将消失的临时对象的指针。不好。

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

即使它有点冗长，我还是会选择一个解决方案，您可以在调用站点指定是否必须复制参数。证明您没有存储指向临时对象的长生命周期指针会更安全，也更容易。