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

| 考虑下面的类，其中内部结构“ 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{};
  }
};

这只是为我节省了很多代码重复，但是如果可以的话，我会很高兴。编辑：可悲的是，我无法使用明显的参数：可变参数模板，因为我正在使用Visual Studio 2010，因此只能使用在那里支持的C ++ 0x东西。：/

已邀请:

5 个回复

郡豪靠暖

这里有两个问题： “ 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;
  };
};

如果最终遇到“ 11”垃圾，则可以很容易地编写元函数或使用Boost 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;

僻朵庙惩竣

干得好： 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

渐首洽陈染

您可以在下面尝试（它不是部分专业化）：

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，我能够编译以下代码，并且看起来很完整。

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
}

但是，您可以在此处互换使用X <1>和X <2>。但是在您提到的更广泛的示例中，这是无关紧要的。仍然，如果需要，您可以支票I = 1和I = 2。

壤欠攻混

如何使用这种方法-http://sergey-miryanov.blogspot.com/2009/03/template-class-overriding.html？（对不起俄语）

蜂佬渺

您可以使用一个meta函数（在这里：内联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) {}
        // ...
    };
};

如果每个X都实例化两个YforIeqN都存在问题，则可以尝试将它们包装为一个元元函数（类似于mpl::apply那样）并使用mpl::eval_if_c。

要回复问题请先登录或注册

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

5 个回复

发起人

c++

templates

compile_time

conditional_compilation

问题状态

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

与内容相关的链接

5 个回复

发起人

c++

templates

compile_time

conditional_compilation

问题状态