有条件的编译时包含/排除基于模板参数的代码？

Question

考虑以下类，内部结构Y被用作类型，例如。模板，以后：

template<int I> 
class X{ 
    template<class T1> 
    struct Y{}; 

    template<class T1, class T2> 
    struct Y{}; 
}; 

现在，这个例子显然不会编译，与错误的第二X<I>::Y已被定义或有太多的模板参数。
我想解决没有（额外）部分专业化，因为int I参数不是唯一的，它的位置可以在不同的部分专业化不同（我的实际结构看起来more like this，以上只是为了简单的问题），所以我想one class fits every I解决方案。

---

我的第一个想法是明显enable_if，但似乎无法在我身上，例如。我仍然得到同样的错误：

// assuming C++11 support, else use boost 
#include <type_traits> 

template<int I> 
class X{ 
    template<class T1, class = std::enable_if<I==1>::type> 
    struct Y{}; 

    template<class T1, class T2, class = std::enable_if<I==2>::type> 
    struct Y{}; 
}; 

---

所以，既然enable_if失败了，我希望有另一种方式来实现以下编译时检查：

template<int I> 
class X{ 
    __include_if(I == 1){ 
    template<class T1> 
    struct Y{}; 
    } 

    __include_if(I == 2){ 
    template<class T1, class T2> 
    struct Y{}; 
    } 
}; 

---

它只是是为了节省我很多的代码重复，但如果它在某种程度上可能，我会非常高兴。
编辑：可惜的是，我不能使用显而易见的：variadic模板，因为我使用的是Visual Studio 2010，所以只能使用支持的C++ 0x东西。 ：/

Answer 1

有两个问题在这里：

1. enable_if作品与部分专业化，不是主要的模板。
2. 外部可见参数的数量由主模板确定，其中可能只有一个。

答案1.

正如你在聊天建议，模板链表可以模拟一个可变参数包。

template<int I> 
class X{ 
    template<class list, class = void> 
    struct Y; 

    template<class list> 
    struct Y< list, typename std::enable_if<I==1>::type > { 
     typedef typename list::type t1; 
    }; 

    template<class list> 
    struct Y< list, typename std::enable_if<I==2>::type > { 
     typedef typename list::type t1; 
     typedef typename list::next::type t2; 
    }; 
}; 

如果你结束了next::next::next垃圾，很容易写一元函数，或者使用升压MPL。

---

回答2.

不同，元数的模板可以类似地命名，但仍停留不同，如果他们被嵌套在SFINAE控制型内。

template<int I> 
class X{ 
    template<typename = void, typename = void> 
    struct Z; 

    template<typename v> 
    struct Z< v, typename std::enable_if<I==1>::type > { 
     template<class T1> 
     struct Y{}; 
    }; 

    template<typename v> 
    struct Z< v, typename std::enable_if<I==2>::type > { 
     template<class T1, class T2> 
     struct Y{}; 
    }; 
}; 

X<1>::Z<>::Y<int> a; 
X<2>::Z<>::Y< char, double > b; 

Answer 2

这种方法怎么样 - http://sergey-miryanov.blogspot.com/2009/03/template-class-overriding.html？ （对不起，俄语）

Answer 3

你能试试以下（这是不偏特）：

template<int I> 
class X 
{ 
}; 

template<> 
class X<1> 
{ 
    template<class T1> 
    struct Y{}; 
}; 

template<> 
class X<2> 
{ 
    template<class T1, class T2> 
    struct Y{}; 
}; 

我如果答案是简单的怀疑！

编辑（模拟部分专业化）： @Xeo，我能够编译下面的代码，似乎是fullfilling。

template<int I> 
struct X 
{ 
    struct Unused {}; // this mocking structure will never be used 

    template<class T1, class T2 = Unused> // if 2 params passed-->ok; else default='Unused' 
    struct Y{}; 

    template<class T1> 
    struct Y<T1, Unused>{}; // This is specialization of above, define it your way 
}; 

int main() 
{ 
    X<1>::Y<int> o1; // Y<T1 = int, T2 = Unused> called 
    X<2>::Y<int, float> o2; // Y<T1 = int, T2 = float> called 
} 

在这里，但是你可以< 1>，X < 2>交替使用X。但在你提到的更广泛的例子中，这是无关紧要的。如果你需要，你可以把支票I = 1和I = 2。

Answer 4

在这里你去：

http://ideone.com/AdEfl

，代码：

#include <iostream> 

template <int I> 
struct Traits 
{ 
    struct inner{}; 
}; 

template <> 
struct Traits<1> 
{ 
    struct inner{ 
    template<class T1> 
    struct impl{ 
     impl() { std::cout << "impl<T1>" << std::endl; } 
    }; 
    }; 
}; 

template <> 
struct Traits<2> 
{ 
    struct inner{ 
    template<class T1, class T2> 
    struct impl{ 
     impl() { std::cout << "impl<T1, T2>" << std::endl; } 
    }; 
    }; 
}; 

template<class T> 
struct Test{}; 

template<class T, class K> 
struct Foo{}; 

template<int I> 
struct arg{}; 

template< 
    template<class, class> class T, 
    class P1, int I 
> 
struct Test< T<P1, arg<I> > >{ 
    typedef typename Traits<I>::inner inner;  
}; 

template< 
    template<class, class> class T, 
    class P2, int I 
> 
struct Test< T<arg<I>, P2 > >{ 
    typedef typename Traits<I>::inner inner;  
}; 

// and a bunch of other partial specializations 

int main(){ 

    typename Test<Foo<int, arg<1> > >::inner::impl<int> b; 
    typename Test<Foo<int, arg<2> > >::inner::impl<int, double> c; 
} 

说明：基本上它是一个局部的专业化理念的延伸，不过不同的是，而不是专业内Test，委托给一个特定的类，可以专门在I单独。这样，您只需要为每个I一次定义inner的版本。然后Test的多个专业化可以重复使用。 inner持有人用于使Test类中的typedef更易于处理。

编辑：这是显示，如果你在错误的多项模板参数传递会发生什么测试用例：http://ideone.com/QzgNP

Answer 5

您可以使用元函数（这里：内联boost::mpl::if_c，但可以是任意复杂的）到选择你想要的。你需要一些脚手架能够使用构造函数，虽然：

template <int I> 
class X { 
    template <typename T1> 
    class YforIeq1 { /* meat of the class */ }; 
    template <typename T1, typename T2> 
    class YforIeq2 { /* meat of the class */ }; 
public: 
    template <typename T1, typename T2=boost::none_t/*e.g.*/> 
    struct Y : boost::mpl::if_c<I==1,YforIeq1<T1>,YforIeq2<T1,T2> >::type { 
     typedef typename mpl::if_c<I==1,YforIeq1<T1>,YforIeq2<T1,T2> >::type YBase; 
     /* ctor forwarding: C++0x */ 
     using YBase::YBase; 
     /* ctor forwarding: C++03 (runs into perfect fwd'ing problem)*/ 
     Y() : YBase() {} 
     template <typename A1> 
     Y(const A1&a1) : YBase(a1) {} 
     template <typename A1, typename A2> 
     Y(const A1&a1, const A2&a2) : YBase(a1,a2) {} 
     // ... 
    }; 
}; 

如果有既YforIeqň问题被实例化每一个X，那么你可以沿着尝试包裹他们作为一个无参元函数（东西mpl::apply的方式）和使用mpl::eval_if_c。