template <class T>
class klasse
{
public:
   klasse();
};

die implementierung des konstruktors in der *.cpp sieht folgendermaßen aus

template <class T>
klasse<T>::klasse() {}

wenn der konstruktor nun aufgerufen wird

klasse<int> objekt_;

bekomme ich ein linkererror:
Verweis auf nicht aufgelöstes externes Symbol ""public: __thiscall klasse<int>::klasse<int>(void)" ...

ich verwende msvcpp express

wie kommt es zu diesem fehler?
wäre schön, wenn mir einer von euch helfen könnte.

header-datei(deklaration der klasse):

class klasse
{
public:
   klasse();
};

cpp-datei(implementation des konstruktors):

klasse::klasse() {}

anwendung:

klasse objekt_;

ausserdem tritt der fehler nicht auf, wenn ich den konstruktor innerhalb der klasse und nicht in der cpp-datei implementiere

Templates werden in der Headerdatei sowohl Deklariert als auch Definiert. Wenn du also deine Definition zu deiner Deklaration (in die .h Datei) packst klappts auch.

grüße

um die definition in die *.cpp packen zu können, brauchst du das schlüsselwort export. Da dies aber nur ein einziger compiler überhaupt beherrscht, ist dies auch nur eine theoretische Lösung

Und warum funktioniert das mit VC++ 8.0

// templ.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
#include "stdafx.h"

template <class T> 
class klasse 
{ 
public: 
   klasse(); 
}; 

template <class T> 
klasse<T>::klasse() {}  

int main()
{
	klasse<int> objekt_; 

   return 0;
}

Weil bei dir Definition und Deklaration immer noch in der selben Datei sind. Du glaubst nicht ernsthaft, dass das was mit der Dateiendung zu tuen hat... Oder?

Jetzt steht die Deklaration in tem.h und es funktioniert immer noch bestens.

// t2.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//
#include "stdafx.h"
#include "tem.h"

template <class T> 
klasse<T>::klasse() {}  

int main()
{
	klasse<int> objekt_; 
   return 0;
}

...
Jetzt steht die Deklaration in tem.h und es funktioniert immer noch bestens.

// t2.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//
#include "stdafx.h"
#include "tem.h"

template <class T> 
klasse<T>::klasse() {}  

int main()
{
	klasse<int> objekt_; 
   return 0;
}

Stimmt natürlich !
Eigentlich muß nämlich nicht Deklaration&-finition zusammen in einem File sein, sondern die Definition muß zur (template-)Instatiierungszeit (also beim Compile) vom Compiler zu finden sein.

Alternativ würde im ersten Beispiel auch ein

#include "tem.cpp"

funktionieren.

Allerdings hat David_pb auch "ein wenig Recht": Es ist oft hilfreich, Definition und Deklaration zusammenzulegen, weil man sonst bei der Verwaltung in Schwierigkeiten/Probleme/Herausforderungen laufen kann.

Gruß,

Simon2.

(Hint: Das funktioniert generell so, nicht nur mit VC++ 8.0, und #include ist eine reine Textersetzung)

Denk über die folgenden Worte nochmal nach:
Definition und Deklaration müssen in derselben Compileeinheit sichtbar sein. ...

DAS ist das wesentliche Verb. David hatte das weggelassen, was die Aussage schwammiger und mißverständlicher machte (wobei immer noch nicht ganz eindeutig ist, was "sichtbar" bedeutet ... vA ob man die (theoretische) Möglichkeit mit export auch unter diesen Grundsatz fallen lassen möchte oder nicht).
Aber es ist auf jeden Fall ein prima Merksatz.

Gerie schrieb:

Die Frage war:Warum funktioniert das mit VC++ 8.0 ?

Weil das mit jedem halbwegs standardkonformen Compiler funktioniert !

Gruß,

Simon2.

Irr ich mich, oder hat die anzahl der korinthenkacker drastisch zugenommen?

Wenn Dir der Unterschied zwischen "falsch" und "richtig" (bzw. "tut" und "tut nicht) zu "korintig" ist, musst Du natürlich seeeeehr viele Optionen bei Deinem Compiler bemühen. Aber wenn Du gut damit fährst: Bleib dabei !
Dann würdest Du Gerie aber vielleicht mehr helfen, wenn Du ihm seine Frage "unkorintig" beantwortes...
Gruß,

Simon2.

otze schrieb:

Irr ich mich, oder hat die anzahl der korinthenkacker drastisch zugenommen?

Wenn Dir der Unterschied zwischen "falsch" und "richtig" (bzw. "tut" und "tut nicht) zu "korintig" ist, musst Du natürlich seeeeehr viele Optionen bei Deinem Compiler bemühen. Aber wenn Du gut damit fährst: Bleib dabei !
Dann würdest Du Gerie aber vielleicht mehr helfen, wenn Du ihm seine Frage "unkorintig" beantwortes...
Gruß,

Simon2.

man, da fühlt sich aber der falsche angepisst ich meinte eher den unreg mit seinen arg konstruierten beispielen fällt mir im moment nur sehr auf, dass es solche dinge inzwischen fast überall gibt.

Es wird eine aussage(faustregel) gemacht, an die sich eigentlich jeder "normale" mensch halten kann, ohne jemals schlecht zu fahren, und dann wird diese aussage durch bestimmte leute mithilfe fast nie auftretender fälle auseinandergenommen. und das ist korintenkackerei.

Simon2 schrieb:

otze schrieb:

Irr ich mich, oder hat die anzahl der korinthenkacker drastisch zugenommen?

Wenn Dir der Unterschied zwischen "falsch" und "richtig" (bzw. "tut" und "tut nicht) zu "korintig" ist, musst Du natürlich seeeeehr viele Optionen bei Deinem Compiler bemühen. Aber wenn Du gut damit fährst: Bleib dabei !
Dann würdest Du Gerie aber vielleicht mehr helfen, wenn Du ihm seine Frage "unkorintig" beantwortes...
Gruß,

Simon2.

man, da fühlt sich aber der falsche angepisst

Na, da bin ich ja mal beruhigt .... ich hatte in diesem Thread halt keine K-kackerei ausmachen können .... nur die (IMHO sehr gute) Spezialisierung der Faustregel, denn

otze schrieb:

...Es wird eine aussage(faustregel) gemacht, an die sich eigentlich jeder "normale" mensch halten kann, ohne jemals schlecht zu fahren,...

Ich liebe es auch, wenn man nützliche Faustregeln hat. Mag sein, dass es Programmierer gibt, die sowas nicht brauchen, sondern einfach den Standard byteweise auswendig lernen (und auch anwenden können und noch einen brauchbaren PG-Stil entwickeln), aber mir helfen Faustregeln jedenfalls ordentlich weiter.

Gruß,

Simon2.