Определяемые пользователем руководства по вычету для параметров шаблона, не являющегося типом

Question

У меня есть зачатки матричного класса. Вот код -

      template<int h, int w = h>
class mat {
public:
    mat() : values(h, std::vector<double>(w)) {
        if (w == h) {
            int x = 0;
            for (int y = 0; y < h; y++) {
                values[y][x] = 1;
                x++;
            }
        }
    }
    mat(std::initializer_list<std::vector<double>> matvals){
        values = matvals;
    }
    mat(int val) : values(h, std::vector<double>(w, val)) {}
    mat(const mat& m) {
        values = m.values;
    }
    mat(mat&& m) {
        values = std::move(m.values);
    }
    int width() {
        return w;
    }
    int height() {
        return h;
    }
    template<int mh, int mw = mh>
    auto operator*(const mat<mh, mw>& m) -> mat<h, mw> const {
        if (w != mh) throw std::logic_error{ "Matrices cannot be multiplied" };
        mat<h, mw> temp;
        std::vector<double> mcol(mh);
        for (int y = 0; y < mw; y++) {
            for (int mx = 0; mx < mw; mx++) {
                for (int my = 0; my < mh; my++) {
                    mcol[my] = m.values[my][mx];
                }
                temp.values[y % h][mx] = dot(values[y % h], mcol);
            }
        }
        return temp;
    }
    mat operator+(const mat& m) const {
        mat temp;
        for (int y = 0; y < h; y++) {
            for (int x = 0; x < w; x++) {
                temp.values[y][x] = values[y][x] + m.values[y][x];
            }
        }
        return temp;
    }
    std::vector<double>& operator[](int y) {
        return values[y];
    }
    mat& operator=(const mat& m) {
        values = m.values;
        return *this;
    }
    mat& operator=(mat&& m) {
        values = std::move(m.values);
        return *this;
    }
private:
    std::vector<std::vector<double>> values;

    template<int mw, int mh>
    friend class mat;
};

Вот как этот класс используется до сих пор:

      mat<2, 4> mat1 = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
};

mat<4, 3> mat2 = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
    {10, 11, 12}
};

auto mat3 = mat1 * mat2;

Заметили избыточность? Если пользователь хочет создать матрицу с помощью конструктора, он должен сначала указать ширину и высоту в параметрах шаблона. Кроме того, существует проблема, если они используют std::initializer_listчьи размеры отличаются от тех, что были указаны в аргументах шаблона, то поведение будет неопределенным. Как мне написать руководство по вычету для параметров шаблона, не являющихся типом? Я знаю, как это сделать с помощью базового шаблона, но все, что я пытаюсь сделать, как обычно, дает много ошибок компилятора. Вот желаемое поведение -

      mat mat1 = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
};

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

auto mat3 = mat1 * mat2;

РЕДАКТИРОВАТЬ: любой, кто действительно хочет создать матричный класс, не должен указывать параметры шаблона ширины и высоты. Это просто излишне усложняет ситуацию.

Answer 1

если вы предоставите такой конструктор:

      template<int w, int h>
struct A{
    A(double (&&c)[w][h]); // `double const (&c)[w][h]` is also OK.
};

без какого-либо другого руководства по дедукции, вы можете использовать его следующим образом:

      A a{{
    {1, 2, 3},
    {4, 5, 6}
}};
A b = {{
    {1, 2, 3},
    {4, 5, 6}
}};
A c({
    {1, 2, 3},
    {4, 5, 6}
});

но мы можем подумать, что внешние скобки ужасны, поэтому мы должны предоставить специальный конструктор и руководство по выводам:

      namespace Impl{
    template<typename T, typename = void>
    struct helper;
    template<int h1, int... hs>
    struct helper<std::integer_sequence<int, h1, hs...>, std::enable_if_t<((h1 == hs) && ...)>>{
        static constexpr int w = sizeof...(hs) + 1;
        static constexpr int h = h1;
    };
    template<int... hs>
    inline constexpr int helper_w = helper<std::integer_sequence<int, hs...>>::w;
    template<int... hs>
    inline constexpr int helper_h = helper<std::integer_sequence<int, hs...>>::h;
}

template<int w, int h>
struct A{
    template<int... hs, typename = std::enable_if_t<w + 1 == Impl::helper_w<h, hs...>>>
    A(double (&&... head)[hs]);
};

template<int... hs>
A(double (&&... head)[hs]) -> A<Impl::helper_w<hs...>, Impl::helper_h<hs...>>;

а затем вы можете использовать его как хотите:

      A a{
    {1, 2, 3},
    {4, 5, 6}
};
A b = {
    {1, 2, 3},
    {4, 5, 6}
};

Answer 2

Вы можете получить

      mat mat2 = {
  row{1, 2, 3},
  row{4, 5, 6},
  row{7, 8, 9},
  row{10, 11, 12}
};

работать; напишите 1-мерную строку, размер которой определяется из Ts&&... и type проверяет Ts совпадать, затем иметь mat быть строкой из одномерных рядов (или повторно реализовать тот же механизм).

Я не знаю, есть ли способ избежать явного ввода (ну, вроде) «строк», а также получения длины consteval для вывода типа матрицы.

Забавная игра состоит в том, чтобы определить умножение матриц в терминах умножения строк, матрица multb - это транспонированная mult2 b, где a mult2 b - это внутреннее произведение матрицы a_i b_j.

Конечно, эта кроличья нора продолжается.