Hallo,

komme leider überhaupt nicht mit den doofen Templates klar. Habe eine Klasse "VarClass":

Header:

Code :

1 2 3 4 5 6 7 8 9

class VarClass { public:     VarClass();     virtual ~VarClass();       template<typename T>     void printSomething(T a);   };

CPP:

Code :

1 2 3 4 5 6 7 8 9 10 11 12

#include <iostream> #include "VarClass.h" using namespace std;   VarClass::VarClass() {}   VarClass::~VarClass() {}   template<typename T> void VarClass::printSomething(T a){     cout << "my input = " << a <<endl; }

Und jetzt habe ich noch eine Klasse Test, die die main-Funktion enthält:

Code :

1 2 3 4 5 6 7 8 9

#include "VarClass.h"   int main(){     VarClass* t1;     t1 = new VarClass();     t1->printSomething(50);     delete t1;     return 0; }

Die "printSomething" Methode lässt sich aber gar nicht aufrufen. Bekomme beim kompilieren folgenden Fehler in der aufrufenden Zeile:

undefined reference to `void VarClass:rintSomething<int>(int)'

Wo ist der Fehler ? Jetzt ist das Programm schon so klein und ich find ihn trotzdem nicht

Grüßle

Hallo,

die Implementation der Template-Methode muss in den Header:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11

class VarClass { public:     VarClass();     virtual ~VarClass();       template<typename T>     void printSomething(T a)     {          cout << "my input = " << a <<endl;     }  };

Gruß
MCoder

Jaah, danke !
So gehts.
Kannst du mir noch sagen wieso die jetzt explizit in den Header muss ? Nur damit ichs wenigstens verstehe, dann merkt man sich das leichter

Liebe Grüße

Hallo,

so genau habe ich das nicht mehr in Erinnerung, aber der Compiler generiert wohl aus dem Ausdruck eine neue Klasse und braucht an der Stelle auch den Zugriff auf die Implementation, die aber nicht erreichbar ist, wenn sie in einer anderen Datei liegt.

Gruß
mbmun

Wenn dich diese Art der Implementierung stört, so kannst du es so aufbauen, dass es der Trennung in *.h(pp) und *.cpp ähnelt. Für große Template-Klassen habe ich mir die Dateiendung tpp angewöhnt, in die ich meine Implementierung packe. Diese neue Datei wird dann einfach am Ende der Header-Datei inkludiert.

Beispiel: Header (test.h)

Code cpp:

1 2 3 4 5 6 7 8 9 10 11

class VarClass { public:     VarClass();     virtual ~VarClass();       template<typename T>     void printSomething(T a);   };   #include "test.tpp"

Implementierung - Templatefunktionen (test.tpp)

Code cpp:

1 2 3 4 5

template<typename T> void VarClass::printSomething(T a) {     cout << "my input = " << a <<endl; }

Implementierung - "Normale" Funktionen (test.cpp)

Code cpp:

1 2 3 4

#include "test.h" VarClass::VarClass() {}   VarClass::~VarClass() {}

Bei einzelenen Funktionen bzw. kleinen Klassen lohnt sich das u.U. nicht, aber bei größerem Code wird es meiner Meinung nach übersichtlicher. Die Header-Datei lässt sich besser lesen (man könnte auch einfach den Inhalt von *.tpp in die *.h direkt reinschreiben, ist halt wieder vom eigenen Stil abhängig).

Danke euch beiden.
Funktioniert beides, wobei ich mich für die *.tpp Lösung entschieden habe da mir die Implementierung im Header nicht soooo gefällt

Liebe Grüße