基於模板參數的模板類強制參數數

Question

我有一個類可以根據單個大小參數進行模板化。我想要一個構造函數，它接受基於模板大小參數的可變金額std::array。所以如果課堂模板化爲一個。它應該接受一個數組。如果模板兩個應該接受兩個等

這是我想出了，但顯然它不工作：

template<std::size_t V> 
class Test 
{ 
public: 

    /* Constructors. */ 
    Test() {} 

    template <std::array<int, 3> ...Args, typename = typename std::enable_if<V == sizeof...(Args), void>::type> 
    Test(std::array<int, 3>&&... args) 
    { 

    } 

}; 


int main() 
{ 
    auto t = Test<1>({ 1, 2, 3 }); 
    auto t2 = Test<2>(
     { 1, 2, 3 }, 
     { 4, 5, 6 } 
    ); 
} 

我收到的錯誤是：

error C2993: 'std::array<int,3>': illegal type for non-type template parameter 'Args' 
note: see reference to class template instantiation 'Test<V>' being compiled 
error C3543: 'std::array<int,3> &&': does not contain a parameter pack 
error C2440: '<function-style-cast>': cannot convert from 'initializer list' to 'Test<1>' 
note: No constructor could take the source type, or constructor overload resolution was ambiguous 
error C2440: '<function-style-cast>': cannot convert from 'initializer list' to 'Test<2>' 
note: No constructor could take the source type, or constructor overload resolution was ambiguous 

任何幫助表示讚賞。

Answer 1

有了繼承，你可以這樣做：

template <std::size_t, typename T> using alwaysT = T; 

template <typename T, typename Seq> struct TestHelper; 

template <typename T, std::size_t ... Is> 
struct TestHelper<T, std::index_sequence<Is...>> 
{ 
    TestHelper(alwaysT<Is, T>... arr) {} 
}; 

template<std::size_t V> 
class Test : TestHelper<const std::array<int, 3>&, std::make_index_sequence<V>> 
{ 
public: 
    using TestHelper<const std::array<int, 3>&, std::make_index_sequence<V>>::TestHelper; 
    Test() = default; 
}; 

Demo

Answer 2

一些工作從評論的解決方案：

#include <type_traits> 
#include <array> 

template<typename... TArgs> struct 
contains_only_array_of_3_int 
{ 
    static constexpr bool const value{false}; 
}; 

template<typename TBack> struct 
contains_only_array_of_3_int<TBack> 
{ 
    static constexpr bool const value 
    { 
     ::std::is_same<::std::array<int, 3>, TBack>::value 
    }; 
}; 

template<typename TFront, typename... TRest> struct 
contains_only_array_of_3_int<TFront, TRest...> 
{ 
    static constexpr bool const value 
    { 
     contains_only_array_of_3_int<TFront>::value 
     && 
     contains_only_array_of_3_int<TRest...>::value 
    }; 
}; 

template<std::size_t V> class 
Test 
{ 
    public: 
    Test() {} 

    template <typename... TArgs> 
    Test(TArgs && ... args) 
    { 
     static_assert 
     (
      sizeof...(TArgs) == V 
     , "arguments count mismatch" 
     ); 
     static_assert 
     (
      contains_only_array_of_3_int<::std::decay_t<TArgs>...>::value 
     , "arguments type mismatch" 
     ); 
    } 
}; 

int main() 
{ 
    Test<1> t 
    { 
     ::std::array<int, 3>{ 1, 2, 3 } 
    }; 
    Test<2> t2 
    { 
     ::std::array<int, 3>{ 1, 2, 3 } 
    , ::std::array<int, 3>{ 4, 5, 6 } 
    }; 
    Test<3> t3 
    { 
     ::std::array<int, 3>{ 1, 2, 3 } 
    , ::std::array<int, 3>{ 4, 5, 6 } 
    , ::std::array<int, 3>{ 7, 8, 9 } 
    }; 
    Test<3> t3_args_count_fail 
    { 
     ::std::array<int, 3>{ 1, 2, 3 } 
    , ::std::array<int, 3>{ 4, 5, 6 } 
    }; 
    Test<3> t3_args_tupe_fail 
    { 
     ::std::array<int, 3>{ 1, 2, 3 } 
    , ::std::array<int, 2>{ 4, 5 } 
    , ::std::array<int, 3>{ 7, 8, 9 } 
    }; 
    return(0); 
} 

online editor