GCC проблема: использование члена базового класса, который зависит от аргумента шаблона

У Дэвида Джойнера была своя история, вот в чем причина.

Проблема при компиляции B<T> заключается в том, что его базовый класс A<T> неизвестен компилятору, так как он является шаблонным классом, поэтому компилятор не может знать никаких членов из базового класса.

Более ранние версии делали некоторые выводы, фактически анализируя базовый класс шаблона, но ISO C++ заявил, что этот вывод может привести к конфликтам там, где их не должно быть.

Решение для ссылки на элемент базового класса в шаблоне заключается в использовании this (как вы это сделали) или в конкретном имени базового класса:

template <typename T> class A {
public:
    T foo;
};

template <typename T> class B: public A <T> {
public:
    void bar() { cout << A<T>::foo << endl; }
};

Дополнительная информация приведена в руководстве gcc .

Вау. C++ никогда не перестает удивлять меня своей странностью.

В определении шаблона неквалифицированные имена больше не будут находить членов зависимой базы (как указано в [temp.dep]/3 в стандарте C++). Например,

template <typename T> struct B {
  int m;
  int n;
  int f ();
  int g ();
};
int n;
int g ();
template <typename T> struct C : B<T> {
  void h ()
  {
    m = 0; // error
    f ();  // error
    n = 0; // ::n is modified
    g ();  // ::g is called
  }
};

Вы должны сделать имена зависимыми, например, добавив к ним префикс this ->. Вот исправленное определение C::h,

template <typename T> void C<T>::h ()
{
  this->m = 0;
  this->f ();
  this->n = 0
  this->g ();
}

В качестве альтернативного решения (к сожалению, не обратно совместимого с GCC 3.3), вы можете использовать using declarations вместо этого->:

template <typename T> struct C : B<T> {
  using B<T>::m;
  using B<T>::f;
  using B<T>::n;
  using B<T>::g;
  void h ()
  {
    m = 0;
    f ();
    n = 0;
    g ();
  }
};

Это просто какое-то безумие. - Спасибо, Дэвид.

Вот раздел" temp.dep/3 " стандарта [ISO/IEC 14882:2003], на который они ссылаются:

В определении шаблона класса или члена шаблона класса, если базовый класс шаблона класса зависит от параметра шаблона, область действия базового класса не рассматривается во время поиска неполного имени ни в точке определения шаблона класса или члена, ни во время создания экземпляра шаблона класса или члена. [Образец:

typedef double A; 
template<class T> class B { 
    typedef int A; 
}; 
template<class T> struct X : B<T> { 
    A a; // a has typedouble 
}; 

Имя типа A в определении X<T> связывается с именем typedef, определенным в области глобального пространства имен, а не с именем typedef, определенным в базовом классе B<T> . ] [Образец:

struct A { 
    struct B { /* ... */ }; 
    int a; 
    int Y; 
}; 
int a; 
template<class T> struct Y : T { 
    struct B { /* ... */ }; 
    B b; //The B defined in Y 
    void f(int i) { a = i; } // ::a 
    Y* p; // Y<T> 
}; 
Y<A> ya; 

Члены A::B , A::a и A::Y аргумента шаблона A не влияют на привязку имен в Y<A> . ]

Это изменилось в 28-27 годах . Парсер C++ стал гораздо более строгим в этом выпуске - в соответствии со спецификацией, но все еще немного раздражает людей с устаревшими или мультиплатформенными кодовыми базами.

Основная причина, по которой C++ не может ничего предположить здесь, заключается в том, что базовый шаблон может быть специализирован для типа позже. Продолжение исходного примера:

template<>
class A<int> {};

B<int> x; 
x.bar();//this will fail because there is no member foo in A<int>

VC не реализует двухфазный поиск, в то время как GCC делает это. Таким образом, GCC анализирует шаблоны до их создания и таким образом находит больше ошибок, чем VC. В вашем примере foo-это зависимое имя, так как оно зависит от 'T'. Если вы не скажете компилятору, откуда он взялся, он вообще не сможет проверить правильность шаблона, прежде чем вы создадите его экземпляр. Вот почему вы должны сказать компилятору, откуда он берется.