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

Question

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

c++templatesconditional-compilationcompile-time

26

考虑以下类，其中内部结构体 Y 作为类型被使用，例如在后续的模板中:

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

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

显然，这个例子无法编译，会报错第二个X<I>::Y已经被定义或模板参数过多。
我希望能够解决这个问题而不需要使用（额外的）部分特化，因为int I参数并不是唯一的，在不同的部分特化中它的位置可能会有所不同（我的实际结构看起来更像这样，上面只是为了简化问题），所以我想要一个适用于每个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东西。 :/

- Xeo

+1。有趣的问题。下班后会尝试回答它 :D - Nawaz

@Xeo：你可以使用C++0x的特性吗？ - Nawaz

@Xeo：抱歉，这似乎很傻，但是可变参数模板怎么办？您可以只使用 static_assert 来检查包的大小。 - Matthieu M.

@Matthieu：不是傻问题，抱歉我没有提供那个信息：由于我正在使用Visual Studio 2010，所以无法使用C++0x的可变参数模板。 :/ 我真的希望VC11能尽快推出，因为这些可变参数模板对于像这样的东西和传递密钥惯用语来说非常棒。 - Xeo

你正在陷入许多新用户都会犯的错误，即询问解决方案而非问题本身。你试图解决什么问题？这个类应该如何使用：提供几个使用案例，说明为什么需要使用内部类型（你考虑过类型特征吗？）。这将使得讨论潜在不同方法更加简单明了。 - David Rodríguez - dribeas

显示剩余5条评论

5个回答

3

这里是您需要的内容：

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

- Nim

我已经发布了相同的简化代码，但提问者说模板不会像 template<int I> 一样简单。 - iammilind

@iammilind，我说它是一个扩展，代码略有不同。在上面的例子中，I 的专门化被委派给 Traits 类，并且 Test 类使用了它。在你的答案中，你提到要为每个 I 专门化 Test（或 X），但是 OP 不愿意这样做。 - Nim

你是正确的。对不起，我错过了那个。谢谢指出。 - iammilind

1

你可以尝试以下代码（这不是部分特化）：

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 进行检查。

- iammilind

这就是我所说的“没有（额外）部分特化”的意思，因为int I不是唯一的模板参数，还有其他参数。我在Ideone上链接了一个小例子，展示了它真正的样子，结构体被简化以便于问题的阐述。 - Xeo

你能检查一下编辑后的版本吗？实际上，我将第二个模板版本作为主版本，并将第一个版本作为第二个版本的专业化版本。希望这有所帮助！ - iammilind

0

您可以使用元函数（这里是内联的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。

- Marc Mutz - mmutz

0

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

- Sergey Miryanov

很遗憾，这并不适用，因为内部模板结构应该作为一种类型在模板中使用。:/ - Xeo

顺便说一下，这是谷歌翻译的网站，它可以很好地传达意图。 - Xeo

重新考虑，也许这可以通过一些decltype技巧来实现。一回家就尝试一下。 :) - Xeo

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Potatoswatter · Accepted Answer

这里有两个问题：

enable_if 仅适用于部分特化，而不是主模板。
外部可见参数的数量由主模板决定，其中可能只有一个。

答案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这样的垃圾值，可以很容易地编写元函数或使用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;