可變類型的可變參數模板參數包

Question

我想知道是否有可能使用參數包捕獲交替的參數模式。 例如，

template<typename T, size_t U, typename... Args>
class foo<T, U, Args...>
{
   public:
     foo() : my_T(nullptr), my_U(U) {}

   private:
     T* my_T;
     size_t my_U;
     foo<Args...> my_next_foo;
}

因此這是行不通的，因為Args是僅類型的參數包。 有沒有辦法修改此類型，以便可以在可變參數模板中正確捕獲類型名稱T，size_t U模式？ 謝謝

Answer 1

根據我的經驗，作為模板參數的值是二等公民。

使用別名將它們升級為頭等艙：

template<std::size_t n>
using size = std::integral_constant<std::size_t, n>;

然后模式匹配：

template<class...>
struct foo;
template<>
struct foo<> {
  // empty
};
template<class T, size_t U, typename... Args>
struct foo<T, size<U>, Args...> {
  foo() : my_T(nullptr), my_U(U) {}

private:
  T* my_T;
  size_t my_U;
  foo<Args...> my_next_foo;
};

鮑勃是你叔叔

但是請注意，將U作為模板參數，然后將其存儲為運行時值是非常可疑的。

foo用戶必須執行以下操作：

foo< Chicken, size<3>, Dog, size<17> >

代替

foo< Chicken, 3, Dog, 17 >

Answer 2

當然，只需編寫自己的一對：

template <typename T, size_t U>
struct foo_pair { };

並打包一包：

template<typename T, size_t U, typename... Pairs>
class foo<foo_pair<T, U>, Pairs...> {
    ...
};

實例化為：

foo<foo_pair<int, 4>, foo_pair<char, 17>, ...> f;

Answer 3

您可以將Args作為std::tuple傳遞給foo 。 對U使用std::integral_constant ，而不要將整數常量作為模板參數傳遞給std::tuple 。 然后， Args參數包包含所有類型和大小對。

例如，實例化foo時，您可以使用以下類型：

Foo<std::tuple<int, std::integral_constant<size_t, 5> >,
    std::tuple<char, std::integral_constant<size_t, 3> > >

實現foo ，應將參數包傳遞給另一個std::tuple並使用std::tuple_element選擇該元組的第N個元素。

這只是一種可能的方法，如果使用類型列表，可能會發現實現foo更容易。

Answer 4

您可以創建一個用size_t my_U表示數據容器T* my_T size_t my_U 。 有了它，您可以實現您的模板：

#include <array>

using std::size_t;

template<typename... Args>
struct foo;

template<typename T, size_t N>
struct foo<std::array<T, N>>
{
    std::array<T, N> array;
};

template<typename T, size_t N, typename... Args>
struct foo<std::array<T, N>, Args...>
{
    std::array<T, N> array;
    foo<Args...> next_array;
};

int main() {
    foo<std::array<char, 1>, std::array<short, 2>, std::array<int, 4>> foos;
}

注意：我使用std :: array代替數據容器。