Условное включение / исключение кода во время компиляции на основе аргументов шаблона? - PullRequest
Новая
       14

Условное включение / исключение кода во время компиляции на основе аргументов шаблона?

26 голосов
/ 14 апреля 2011

Рассмотрим следующий класс с внутренней структурой Y, используемой в качестве типа, например. в шаблонах, позже: 

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 ]

8 голосов
/ 09 июня 2011

Здесь есть две проблемы:

  1. enable_if работает с частичной специализацией, а не с первичными шаблонами.
  2. Количество видимых извне аргументов определяется первичным шаблоном, из которых может быть только один.

Ответ 1.

Как вы предлагали в чате, связанный список шаблонов может эмулировать пакет параметров variadic. 

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;
3 голосов
/ 14 апреля 2011

Вот, пожалуйста:

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. Таким образом, вам нужно только определить версии inner для каждого I один раз . Тогда несколько специализаций Test можно использовать повторно. Держатель inner используется для облегчения обращения с typedef в классе Test.

РЕДАКТИРОВАТЬ: вот тестовый пример, который показывает, что произойдет, если вы передадите неверное количество аргументов шаблона: http://ideone.com/QzgNP

1 голос
/ 14 апреля 2011

Можете ли вы попробовать ниже (это не частичная специализация): 

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.

0 голосов
/ 18 апреля 2011

Вы можете использовать мета-функцию (здесь: встроенная 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 N для каждого X, тогда вы можете попробовать обернуть их как нулевую мета-функцию (что-то вроде того, что делает mpl::apply) и использовать mpl::eval_if_c.

0 голосов
/ 14 апреля 2011

Как насчет этого подхода - http://sergey -miryanov.blogspot.com / 2009/03 / template-class-overriding.html ?(простите за русский)

...