如何解决基于模板参数的条件编译时包含/排除代码？
| 考虑下面的类，其中内部结构“ 0”用作类型，例如。在模板中，稍后：template<int I>
class X{
template<class T1>
struct Y{};
template<class T1,class T2>
struct Y{};
};
X<I>::Y
int I
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{};
}
};
解决方法
这里有两个问题：
“ 5”仅适用于部分专业化，而不适用于主要模板。
外部可见参数的数量由主模板决定，其中主模板可能只有一个。
答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;
};
};
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;
#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 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
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{};
};
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
}
I = 1
I = 2
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,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
mpl::apply
mpl::eval_if_c
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。