Ich habe 3 Klassen.

Klasse 1 ist eine übliche Klasse
Klasse 2 ist eine Template-Klasse
Klasse 3 ist eine abgeleitete Klasse aus Klasse 1 und Klasse 2.

Das sind meine 3 Header-Dateien

// --------
// class1.h

class Klasse1
{
  private:
    int iKlasse1;

  public:
    Klasse1(int i1);
};

// --------
// class2.h

template <class T>
class Klasse2
{
  private:
    T * pKlasse;

  public:
    Klasse2();
};

// --------
// class3.h

#include "class1.h"
#include "class2.h"

class Klasse3 : public Klasse 1, public Klasse2<Klasse3>
{
  private:
    int iKlasse3;

  public:
    Klasse3(int i1, int i3);
};

Und das sind meine dazugehörigen Source-Dateien

// ----------
// class1.cpp

#include "class1.h"

Klasse1::Klasse1(in i1)
{
  iKlasse1 = i1;
}

// ----------
// class2.cpp

#include "class2.h"

template <class T>
Klasse2<T>::Klasse2()
{
  pKlasse = NULL;
}

// ----------
// class3.cpp

#include "class3.h"

// ACHTUNG hier ist mein Problem:
Klasse3::Klasse3(int i1, int i3) : Klasse1(i1), Klasse2()
{
  iKlasse3 = i3;
}

Mein Problem: Wie kann ich den Konstruktor der Klasse 2 aufrufen?
Das ist ja meine Template-Klasse also vermute ich mal irgendwie sowas:

Klasse3::Klasse3(...) : Klasse1(...), Klasse2<Klasse3>()

oder wenigstens so ähnlich...

Aber wie ich es auch mache, ist es falsch.
Hab schon alles mögliche gegoogelt aber sowas ähnliches hab ich da noch nicht gefunden...

Hat jemand eine Lösung?

ungefähr so?

Klasse3::Klasse3(int i1, int i3) : Klasse1(i1)

Das wird nicht so funktionieren wie du dir das vorstellst.
Ich wette du bekommst dann linker error

Daher solltest du diesen C'tor in deinem Header implementieren.

BR
Vinzenz

Daher solltest du diesen C'tor in deinem Header implementieren.

wie meinst du das? was soll in den header?

find das aber recht unschön Sowas gehört doch eigentlich in eine cpp rein oda?
naja egal es geht!

danke euch

find das aber recht unschön Sowas gehört doch eigentlich in eine cpp rein oda?

Bei "normalen" Funktionen schon. Templates haben aber einen Sonderstatus, was die Linkage betrifft. Dazu steht auch etwas in den FAQ.

Um die Unschönheit abzuschwächen und die Trennung Schnittstelle - Implementierung aufrechtzuerhalten, kann man immer noch einen Header mit den Definitionen der Funktionstemplates anlegen, beispielsweise mit Endung .impl, .ipp, .inl oder einfach .h respektive .hpp.

Kopfschmerzen schrieb:

find das aber recht unschön Sowas gehört doch eigentlich in eine cpp rein oda?

Bei "normalen" Funktionen schon. Templates haben aber einen Sonderstatus, ...

Oder wie ich es mir immer merke: "Template" = "Schablone (aus der der Compiler erst eine Funktion bastelt)".
Damit ist's irgendwie klar, dass man diese Schablone dem Compiler auch an die Hand geben muss... Der Linker braucht die Information, dass die Funktion aus einem Template stammt eigentlich nur noch, um sich über "Doppeldefinitionen" nicht mehr so aufzuregen...

Gruß,

Simon2.

P.S.: Gibt es eigentlich Compiler/Linker, die bei den "Doppeldefinitionen" von Templateinstanzen die Konsistenz der Implementierung gewährleisten?

P.S.: Gibt es eigentlich Compiler/Linker, die bei den "Doppeldefinitionen" von Templateinstanzen die Konsistenz der Implementierung gewährleisten?

Templateklassen sind meistens mehrmals definiert und müssen daher immer gleich sein. Die ODR ist auch hier gültig. (Allerdings als ein Sonderfall 3.2/5).