Abgeleitete Template-Klassen und Konstruktoren

Ich bin mir nicht sicher ob ich mir das Leben nicht viel zu schwer mache:

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?

David_pb

Weil Klasse2 einen Standardkonstruktor hat, musst du garnichts machen. Ansonsten: Klasse2<Klasse3>().

Meinst du mit gernichts machen dass ich den Konstruktoraufruf einfach weglassen soll?

ungefähr so?

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

David_pb

Genau!

evilissimo

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

#include "class2.h"

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

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

evilissimo schrieb:

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

wie meinst du das? was soll in den header?

Braunstein

Die definitionen deiner Template-Klassenmethoden soll mit in den Header. Siehe auch hier (FAQ)
http://www.c-plusplus.net/forum/viewtopic-var-t-is-39467.html

Hey Super
Kaum in den Header verschoben schon gehts völlig reibungslos...

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

danke euch

Nexus

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, 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.

Simon2

Nexus schrieb:

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?

drakon

Simon2 schrieb:

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).