Wo werden Templates sinnvoll
angewendet?
Wie kann man Template-
Implementierungen, ähnlich wie normale Klassen, ausserhalb ihrer Definition schreiben?
Antwort: Outline-Notation
erweitern, d.h. Keyword template
mit Template-Parametern
template <class StackItemType>
void stack<StackItemType>::push(StackItemType &item, bool& opOK) {
...
}
auch inline:
template <class StackItemType>
inline stack<StackItemType>::stack() {
SP = NULL;
}
Fact: templates werden in der Regel durch Hilfsklassen
aufgebaut (siehe unten) Es gibt 3 Arten friend -
Erklärungen in template s
friend
void nuetzlich(){...} //global class hilfsKlasse{
public:
void nuetzlich(); //Methode ...
};
template <class T>
class stack{
private:
friend class stackNase;
friend void nuetzlich();
friend void hilfsKlasse::nuetzlich();
...
Compiler muss die
Klassendefinition von
hilfsKlasse verarbeiten, bevor Klasse stack die friend -
Methoden von hilfsKlasse verwenden kann
Bei den anderen: wie bisher
template friend template
template <class T>
class hilfsKlasse { private:
void nuetzlich();
...
};
template <class T>
class stack{
private:
friend class anyKlasse<T>; //merke T!
friend class hilfsKlasse<T>::nuetzlich();
...
};
Klasse hilfsKlasse oder
zumindest eine Erklärung davon muss hier Klasse stack im
Programmtext vorausgehen
Auch Klasse anyKlasse , da sie
auch template ist.
template template
template <class Type>
class stack{
private:
template <class T>
friend class anyKlasse;
template <class T>
friend void hilfsKlasse<T>::nuetzlich();
...
};
Die template -Klasse anyKlasse und die Methodenfunktion
nuetzlich() sind friend s von stack für alle template -
Parameter!!
Diese Art friend -schaft nicht
überall verfügbar
template -Klasse stack wird mittels einer Hilfsklasse
stackKnoten definiert Diese Hilfsklasse ist eine
template -Klasse gleichen Typs.
Damit interne Felder von
stackKnoten zugegriffen werden
können, muss stack ein friend
von stackKnoten sein
! "
stackKnoten
template <class T>
class stackKnoten{
public:
stackKnoten (const T&):
stackKnoten();
T getData();
friend class stack<T>;
private:
T data;
stackKnoten<T> *naechster;
};
! stack template
template <class Type>
class stack{
public:
stack();
stack (const Type&);
~stack();
Type pop(bool &);
void push(const Type&, bool&);
...
private:
stackKnoten<Type> *SP;
};
# $ %
& %
Die Hilfsklasse stackKnoten ist überall verwendbar
Lösung: Alle Konstruktoren von
stackKnoten private machen
Andere Möglichkeit: Die Hilfsklasse
in Klasse stack verschachteln.
stack ' ( ' ' $
template <class Type>
class stack{
private:
class stackKnoten{
public:
stackKnoten(const Type&);
void setData(const Type&);
Type getData();
Type data; //jawohl, public in private!!
stackKnoten<Type> *Naechster;
};
