c++ - 使用 std::tuple 使用模板的多项式乘法

Question

假设我有一个表示两个多项式系数的 2 元组，我该如何计算乘法系数。 我想用模板来完成这个。

mul_scalar() 将元组的值与标量相乘。 我正在尝试使用此函数扩展到多项式情况。通过迭代一个元组并使用 mul_scalar()

#include <tuple>
#include <utility> 
#include <iostream>

template<std::size_t I = 0, typename T, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
mul_scalar(const T& lhs, const std::tuple<Tp...> rhs ) // Unused arguments are given no names.
{ }

template<std::size_t I = 0, typename T, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
mul_scalar(const T& lhs, const std::tuple<Tp...> rhs)
{
    std::cout << (std::get<I>(rhs))*lhs << " ";
    mul_scalar<I + 1, T, Tp...>(lhs, rhs);
}

template <std::size_t I = 0, template <typename ...> class Tup1, template <typename ...> class Tup2, typename ...A, typename ...B>
inline typename std::enable_if<I < sizeof...(A), void>::type
mul_poly(const Tup1<A...>& lhs, const Tup2<B...> rhs)
{
    mul_scalar(std::get<I>(lhs), rhs);
    //mul_poly(lhs, rhs); with I = I + 1
    // However I can't figure how to give other template args
}

int main(){
    auto poly_1 = std::make_tuple(2,1);
    auto poly_2 = std::make_tuple(3,4,5);
    mul_scalar(3,poly_1);
    std::cout << "\n";

    // Expected output 6 8 10 3 4 5
    mul_poly(poly_1, poly_2);
}

Answer 1

递归调用很简单

mul_poly<I+1u>(lhs, rhs);

但是你必须加上ground case

template <std::size_t I = 0, template <typename ...> class Tup1,
          template <typename ...> class Tup2, typename ...A, typename ...B>
inline typename std::enable_if<I == sizeof...(A), void>::type
    mul_poly (const Tup1<A...> &, const Tup2<B...> &)
 { }

would be great if you could tell me other approaches as well

额外建议:如果可以使用 C++17，则可以避免 SFINAE 和递归，对于 mul_scalar()，使用 std::index_sequence/ std::make_index_sequence(或std::index_sequence_for)和模板折叠如下

template <typename T, typename ... Tp, std::size_t ... Is>
void mul_scalar_helper (T const & lhs, std::tuple<Tp...> const & rhs,
                        std::index_sequence<Is...> const &)
 { ((std::cout << (std::get<Is>(rhs))*lhs << ' '), ...); }

template <typename T, typename ... Tp>
void mul_scalar (T const & lhs, std::tuple<Tp...> const & rhs)
 { mul_scalar_helper(lhs, rhs, std::index_sequence_for<Tp...>{}); }

mul_poly() 没有太大区别

template <template <typename ...> class Tup1,
          template <typename ...> class Tup2,
          typename ... A, typename ... B, std::size_t ... Is>
void mul_poly_helper (Tup1<A...> const & lhs, Tup2<B...> const & rhs,
                      std::index_sequence<Is...> const &)
 { (mul_scalar(std::get<Is>(lhs), rhs), ...); }

template <template <typename ...> class Tup1,
          template <typename ...> class Tup2,
          typename ...A, typename ...B>
void mul_poly (Tup1<A...> const & lhs, Tup2<B...> const & rhs)
 { mul_poly_helper(lhs, rhs, std::index_sequence_for<A...>{}); }

无论如何...您确定 std::tuple 是正确的容器吗？您是否考虑过 std::array？

--- 编辑 ---

按照 liliscent 的建议(谢谢!)，您可以使用 std::apply( ) 简单的写

template <typename T, typename ... Tp>
void mul_scalar (T const & lhs, std::tuple<Tp...> const & rhs)
 { std::apply([&](auto const & ... x){ ((std::cout << x*lhs << ' '), ...); }, rhs); }

template <template <typename ...> class Tup1,
          template <typename ...> class Tup2,
          typename ...A, typename ...B>
void mul_poly (Tup1<A...> const & lhs, Tup2<B...> const & rhs)
 { std::apply([&](auto const & ... x){ (mul_scalar(x, rhs), ...); }, lhs); }

您还可以使用几个 std::apply() 编写 mul_poly()，而无需调用 mul_scalar()

template <template <typename ...> class Tup1,
          template <typename ...> class Tup2,
          typename ...A, typename ...B>
void mul_poly (Tup1<A...> const & lhs, Tup2<B...> const & rhs)
 { std::apply([&](auto const & ... x){
      (std::apply([x](auto const & ... y){ ((std::cout << x*y << ' '), ...); }, 
                  rhs), ...); }, lhs); }