Привет All,

Имеем шаблон вида

template <typename T1>
class A {
public:
  template <typename T2>
  class B {};

  template<>
  class B<int> {};
};

Хотя VC6/7 это кушают без проблем, стандарт (14.7.3/18) это дело запрещает :(
Соответственно, gcc код не компилирует. Возможно ли это дело переписать
как-то иначе без частичной специализации? Уж больно не хочется делать
две версии: для vc и gcc...

Happy Coding,
Sergey.

Здравствуйте Qiller, Вы писали:

Q>Привет All,

Q>Имеем шаблон вида
Q>

Q>template <typename T1>
Q>class A {
Q>public:
Q>  template <typename T2>
Q>  class B {};

Q>  template<>
Q>  class B<int> {};
Q>};
Q>

Q>Хотя VC6/7 это кушают без проблем, стандарт (14.7.3/18) это дело запрещает
Q>Соответственно, gcc код не компилирует. Возможно ли это дело переписать
Q>как-то иначе без частичной специализации? Уж больно не хочется делать
Q>две версии: для vc и gcc...

Q>Happy Coding,
Q>Sergey.

У меня нет под рукой gcc, но попробуй написать так:
[ccode]
// это сам шаблон A<T1>::B<T2>
template<class T1, class T2>
class AB
{
public:
int i;
};

// это специализация на int A<T1>::B<int>
template<class T1>
class AB<T1, int>
{
public:
int j;
};

template<class T1>
class A
{
public:
// здесь нужно будет разобраться только с конструкторами
template<class T2>
class B : public AB<T1, T2>
{
};
};

int main()
{
A<int>::B<char> abc;
abc.i = 5;

A<int>::B<int> abi;
abi.j = 5;
}
[\ccode]

Может быть, в твоем случае можно обойтись без вложенного класса. Не очень удобно, но работать должно, о результатах, пожалуйста, сообщи

Здравствуйте dupamid, Вы писали:

Q>>Уж больно не хочется делать две версии: для vc и gcc...

D>попробуй написать так:
[ccode]<...>
D>// это специализация на int A<T1>::B<int>
D>template<class T1>
D>class AB<T1, int>[\ccode]

Это не будет работать уже с vc :-)

Здравствуйте Павел Кузнецов, Вы писали:

ПК>Здравствуйте dupamid, Вы писали:

Q>>>Уж больно не хочется делать две версии: для vc и gcc...

D>>попробуй написать так:
ПК>[ccode]<...>
D>>// это специализация на int A<T1>::B<int>
D>>template<class T1>
D>>class AB<T1, int>[\ccode]

ПК>Это не будет работать уже с vc

К сожалению, да! Но иначе это переписать Стандартным образом невозможно (я в этом почти уверен).

Здравствуйте dupamid, Вы писали:

Q>>>>Уж больно не хочется делать две версии: для vc и gcc...

D>>>попробуй написать так:
<...>

ПК>>Это не будет работать уже с vc

D>К сожалению, да! Но иначе это переписать Стандартным образом невозможно (я в этом почти уверен).

Будешь есть шляпу?

Здравствуйте Qiller, Вы писали:

[сcode]
Q>template <typename T1>
Q>class A {
Q>public:
Q> template <typename T2>
Q> class B {};

Q> template<>
Q> class B<int> {};
Q>};[/сcode]

Q>Возможно ли это дело переписать как-то иначе без частичной специализации? Уж больно не хочется делать две версии: для vc и gcc...

Да, можно использовать симуляцию частичной специализации при помощи traits:

template <typename T2>
struct AB_traits
{
  // общий случай A<T1>::B<T2>
  template <typename T1>
  class AB_base { };
};

template <>
struct AB_traits<int>
{
  // специализация A<T1>::B<int>
  template <typename T1>
  class AB_base { };
};

template <typename T1>
class A {
public:
  template <typename T2>
  class B : public AB_traits<T2>::template AB_base<T1>
  {
    /* как написал dupamid, здесь нужно будет разобраться только с конструкторами */
  };
};

Здравствуйте Павел Кузнецов, Вы писали:

ПК>Здравствуйте dupamid, Вы писали:

Q>>>>>Уж больно не хочется делать две версии: для vc и gcc...

D>>>>попробуй написать так:
ПК><...>

ПК>>>Это не будет работать уже с vc

D>>К сожалению, да! Но иначе это переписать Стандартным образом невозможно (я в этом почти уверен).

ПК>Будешь есть шляпу?

А что есть способ? Ну-ка изложи! Если есть я съем свою шляпу
(слава богу, что я не ношу шляп и шапок!)

Здравствуйте Павел Кузнецов, Вы писали:

sorry

template <typename T2>
struct AB_traits
{
  // общий случай A<T1>::B<T2>
  template <typename T1>
  class AB_base { };
};

template <>
struct AB_traits<int>
{
  // специализация A<T1>::B<int>
  template <typename T1>
  class AB_base { };
};

template <typename T1>
class A {
public:
  template <typename T2>
  class B : public AB_traits<T2>::template AB_base<T1>
  {
    /* как написал dupamid, здесь нужно будет разобраться только с конструкторами */
  };
};

Здравствуйте dupamid, Вы писали:

D>>>иначе это переписать Стандартным образом невозможно (я в этом почти уверен).

ПК>>Будешь есть шляпу?

D>А что есть способ? Ну-ка изложи! Если есть я съем свою шляпу
D>(слава богу, что я не ношу шляп и шапок!)

Считай, повезло см. ответ Qiller'у.

Здравствуйте Павел Кузнецов, Вы писали:

ПК>Здравствуйте Павел Кузнецов, Вы писали:

ПК>sorry

ПК>

ПК>template <typename T2>
ПК>struct AB_traits
ПК>{
ПК>  // общий случай A<T1>::B<T2>
ПК>  template <typename T1>
ПК>  class AB_base { };
ПК>};

ПК>template <>
ПК>struct AB_traits<int>
ПК>{
ПК>  // специализация A<T1>::B<int>
ПК>  template <typename T1>
ПК>  class AB_base { };
ПК>};

ПК>template <typename T1>
ПК>class A {
ПК>public:
ПК>  template <typename T2>
ПК>  class B : public AB_traits<T2>::template AB_base<T1>
ПК>  {
ПК>    /* как написал dupamid, здесь нужно будет разобраться только с конструкторами */
ПК>  };
ПК>};

Уже съел

Здравствуйте Павел Кузнецов, Вы писали:

ПК>Да, можно использовать симуляцию частичной специализации при помощи traits:
ПК>[сcode]
ПК>template <typename T2>
ПК>struct AB_traits
ПК> .... суслики погрызли
ПК>};[/сcode]

О! Спасибо за идею! Буду думать...