c++ - 将类数组对象作为模板值参数

Question

我想实现一个

template<class ValueType,UnitTag x>
clsas Quantity;

像运算符

template<UnitTag y>
Quantity<T,x+y> operator*(Quantity<T,y> b)
    {return Quantity<T,x+y>(m_value*b.value());}

(也可以添加数量，但只能是同类)

UnitTag 的操作必须按元素进行

x_0 + y_0 = z_0
x_1 + y_1 = z_1
x_2 + y_2 = z_2
x_3 + y_3 = z_3
...

最直接的方法是让 UnitTag 成为一个 constexpr 数组。但这不能用作模板参数。作为一种解决方法，我可以使用大整数类型来实现，并使用少量位来表示每个维度。然而，这对维数或每个维的幂给出了限制:例如，对于 64 位和 16 维，我只涵盖 [L^(-8), L^7]。这对大多数应用程序来说应该是好的，但该类不能处理根，因为这需要分数次幂。

有什么方法可以在模板参数中传递超过 64 位的信息吗？例如，是否可以对模板参数包进行逐元素操作？所需的逐元素操作是:

• 加法(用于乘法)
• 减法(除法)

对于激进分子:

• 除法(这要求元素表现得像有理数。可以使用 constexpr word() 访问器实现为一个类)

Answer 1

我试着提出一个解决方案

is it possible to do element-wise operations on a template parameter pack?

不确定(我不知道你到底想用这个值做什么)但是如果你将模板参数包包装在 std::integer_sequence (或 std::index_sequence 如果你可以使用一包 std::size_t)，这对我来说似乎是可能的。

不幸的是，std::integer_sequence 和 std::index_sequence 是 C++14 特性。但是如果你需要在 C++11 中，很容易实现类似的东西。

下面是一个使用std::index_sequence的例子

-- 编辑 -- 添加减法/除法的修改示例

#include <utility>
#include <type_traits>

template <typename, typename>
struct addVI;

template <std::size_t ... Is, std::size_t ... Js>
struct addVI<std::index_sequence<Is...>, std::index_sequence<Js...>>
 {
   static_assert(sizeof...(Is) == sizeof...(Js), "! add");

   using type = std::index_sequence<(Is+Js)...>;
 };

template <typename, typename>
struct subVI;

template <std::size_t ... Is, std::size_t ... Js>
struct subVI<std::index_sequence<Is...>, std::index_sequence<Js...>>
 {
   static_assert(sizeof...(Is) == sizeof...(Js), "! sub");

   using type = std::index_sequence<(Is-Js)...>;
 };

template <typename, typename>
struct foo;

template <typename T, std::size_t ... Is>
struct foo<T, std::index_sequence<Is...>>
 {
   template <std::size_t ... Js>
   using Ks = typename addVI<std::index_sequence<Is...>,
                             std::index_sequence<Js...>>::type;

   template <std::size_t ... Js>
   using Ls = typename subVI<std::index_sequence<Is...>,
                             std::index_sequence<Js...>>::type;

   template <std::size_t ... Js>
   foo<T, Ks<Js...>> operator* (foo<T, std::index_sequence<Js...>> const & b)
    { return foo<T, Ks<Js...>>(); }

   template <std::size_t ... Js>
   foo<T, Ls<Js...>> operator/ (foo<T, std::index_sequence<Js...>> const & b)
    { return foo<T, Ls<Js...>>(); }

 };

int main ()
 {
   foo<int, std::index_sequence<1, 2, 3>> f1;
   foo<int, std::index_sequence<2, 3, 5>> f2;

   static_assert(std::is_same<decltype(f1*f2),
                              foo<int, std::index_sequence<3, 5, 8>>>::value,
                 "!!");

   static_assert(std::is_same<decltype(f2/f1),
                              foo<int, std::index_sequence<1, 1, 2>>>::value,
                 "!!!");
 }