基于参数值的模板重载

Question

我想做的是能够根据参数的值对同一个模板类进行不同的声明，如下所示：

// Enable if X == 2
template <int X, int W, typename Y,
          typename A = int, typename B = int> struct Z {}; 

// Enable if X != 2
template <int X,        typename Y,
          typename A = int, typename B = int> struct Z {};

我可以这样开始：

template <int X, int W, typename Y, typename A = int, typename B = int, 
          typename = std::enable_if_t<X == 2>> struct Z {};
template <int X,        typename Y, typename A = int, typename B = int,
          typename = std::enable_if_t<X != 2>> struct Z {};

问题在于，可以理解的是，它已使用不同数量的参数重新声明。

可变参数模板功能可以派上用场，但不幸的是，它只支持类型而不支持字面量，就像本例一样。

template <typename... Args> struct Z {};
template <int X, int W, typename Y,
          typename A = int typename B = int> struct Z<X, W, Y> {};

类型/值不匹配 -> 期望类型，得到 'X/W'

有人对此有解决方案吗？

编辑

对不起我之前没有提到，但很遗憾我不能改变参数的顺序，因为Y之后的其他参数都有默认值。

Answer 1

你说过你想按照这里的 cmets 所说的那样做：

// Enable if X == 2
template <int X, int W, typename Y, typename A=int, typename B=int> 
struct Z {}; 

// Enable if X != 2
template <int X,        typename Y, typename A=int, typename B=int> 
struct Z {};

显然，当X !=2 时，您希望不使用第二个模板参数。你可以不用名字来定义它。

部分特化可用于进行选择：

// PRIMARY TEMPLATE: Used if X != 2
template <int X, int, typename Y, typename A=int, typename B=int> 
                //^^ see here
struct Z {};

// PARTIAL SPECIALIZATION: Used if X == 2
template <int W, typename Y, typename A, typename B> 
struct Z<2, W, Y, A, B> {}; 

---

编辑 1 of 2： （根据您的评论）

我希望能够使用只有两个参数的结构 Z (if X!=2): Z<3, int>

您必须重新排序模板并在主模板中使用默认参数

// PRIMARY TEMPLATE: Used if X != 2
template <int X, typename Y, int=0, typename A=int, typename B=int> 
                             //^^ see here
struct Z {};

// PARTIAL SPECIALIZATION: Used if X == 2
template <typename Y, int W, typename A, typename B> 
struct Z<2, Y, W> {}; 

你可以用作：

Z<2, int> z;
Z<3, int, 5> z3;

---

EDIT 2 of 2: （对您的问题编辑和 cmets）

套用你的话：

我希望能够在不重新排序我的模板的情况下执行Z<3, int> 参数

如果第二个模板参数是类型 并且其余参数默认。不幸的是，这不是你的情况。所以如果这真的是你的问题，你就在这里死胡同了。

Answer 2

如果您可以使用 C++14 并且您可以接受您的整数包含在 std::integer_sequence 中，您可以通过这种方式定义 Z 的两个版本

#include <iostream>
#include <utility>

template <typename, typename>
struct Z;

template <int W, typename T>
struct Z<std::integer_sequence<int, W>, T>
 { static constexpr int c { 0 }; };

template <int X, typename T>
struct Z<std::integer_sequence<int, 2, X>, T>
 { static constexpr int c { 2 }; };

int main()
 {
   Z<std::integer_sequence<int, 0>, long>     z0;
   Z<std::integer_sequence<int, 2, 7>, long>  z2;
   Z<std::integer_sequence<int, 2>, long>     zX;  // unacceptable ?

   std::cout << "z0: " << z0.c << std::endl;  // output: z0: 0
   std::cout << "z2: " << z2.c << std::endl;  // output: z2: 2
   std::cout << "zX: " << zX.c << std::endl;  // output: zX: 0
 }

我不知道如何避免定义为 zX 与 X == 2 和没有 W 但是，如果您希望 zX 用作 z2，您可以通过以下方式定义 Z

template <typename, typename>
struct Z;

template <typename T, int ... I>
struct Z<std::integer_sequence<int, I ...>, T>
 { static constexpr int c { 0 }; };

template <typename T, int ... I>
struct Z<std::integer_sequence<int, 2, I ...>, T>
 { static constexpr int c { 2 }; };

和zX 返回2。

第二个解决方案的问题是，即使Z 使用未定义的整数进行编译。我的意思是编译（使用第二种解决方案）

 Z<std::integer_sequence<int, 0, 5, 6, 7>, long>     z0;

--- 编辑---

对不起，我是个白痴。

避免zX的定义很简单。

在这两种情况下，您都可以声明（但不能定义）以下特化。

template <typename T>
struct Z<std::integer_sequence<int, 2>, T>;

Answer 3

如果不重新排序参数或使用其他数据结构来包装参数，您将无法执行此操作。

无论如何，您可以使用constexpr 构造函数来提交额外的参数，并能够在常量表达式中使用您的类型。
举个例子：

template <int X, typename Y, typename A = int, typename B = int>
struct Z {
    constexpr Z() {}
}; 

template <typename Y, typename A, typename B>
struct Z<2, Y, A, B> {
    constexpr Z(int W) { }
};

int main() {
    constexpr Z<0, void> z1;
    constexpr Z<2, void> z2{42};
}

如果这是一个好的折衷方案，主要取决于真正的问题。

Answer 4

如果您可以更改模板参数的顺序，您可以专门化您的类并使用默认值：

// Chosen if X != 2
template<int X, typename Y, typename A = int, typename B = int, int = 0>
struct Z {}; // W is discarded

// Chosen if X == 2
template<typename Y, typename A, typename B, int W>
struct Z<2, Y, A, B, W> {};

Live example