Klasse in Template

PoRcUpInE

Hi,

Beim Compilieren, folgenden Codes wirft der Compiler (gcc-3.3.4) mir eine Warnung aus und ich hab keine Ahnung, auf was die zurückzuführen ist.

template<class T>
class x
{
public:
  class z
  {
  public:
    T a;
  };

  z get_z();
};

template<class T>
x<T>::z x<T>::get_z()
{
  return z();
}

int main()
{
  return 0;
}

Die Warnung ist:

test.cpp:16: Warnung: `x<T>::z' is implicitly a typename
test.cpp:16: Warnung: implicit typename is deprecated, please see the
documentation for details

virtuell Realisticer

Hallo,

template<class T>
x<T>::z x<T>::get_z()
{
  return z();
}

das musst du so schreiben:

template<class T>
typename x<T>::z x<T>::get_z()
{
  return z();
}

mfg
v R

HumeSikkins

Hallo,
dein Compiler weißt dich darauf hin, dass x<T>::z innerhalb eines Templates ein abhängiger Name ist. Die Bedeutung von z ist nämlich abhängig vom konkreten T.
Beispiel:

template <class T>
struct X
{
typedef int z;
};

template <>
struct X<int>
{
    typedef double z;
};

template <class T>
struct X<T*>
{ 
    T* z;
};

Wie du siehst ist die Bedeutung von z hier abhängig vom Template-Parameter T. Ist T = int, so ist z ein typedef auf double. Ist T hingegen ein Pointer, so ist z eine Instanzvariable vom Typ T-Pointer. Im allgemeinen Fall wiederum ist z ein typedef auf int.

Der Compiler prüft Gültigkeit von Templates in zwei Phasen prüft. Einmal vor der Substitution der Templateparameter und einmal danach.
Innerhalb eines Templates kann er nun in der ersten Phase aber nicht wissen, was X<T>::z im folgenden Code bedeutet:

template<class T>
x<T>::z x<T>::get_z()
{
  return z();
}

Ist das ein Typ oder vielleicht doch eine Instanzvariable?

Der Standard legt fest, dass der Compiler sich im Zweifelsfalls immer für Nicht-Typ (in diesem Fall also Instanzvariable) entscheiden soll.

Durch eine Qualifikation eines abhängigen Namens mit "typename" kannst du die Default-Entscheidung von "Nicht-Typ" auf Typ umstellen:

template<class T>
typename x<T>::z x<T>::get_z()
{
  return z();
}

Nun weiß der Compiler, dass es sich bei x<T>::z tatsächlich um einen Typ handelt.