如何专门用可变参数类模板

Question

下面的示例代码说明我的问题：

#include <array> 
#include <vector> 
#include <iostream> 
#include <type_traits> 

namespace Vector 
{ 
    namespace Intern 
    { 
     template <typename T1, typename ...T2> 
     struct Traits; 

     // How can I specialize here so that Memory is being assigned properly?? 
     template <typename T1, int N> 
     struct Traits<T1, int> { 
      static constexpr bool Static = 1; 
      using Memory = std::array<T1, N>; 
     }; 

     template <typename T1> 
     struct Traits<T1> { 
      static constexpr bool Static = 0; 
      using Memory = std::vector<T1>; 
     }; 
    } 

    template <typename T1, typename ...T2> 
    class Object 
    { 
     public : 
      void printd() 
      { 
       std::cout << "Is Static: " << Traits::Static << std::endl; 
      } 
     private: 
      using Traits = Intern::Traits<T1, T2...>; 
      using Memory = typename Traits::Memory; 

      Memory m_memory; 
    }; 

    template <typename T1, typename ...T2> 
    static auto Create(T2&& ...ln) -> decltype(auto) 
    { 
     return new Object<T1, T2...>(); 
    } 
} 

int main() 
{ 
    auto static_vector = Vector::Create<int>(10); 
    static_vector->printd(); 

    auto active_vector = Vector::Create<int>(); 
    active_vector->printd(); 
} 

我想知道我可以专注性状结构，这样的类型存储器进行适当的分配为标准::在上面的例子中，N设为10。

Answer 1

您不能直接使用整数，但可以将整数包装为一个类型。这可以使用例如 例如std::integral_constant：

template <typename T1, typename T2, int N> 
struct Traits<T1, std::integral_constant<T2, N>> { 
    static constexpr bool Static = 1; 
    using Memory = std::array<T1, N>; 
}; 

template <typename T1> 
struct Traits<T1> { 
    static constexpr bool Static = 0; 
    using Memory = std::vector<T1>; 
}; 


auto static_vector = Vector::Create<int, std::integral_constant<int, 10>>(); 

Answer 2

保持简单：

#include <array> 
#include <vector> 
#include <iostream> 
#include <type_traits> 

namespace Vector 
{ 
    struct VariableSize {}; 
    template<std::size_t N> struct FixedSize {}; 

    template<typename T, std::size_t N> 
    auto Create(FixedSize<N>) 
    { 
     return std::array<T, N>(); 
    } 

    template<typename T, std::size_t N> 
    auto Create(VariableSize) 
    { 
     return std::vector<T>(); 
    } 
} 

int main() 
{ 
    auto static_vector = Vector::Create<int>(Vector::FixedSize<10>()); 

    auto active_vector = Vector::Create<int>(Vector::VariableSize()); 
}