Как мы можем определить или переопределить шаблонный вложенный класс в подклассе?

Question

Рассмотрим следующее:

template <typename T>
class Base {
  public:
    template <typename U>
    class Nested { };
};

template <typename T>
class Derived : public Base<T> {
  public:
    //How do we typedef of redefine Base<T>::Nested?
    using Base<T>::Nested; //This does not work
    using Base<T>::template<typename U> Nested; //Cannot do this either
    typedef typename Base<T>::template<typename U> Nested Nested; //Nope..

    //now we want to use the Nested class here
    template <typename U>
    Class NestedDerived : public Nested { };

    //or like this:
    Nested<int> nestedVar; // obviously does not work
};

Как использовать шаблонный вложенный класс в классе Derived? Возможно ли это сделать в текущей версии стандарта C ++?

Answer 1

На самом деле using работает так, как объявлено, просто не избавляется от проблемы с зависимым именем в шаблоне и не может в настоящий момент напрямую создавать псевдонимы шаблонов (будет исправлено в C ++ 0x ):

template <class T>
struct Base {
    template <class U> struct Nested {};
};

template <class T>
struct Derived : Base<T> {
    using Base<T>::Nested;

    // need to prefix Nested with template because
    // it is a dependent template:
    struct X : Base<T>::template Nested<int> {};

    // same here:
    template<class U>
    struct Y : Base<T>::template Nested<U> {};

    // data member, typename is needed here:
    typename Base<T>::template Nested<int> data;
};

void f() { 
    Derived<int>::Nested<int> n; // works fine outside
}

Существует еще один возможный gotcha при использовании Derived<T>::Nested в шаблонах, но, опять же, это проблема с зависимым именем, не связанная с наследованием:

template<class T>
void g() {
    // Nested is a dependent type and a dependent template, thus
    // we need 'typename' and 'template':
    typedef typename Derived<T>::template Nested<int> NestedInt;
}

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

• с префиксом typename, если это зависимый тип: typename A<T>::B
• напрямую с префиксом template, если это зависимый шаблон: A<T>::template f<int>()
• оба, если оба: typename A<T>::template B<int>
• typename недопустимо в списках базовых классов: template<class T> struct A : B<T>, C<T>::template D<int> {};

Answer 2

Это похоже на работу:
( РЕДАКТИРОВАТЬ: добавил еще несколько строк, чтобы показать первый шаблон шаблона. И спасибо Самиру Талвару за исправление моего форматирования!)

template <typename T, typename U> 
class Derived : public Base<T> { 
  public: 
    typedef typename Base<T>::template Nested<U> Nested;

    class NestedDerived : public Nested { }; 

    Nested nestedVar;
};

Answer 3

Я все еще не на 100% уверен, что вы хотите, но вы можете попробовать.
Это скомпилировано в Visual Studio

template <typename T>
class Base {
  public:
    template <typename U>
    class Nested { };
};

template <typename T>
class Derived : public Base<T> {
  public:
    //now we want to use the Nested class here
    template <typename U>
    class NestedDerived : public Nested<U> { };
};

int _tmain(int argc, _TCHAR* argv[])
{
Base<int>::Nested<double> blah2;
Derived<int>::NestedDerived<int> blah;

return 0;
}

Answer 4

Попробуйте это:

template <typename T>
class Base {
  public:
    template <typename U>
    class Nested { };
};

template <typename T>
class Derived : public Base<T> {
  public:
    //How do we typedef of redefine Base<T>::Nested?
    //using Base<T>::Nested; //This does not work
  //using Base<T>::template<typename U> Nested; //Cannot do this either
  //typedef typename Base<T>::template<typename U> Nested Nested; //Nope..

    //now we want to use the Nested class here
  template <typename U>
  class NestedDerived : public Base<T>::template Nested<U> { };
};

int main()
{
  Base<int>::Nested<double> nested;

  Derived<int>::NestedDerived<double> nested_derived;

  return 0;
}

Отлично скомпилировано с использованием gcc 4.3.3 на slackware 13