非类型模板参数、构造函数和推导指南

Question

我想要一个结构模板，它由在构造过程中传递给它的组件的特定值定义，这样不同的值会创建不同的 C++ 数据类型，并且认为非类型模板参数可能对此有用。 像这样（只是一个简单的例子来说明问题，真正的结构会更复杂）：

enum ElementType
{
    TYPE1,
    TYPE2
};

template<ElementType elementType, int size>
struct DataType
{
    DataType(ElementType et = elementType, int s = size):
        elementType_(et),
        size_(s)
    {
    }
    ElementType elementType_;
    int size_;
};

int main()
{
    auto d1 = DataType(ElementType::TYPE1, 1);
}

我尝试使用 g++-8 -std=c++17 构建它，它给了我以下错误：

./main.cpp:23:42: error: class template argument deduction failed:
auto d1 = DataType(ElementType::TYPE1, 1);
                                      ^
../main.cpp:23:42: error: no matching function for call to     ‘DataType(ElementType, int)’
../main.cpp:12:2: note: candidate: ‘template<ElementType elementType, int size> DataType(ElementType, int)-> DataType<elementType, size>’
  DataType(ElementType et = elementType, int s = size):
  ^~~~~~~~
../main.cpp:12:2: note:   template argument deduction/substitution failed:
../main.cpp:23:42: note:   couldn't deduce template parameter ‘elementType’
  auto d1 = DataType(ElementType::TYPE1, 1);
                                      ^
../main.cpp:23:42: error: expression list treated as compound expression in functional cast [-fpermissive]
../main.cpp:23:42: warning: left operand of comma operator has no effect [-Wunused-value]

请注意，我不能使用类型模板参数，因为这两种类型的参数是固定的（ElementType 和 int），但 DataType(ElementType::TYPE1, 1) 的类型必须与 DataType(ElementType::TYPE1, 2) 和 DataType(ElementType::TYPE1, 1) 的类型不同不同于DataType(ElementType::TYPE2, 1)。

Answer 1

你可以这样定义你的模板：

template<ElementType elementType, int size>
struct DataType
{
    const ElementType elementType_ = elementType;
    const int size_ = size;
};

并像这样创建它的一个实例：

auto d1 = DataType<ElementType::TYPE1, 1>();

Demo

Answer 2

要使用推导，传递给构造函数的值需要是一个常量表达式。不幸的是，作为参数传递的值失去了它们的 constexpr 属性。为了防止这种行为，您可以传递包装在类型中的值，例如使用std::integral_constant。

示例用法：

#include <type_traits>

enum ElementType
{
    TYPE1,
    TYPE2
};

template<ElementType elementType, int size>
struct DataType
{
    DataType(std::integral_constant<ElementType, elementType>, std::integral_constant<int, size> ic):
        elementType_(elementType),
        size_(ic)
    {
    }
    ElementType elementType_;
    int size_;
};

int main()
{
    auto d1 = DataType(std::integral_constant<ElementType, TYPE1>{}, std::integral_constant<int, 1>{});
}

[live demo]

为了更方便使用，您可以使用 constexpr 后缀运算符环绕整型 const：

#include <type_traits>

enum ElementType
{
    TYPE1,
    TYPE2
};


template <class... Ts>
constexpr int ival(Ts... Vs) {
    char vals[sizeof...(Vs)] = {Vs...};
    int result = 0;
    for (int i = 0; i < sizeof...(Vs); i++) {
        result *= 10;
        result += vals[i] - '0';
    }
    return result;
}

template <class T, class... Ts>
constexpr ElementType etval(T V, Ts... Vs) {
    if (V == '1')
       return TYPE1;
    if (V == '2')
       return TYPE2;
}

template <char... Vs>
std::integral_constant<int, ival(Vs...)> operator""_i() {
    return {};
}

template <char... Vs>
std::integral_constant<ElementType, etval(Vs...)> operator""_et() {
    return {};
}


template<ElementType elementType, int size>
struct DataType
{
    DataType(std::integral_constant<ElementType, elementType>, std::integral_constant<int, size> ic):
        elementType_(elementType),
        size_(ic)
    {
    }
    ElementType elementType_;
    int size_;
};

int main()
{
    auto d1 = DataType(1_et, 1_i);
}

[live demo]