C++ Wie gehe ich mit eine Klasse um der von eine Template Oberklasse erbt?

[Zeboo]

Hallo.

Nehmen wir mal an, es gibt eine Oberklasse der mit Templates umgeht. Im Grunde ist es auch egal was diese Klasse macht, geht nur darum, dass dort Templates sind.

Ich erbe jetzt von diese Klasse. Dann baue ich noch eine Funktion ein "machwas" und gut ist. Das müsste dann doch so aussehen oder? Zumindest die .h Datei:

template <typename T>
class Unterklasse : public Oberklasse<T> {
public:
        Unterklasse() {}; //konstruktor
	virtual ~Unterklasse() {}; //destruktor

	void machwas();
        void machnochetwas();
};

Dann habe ich noch natürlich noch .cpp Datei, das sieht dann etwas so aus:

#include "Unterklasse.h"

void Unterklasse<T>::machwas() {
//...
}

void Unterklasse<T>::machnochetwas() {
//...
}

Jetzt kommt die Meckerei in der .cpp Datei:

Description Resource Path Location Type
‘template<class T> class Unterklasse’ used without template parameters

Okey dann versuche ich es mal mit:

#include "Unterklasse.h"

template<typename T>
void Unterklasse<T>::machwas() {
//...
}

template<typename T>
void Unterklasse<T>::machnochetwas() {
//...
}

So ist ruhe. Aber ich muss über alle Funktionen "template<typename T>" schreiben, sonst geht es nicht. Ich glaube ich mache etwas gewaltig falsch oder? Ist der Fehler schon sogar in der .h Datei? Macht man das so nicht?

Danke und Gruß

 

[akra]

hmm müsstest nichts falsch machen, ich meine alle Funktionen einer klasse die du dann definierst auch template Funktionen sein müssen,also passt

 

[toeffi]

---Sorry, hab gerade gemerkt da sich mich bei deiner Definition verlesen habe. ----

Aber du hast es richtig erkannt, du brauchst über jeder Funktionsdefinition das template<typename T> Zeug.

 

[Zeboo]

Hallo, dann mache ich doch alles halbwegs richtig. Gut hier habe ich etwas womit ich dann doch nicht klarkomme:
Was mache ich wenn in der Oberklasse sowas wie das hier steht:

template <typename T,
    template <typename> class irgendwas = i,
    template <typename> class irgendwas2 = i2,
    template <typename> class irgendwas3 = i3>

Wie müsste jetzt meine Unterklasse aussehen ? Eigentlich kann ich alles so lassen wie das ist mit nur einem <T> aber dann habe ich ja nicht alles. Und wenn ich i,i2,i3 hinschreibe geht das nicht...
Erbt man von class Templates anders wie bei normalen? Was muss ich wissen?

Ich meine wenn ich schon das Versuche, geht das nicht.
template <typename T,
    template <typename> class irgendwas = i,
    template <typename> class irgendwas2 = i2, //fehler
    template <typename> class irgendwas3 = i3> //fehler
class Unterklasse ...
}

Da steht dann für beide Zeilen:

invalid default argument for a template template parameter

 

[akra]

template <typename T, 
    template <typename> class irgendwas = i, 
    template <typename> class irgendwas2 = i2, //fehler 
    template <typename> class irgendwas3 = i3> //fehler 
class Unterklasse ... 
}

ich bin mir unsicher aber ich glaube das geht garnicht so wie dus geschrieben hast, das muss sicher anders heißen, ob du dort überhaupt was zuweisen darfst->skeptisch?

template <class T, class XY, class YZ>
class iwas {
...
};

hoffe ich meine das richtige wie du

 

[7H3 N4C3R]

Was sind denn i, i2, i3 für Typen? Erwartet werden offensichtlich Template-Template-Typen. Bin mir aber nicht sicher, ob die Syntax überhaupt stimmt, benutze Template-Templates-Args so selten.

 

[Stefan_Sch]

Jetzt kommt die Meckerei in der .cpp Datei:


Okey dann versuche ich es mal mit:

#include "Unterklasse.h"

template<typename T>
void Unterklasse<T>::machwas() {
//...
}

template<typename T>
void Unterklasse<T>::machnochetwas() {
//...
}

So ist ruhe. Aber ich muss über alle Funktionen "template<typename T>" schreiben, sonst geht es nicht.

Das ist auch richtig. Die Implementierung der Member muss explizit als Template deklariert sein.

Ich meine wenn ich schon das Versuche, geht das nicht.
template <typename T,
    template <typename> class irgendwas = i,
    template <typename> class irgendwas2 = i2, //fehler
    template <typename> class irgendwas3 = i3> //fehler
class Unterklasse ...
}

Die Deklaration der Template-Klasse ist formal in Ordnung. Allerdings werden die meisten Compiler bei dieser Form von Template Template Parametern aussteigen. Der Visual Studio C++ Compiler kommt nicht einmal mit einstufigen Template Template Parametern, wie

template <typename T, template <typename> class CONTAINER = std::deque>
class Stack {
  private:
    CONTAINER<T> elements;

zurecht, sobald der Aufruf über den realen ass. Container stattfindet.