如何专门化可变类模板

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();
}

我想知道如何专门化特征结构，以便在上面的示例中将内存类型正确地分配为std::array，并将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());
}