[C++] typdefs von template Parameter nutzen

[karolherbst]

Kann mir hier ein C++ Crack erklären warum folgendes nicht funktioniert?

template <class T>
class Wrapper
{
    T::Type type; // Fehler in etwa: T not derived type from Wrapper<T>
}

Type wird dann einfach per typedef definiert.

Im Grunde möchte ich nur eine Wrapper Klasse schreiben, dessen Membertypen über ein template Parameter gesteuert wird. Aber vielleicht gibt es auch einen anderen eleganten Weg, dieser Problematik zu entkommen.

Ich bin für jeden Ratschlag dankbar.

 

[ImperatoR]

template <class T>
class Wrapper
{
public:
    void foo(T x); // Prototyp

private:
   T varName;
}

// Bei Templates muss auch die Implementierung in der h-Datei sein.

template <class T> // Muss an jede Funktion geschrieben werden
void Wrapper<T>::foo(T x)
{
   // Konkrete Implementierung
}

 

[karolherbst]

das ist mir klar, aber ich gehe ja von einem speziellen Fall aus.

template <class T>
class Wrapper
{
public:
    void foo(T x); // Prototyp

private:
   T varName;
   T::Type typename;
}

Ich weiß ziemlich viel über templates und programmiere auch viel mit denen. Ich frage mich nur, warum genau das hier nicht funktioniert. Der Compiler beschwert sich ja auch schon beim Einbinden der Headerdatei. Und die genaue Fehlermeldung ist folgende: "type ‘T’ is not derived from type ‘Wrapper<T>’"

 

[ImperatoR]

Was willst du denn mit T::Type erreichen?

 

[karolherbst]

ich möchte über einen

class Para{
  public:
    typedef externelLib::Type Type
    typedef externelLib::Type2 Type2
}

- Mechanismus die Klassen der Membervariablen des Templates bestimmten können.

Ausweichmöglichkeit wäre ja, dass man diese Variablen einfach in der Parameterklasse deklariert. Jedoch finde ich diesen Weg nicht schön, da die Programmlogik dann wieder an mehreren Stellen liegt.

Das doofe ist ja, dass ich auch die Variablen dieser Typen in Methoden der Templateklasse deklarieren möchte und das geht ebenfalls nicht.

 

[ImperatoR]

Ich weiß nicht ob das geht (weil ich solche Zaubertricks bisher in C++ zum Glück noch nicht machen musste), aber eventuell hilft dir implicit instantiation.

 

[karolherbst]

stimmt, auf die Idee bin ich noch nicht gekommen, jedoch ist das Problem dann, dass die Spezialisierungen nicht von dem unspezialisiertem erben

zb:

template <class T>
class Test {
    public:
      int a;
};

template <>
class Test<std::string>{
    public:
      int b;
};

int main(){
    Test<std::string> special;
    special.a; // compiler error: ‘class Test<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘a’

}

Das sind dann intern 2 ganz verschiedene Klassen. Ich denke ich werden den Umweg nehmen müssen und das erstellen von Objekten dann dem Parameterklassen überlassen.

 

[ImperatoR]

Funktioniert eventuell etwas in die Richtung?:

template <class T>
class Test {
    public:
      int a;
};

template <class T = std::string>
class Test : public Test<T> {
    public:
      int b;
};

int main(){
    Test<std::string> special;
    special.a;
}

 

[karolherbst]

ne leider nicht, wäre aber auch eine Idee gewesen