C++ 可变模板参数包仅接受无符号整数或大小\u t作为其类型

我试图使用一组带有可变参数的模板类。我面前有几个选择，我可以选择。在声明或定义任何模板之前，我目前拥有这些原型：我熟悉模板，但在使用模板时没有太多可变类型的经验，因此语法有时会让我感到有点困惑。因为它们都是空的shell，所以它们当前正在编译

template<typename ClassType, typename... Args>  class MatrixReference;
template<typename ClassType, typename... Args>  class MatrixStorage;
template<typename ClassType, typename... Args>  class MatrixAllocation;

编辑

---

我忘了在原来的问题上加上这个，但为了更清楚一点，我现在加上它。我确实需要测试每个可变参数的值，看看它是奇数还是偶数，它们的结果将被存储到一个向量中，向量的大小等于存储0表示偶数或1表示奇数的参数量。这就是我倾向于使用参数包的原因之一，因为我可以将它传递给一个助手函数，该函数将返回所需的向量。

std:：size\t。。。Args

和

类型名。。。参数不相同。第一个会期望像这样的整数

Matrix<float,2,2> mat2x2;

矩阵mat2x2；

而第二个则期望类型为而不是。

当然，您可以使用，但这会更详细：

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

Matrix<float,size<2>,size<2>> mat2x2;

模板
使用size=std:：integral_常量；
矩阵mat2x2；

另一方面，您可以使用：

模板
类矩阵{
使用维度=标准：：索引\u序列；
};
使用静态断言可以在编译时检查：

template <typename ClassType,typename... Dimensions>
class DimensionPack {
        public:
            DimensionPack(const Dimensions&... args){
                checkType<Dimensions...>(args...);
            }
            ~DimensionPack(){}
        private:
            template<typename T> void checkType(const T& t) {
                static_assert(std::integral_constant<bool, std::is_same<T, size_t>::value>(), "T is not of type size_t");
            }
            template<typename T, typename... V> void checkType(const T& t, const V&... v) {
                static_assert(std::integral_constant<bool, std::is_same<T, size_t>::value>(), "T is not of type size_t");
                checkType<V...>(v...);
            }
    };

模板
类维度包{
公众：
维度包（常量维度和参数）{
检查类型（args…）；
}
~DimensionPack（）{}
私人：
模板无效检查类型（常量T&T）{
静态_断言（std:：integral_constant（），“T不是size_T类型”）；
}
模板无效检查类型（常量T&T、常量V和…V）{
静态_断言（std:：integral_constant（），“T不是size_T类型”）；
支票类型（v…）；
}
};
有什么原因不能只使用
模板
？@AlexZywicki我也这么想，但不确定提取并扩展成std:：tuple的helper类是否会让事情变得更简单。@AlexZywicki Oh；我差点忘了，但我确实需要检查矩阵的每个维度是奇数还是偶数。因此，除了让std:：size\u t…

将它们存储到参数包中，还需要生成该包大小的向量，并用0表示偶数或1表示奇数。我可以继续澄清我的问题。因此，答案是没有理由不使用

size\t…Args

。你走错了路。@FrancisCugler动态分配存储编译时常量似乎是个坏主意，但不是我的猴子，不是我的马戏团。是的，我理解这一点；但是我倾向于使用一个helper模板类，仅用于参数包，将内容存储到

std:：tuple

中，这将有助于打包和解包参数列表。我还需要检查这些参数，看看它们是否在x>0的范围内，并测试它们是偶数还是奇数，然后将这些结果保存到一个容器中。然后我就可以把它传递给我的助手函数…或者我是在看这个。。。我可以在哪里使用，但仍然可以将其保存到同一助手类和函数中的std:：tuple。@FrancisCugler和解包

std:：index_序列

有什么问题吗？我不熟悉index_序列，我不希望实例化看起来像这样：

Matrix

等等。我更喜欢

Matrix

Matrix<float,2,2> mat2x2; // Default constructor making it empty

Matrix<int,3,3,3> mat3x3x3; 

template <typename ClassType,typename... Dimensions>
class DimensionPack {
public: 
    typename std::tuple<ClassType, std::tuple<Dimensions...> >::type Dim;
    const unsigned int numarguments = sizeof...(Dimensions);
};

template<typename ClassType, std::size_t bufferSize>
class MatrixBuffer {
    static std::vector<ClassType> matrixBuffer = std::vector<ClassType>().reserve( bufferSize );
};

Matrix<float,2,2> mat2x2;

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

Matrix<float,size<2>,size<2>> mat2x2;

template<typename ClassType, std::size_t... Dims>
class Matrix {
    using Dimensions = std::index_sequence<Dims...>;
};

template <typename ClassType,typename... Dimensions>
class DimensionPack {
        public:
            DimensionPack(const Dimensions&... args){
                checkType<Dimensions...>(args...);
            }
            ~DimensionPack(){}
        private:
            template<typename T> void checkType(const T& t) {
                static_assert(std::integral_constant<bool, std::is_same<T, size_t>::value>(), "T is not of type size_t");
            }
            template<typename T, typename... V> void checkType(const T& t, const V&... v) {
                static_assert(std::integral_constant<bool, std::is_same<T, size_t>::value>(), "T is not of type size_t");
                checkType<V...>(v...);
            }
    };