template<class T>
class A{

T* A;
T* B;
}
class B : pulbic A{

void berechnung1();
}
class C : pulbic A{

void berechnung2();
}

num möchte ich das die funktionen aus Klasse B und C jeweile mit utnerschiedlichen zahlentypen rechnen (long,int,double), wobei die Zahlen die variablen A,B aus klasse A representieren!!

Ist diese Iplementierung Sinnvoll? Ist sowas überhaupt möglich?

Grüße

template<typename T>
class A
{...};

class B : public A<int>
{...};

Zweitens: Kannst du mal etwas genauer beschreiben, was du beabsichtigst?

class Allokation{

T* Anfangszeit;
T* Endzeit;

}
class AllokationstypA : public Allokation{

}
class AllokationstypB : public Allokation{

}

Die Klasse Allokation reprensiert eine Alloaktion in einer Zeitliste...

wobei es utnrschiedliche Allokationstypen gibts (A,B).. diese Allokationstypen können die varaiblen aus "Allokation" bearbeiten..

ich möchte die möglichkeit gewährleisten, das Allokationen ganzhalig (sekunden) , oder auch (kommastellen) double definiert werden können.

Allokator <sekunden> secAlloc;

template<typename T>
class A
{...};

template<typename T>
class Btemplate : public A<T>
{...};

class Bkonkret : public A<int>
{...};

template<typename T>
class A
{...};

template<typename T> <-- ist die nötig??
class Btemplate : public A<T>
{...};

class Bkonkret : public A<int>
{...};

würden alle Klassen mit dem selben template (typ) arbeiten dann so: ?

template<typename T>
class A
{...};

template<typename T> 
class Btemplate : public A<T>
{...};

template<typename T> 
class Ctemplate : public A<T>
{...};

template<typename T>
class A
{...};

template<typename T> <-- ist die nötig??
class Btemplate : public A<T>
{...};

Ja, ist sie. Wenn du mit template-Klassen arbeiten willst, mußt du sie spezialisieren. Und dieses Konstrukt erzeugt für jeden Datentyp "T" (der irgendwo im Programm benötigt wird) eine Klasse Btemplate<T>, die von der Spezialisierung A<T> des Templates A abgeleitet wird.

template<typename T>

schreibe, und dann meine Basis + Sub klassen mit

<T>

deklariere,

das dann das T in alles klassen gilt...

template<typename T>
class A
{...};

class Sub1 : public A<T>
{...};

class Sub2 : public A<T>
{...};

aber muss woh vor jeder sub klasse das

template<typename T>[/

schreiben!!

(und am Rand bemerkt, du bist nicht einmal darauf beschränkt, den Parameter "T" zu nennen. Der mußt nur innerhalb einer Template-Defintion eindeutig sein)

template<typename T>
class A
{...};

template<typename SubT>
class B : public A<SubT>
{...};

Woher sollte der Compiler im Umfeld von Sub1 auch den Typ "T" kennen? T ist ein Templateparameter des Klassentemplate A und nicht der Klasse Sub1. Ableiten kannst Du nur von anderen Klassen, und A ist keine Klasse (sondern eine Vorlage). A<int> aber schon. A<T> ist erstmal ein syntaktisch ungültiges Konstrukt, solange Du dem Compiler nicht mitteilst was T ist. Und das tust Du im letzteren Fall dadurch dass Du Sub1 widerum zum Template mit T als Template-Parameter machst.