C++ 11可變參數模板：3..n INT的分成第一，中間，最後

Question

正如標題所說我有一個可變參數模板接受至少3個參數（INT的）

template<int p_first, int p_second, int p_third, int... p_rest> 

和我需要這些分成第一，中間和最後

class MyClass { 
    OtherClass<p_first> first; 
    // Works obviously 

    // std::vector<OtherClass> middle... Doesn't work 

    OtherClass<p_last> last; 
    // No idea how to do this 
} 

的Visual Studio 2015年C++功能都可以

---

編輯：對不起，我忘了提及的關鍵方面。

• OtherClass實現：

  template <int v> 
  class OtherClass { ... }; 
  

• 是的，我想所有值在中間（第一和之間最後）

• "the vector can't hold different types of OtherClass"謝謝你的提醒我。這可能是原因，這是不可能的。
• "Are you reinventing tuples?"也許使用元組確實是一個更好的解決方案。看着它。

謝謝你的職位。我會理解，儘快測試代碼並發表評論！

Answer 1

使用Boost.Hana（需要一個C++編譯器14）：

#include <boost/hana.hpp> 
#include <tuple> 
namespace hana = boost::hana; 


template <int> 
struct OtherClass { }; 

template <int ...I> 
class MyClass { 
    static constexpr auto ints = hana::tuple_c<int, I...>; 

    OtherClass<hana::front(ints)> first; 

    using Middle = typename decltype(
     hana::unpack(hana::slice_c<1, sizeof...(I) - 1>(ints), [](auto ...i) { 
      return hana::type_c<std::tuple<OtherClass<ints[i]>...>>; 
     }) 
    )::type; 
    Middle middle; 

    OtherClass<hana::back(ints)> last; 
}; 

int main() { 
    MyClass<0, 3, 2, 1> x; 
} 

請注意，我在上面濫用一個鏘錯誤，因爲lambda表達式不允許出現在未評估的情況下。爲了符合標準，在調用hana::unpack時，應使用手寫函數對象而不是lambda表達式。另外，如果你使用Hana方式，如果編譯時性能是一個考慮因素，我會建議你使用hana::tuple，因爲std::tuple是所有已知標準庫實現中的一個緩存。

Answer 2

你可以寫一個輔助結構從一個int包拿到N日int：

template <std::size_t N, int... I> 
struct get_n : 
    std::integral_constant<int, 
     std::get<N>(std::array<int,sizeof...(I)> { I... }) 
    > 
{}; 

然後，你可以寫元函數來獲取中間和結尾：

template <int... I> 
using get_middle = get_n<sizeof...(I)/2 - 1, I...>; 

template <int... I> 
using get_end = get_n<sizeof...(I) - 1, I...>; 

您可以使用這樣如此：

using p_last = get_end<p_third, p_rest...>; 
OtherClass<p_last> last; 

---

如果你想爲所有中間元素設置一個OtherClass<N>的元組，這裏有一個相當簡單的解決方案。請參閱Yakk's answer以獲得更復雜，更靈活的一個。

template <template <int> class ToBuild, class Seq, int... Args> 
struct build_tuple; 

template <template <int> class ToBuild, std::size_t... Idx, int... Args> 
struct build_tuple<ToBuild, std::index_sequence<Idx...>, Args...> { 
    using type = std::tuple<ToBuild<get_n<Idx, Args...>::value>...>; 
}; 

template<int p_first, int p_second, int p_third, int... p_rest> 
struct MyClass { 
    MyClass() { 
     typename build_tuple<OtherClass, 
          std::make_index_sequence<sizeof...(p_rest) + 1>, 
          p_second, p_third, p_rest...>::type middle; 
    } 
}; 

Answer 3

首先，樣板。我在類型中工作，而不是常量，因爲使用類型進行元編程要容易得多。

template<class T>struct tag{using type=T;}; 
template<class Tag>using type_t=typename Tag::type; 

template<int I>using int_k=std::integral_constant<int, I>; 

template<class...>struct types{using type=types;}; 

template<template<class...>class Z, class pack> 
struct apply; 
template<template<class...>class Z, class pack> 
using apply_t=type_t<apply<Z,pack>>; 
template<template<class...>class Z, class...Ts> 
struct apply<Z, types<Ts...>>:tag<Z<Ts...>>{}; 

現在，一旦我們有中間元素的包裝，我們可以應用它們。

template <std::size_t N, class... Ts> 
using get_t = type_t< std::tuple_element< N, std::tuple<Ts...> > >; 

從類型列表中獲取第n個類型。

template <class Is, class pack> 
struct get_slice; 
template <class Is, class pack> 
using get_slice_t=type_t<get_slice<Is,pack>>; 
template<std::size_t...Is, class...Ts> 
struct get_slice<std::index_sequence<Is...>,types<Ts...>>: 
    types< get_t<Is, Ts...>... >{}; 

這讓我們拿一包，並從中得到一個切片。

偏移索引列：

template<class Is, std::size_t I> 
struct offset; 
template<class Is, std::size_t I> 
using offset_t=type_t<offset<Is,I>>; 
template<std::size_t...Is, size_t I> 
struct offset<std::index_sequence<Is...>, I>: 
    tag<std::index_sequence<(I+Is)...>> 
{}; 

提取中間分子開始在長度LEN的開始：

template<std::size_t start, std::size_t len, class pack> 
struct get_mid: 
    get_slice< offset_t< std::make_index_sequence<len>, start >, pack > 
{}; 
template<std::size_t start, std::size_t len, class pack> 
using get_mid_t=type_t<get_mid<start,len,pack>>; 

，現在我們可以將元素分成第一，最後和東西在休息一個元組：

template<int p_first, int p_second, int p_third, int...is> 
class MyClass { 
    using pack = types< int_k<p_first>, int_k<p_second>, int_k<p_third>, int_k<is>... >; 
    OtherClass<p_first> first; 

    using mid = get_mid_t<1, sizeof...(is)+1, pack >; 

    template<class...Ts> 
    using OtherClass_tuple = std::tuple<OtherClass<Ts::value>...>; 

    apply_t< OtherClass_tuple, mid > middle; 

    OtherClass<get_t<sizeof...(is)+2, pack>::value> last; 
}; 

Answer 4

由於OtherClass的定義是未知的和矢量不能持有不同類型的OtherClass我假設以下代碼：

該代碼使用遞歸模板繼承與integer_sequence拆分int pack。

#include <utility> 
#include <vector> 

template<int...> 
struct OtherClass { }; 

template<typename, int... > 
struct Splitter; 

template<int... middle, int next, int... rest> 
struct Splitter<std::integer_sequence<int, middle...>, next, rest...> 
    : Splitter<std::integer_sequence<int, middle..., next>, rest...> { }; 

template<int... middle, int last> 
struct Splitter<std::integer_sequence<int, middle...>, last> 
{ 
    static std::vector<int> const& get_vector() 
    { 
     static std::vector<int> const m = { middle... }; 
     return m; 
    } 

    using last_t = std::integral_constant<int, 
     last 
    >; 
}; 

template<int p_first, int p_second, int p_third, int... p_rest> 
class MyClass 
{ 
    OtherClass<p_first> first; 

    using splitter = Splitter<std::integer_sequence<int>, p_second, p_third, p_rest...>; 

    std::vector<int> middle = splitter::get_vector(); 

    typename splitter::last_t last; 
}; 

Demo