Generische Programmierung (Templates)

Es gibt Abläufe, die sich auch bei verschiedenen Datentypen gleichen. So funktioniert die Bestimmung des Minimums zweier Werte völlig unabhängig vom verwendeten Datentyp immer gleich, sofern eine Kleiner-Relation für den Datentyp existiert. Auch ein Sortierverfahren lässt sich fast unverändert auf jeden Datentyp anwenden. Schließlich ist es auch einem Stack völlig gleichgültig, was für Daten dort verwaltet werden. In den bisher gezeigten Programmen ist der Typ aber mit dem Algorithmus sehr verwoben. Entsprechend müsste das gleiche Verfahren für einen anderen Typ wieder vollständig neu geschrieben werden.

Schablone

Template-Funktionen

Beispiel

[Funktion min() für den Typ long]

long min(long a, long b)
{
    return (a < b) ? a : b;
}

Daraus lässt sich die folgende Template-Funktion erstellen:

[Template-Funktion min()]

template <class T>
T min(T a, T b) 
{
    return (a < b) ? a : b;
}

Funktionsdefinition

typename

Hier steht im Buch die Abbildung "Syntaxgraph für Template-Funktionen" (graftemplatefunktion)

Aufruf

[Anwendung der Template-Funktion min]

int i=15;
int j=7;
cout << min(i,j) << endl;

Beispiel

[Template-Funktion swap]

template <typename T> void swap(T& a, T& b)
{
T hilf;

    hilf = a;
    a = b; 
    b = hilf;
}

Mehrere Typen

template <class T1, class T2>
int meineFunktion(T1 t1, T2 &t2)
{
    ...

Spezifizierung

int a = Create<int>();

Besitzt das Template mehrere offene Typen, so können diese, durch Kommata getrennt, angegeben werden. Es können aber auch nur die ersten Parameter festgelegt werden. Der folgende Aufruf von meineFunktion() stellt klar, dass der erste Parameter als short zu verstehen ist:

int a = meineFunktion<short>(12, 5.5);

Wenn Sie festlegen wollen, dass der erste Parameter als short und der zweite Parameter als float zu interpretieren ist, dann würde der Aufruf so aussehen:

int a = meineFunktion<short,float>(12, 5.5);

Template-Parameter

template <class T, int max>
int SuperArray(T t)
{
T a[max];
...
}

int main()
{
    SuperArray<int, 100>(12);
}

Makro-Ersatz

Template-Klassen

Beispiel

[Template-Klasse Stack]

// Ein Stack für eine beliebige Klasse T
template<class T> class Stack 
{
public:
    // Konstruktor mit Initialisierung der Konstanten maxStack
    Stack() : maxStack(256)
        { s = new T[maxStack]; index=0;}
    ~Stack() {delete[] s;}
    bool pop(T *); // abholen
    bool push(T ); // drauflegen
private:
    const int maxStack; // Konstante für die Stackgröße
    T *s;               // Der Stack selbst
    int index;          // aktuelle Position im Stack-Array
};

// Element vom Stack nehmen und freigeben
template<class T> bool Stack<T>::pop(T *get)
{
    if (index==0 ) return false; // ist Stack leer?
    *get = s[--index]; // Entnehme Element
    return true;
}

// Neues Element auf den Stack schieben
template<class T> bool Stack<T>::push(T set)
{
    if (index>=maxStack) return false; // Ist Stack überfüllt?
    s[index++] = set;  // Element auflegen
    return true;
}

int main() // Testet den Stack
{
   Stack<int> iStack; // Lege einen Stack für ganze Zahlen an

   iStack.push(8); // Testzahlen eintragen
   iStack.push(4);
   iStack.push(2);
   // Stack auslesen und auf dem Bildschirm anzeigen
   for (int i=0; i<3; i++)
   {
       int a;
       if (iStack.pop(&a))
       {
           cout << a << endl;
       }
   }
}

Funktionsdefinition

template<class T> bool Stack<T>::push(T set)

Anlegen einer Instanz

Stack<int> iStack;

Im weiteren Verlauf werden ein paar Werte auf den Stack gelegt und wieder heruntergeholt. Dabei ist nicht mehr zu erkennen, dass der Stack ein Template ist.

Template-Klasse mit Parameter

#include <iostream>
using namespace std;

template<class T, int max> class Stack
{
public:
    Stack() : maxStack(max)  // wird bei Definition festgelegt
        { s = new T[maxStack]; index=0;}
    ~Stack() {delete[] s;}
    bool pop(T *); // abholen
    bool push(T ); // drauflegen
private:
    const int maxStack; // Konstante für die Stackgröße
    T *s;               // Der Stack selbst
    int index;          // aktuelle Position im Stack-Array
};

// Element vom Stack nehmen und freigeben
template<class T, int max> bool Stack<T,max>::pop(T *get)
{
    if (index==0 ) return false; // ist Stack leer?
    *get = s[--index]; // Element entnehmen
    return true;
}

// Neues Element auf den Stack schieben
template<class T, int max> bool Stack<T,max>::push(T set)
{
    if (index>=maxStack) return false; // ist Stack überfüllt?
    s[index++] = set; // Element auflegen
    return true;
}

int main() // Testlauf
{
   Stack<int, 2> iStack; // Stack mit zwei Integerelementen
   int a;

   iStack.push(8); // Auffüllen!
   iStack.push(4);
   iStack.push(2); // Hier wird es eng!
   // Ausgabe des Stacks
   for (int i=0; i<3; i++)
   {
       if (iStack.pop(&a))
       {
           cout << a << endl;
       }
   }
}

• Schreiben Sie die Template-Klasse Stack neu, so dass sie mit linearen Listen implementiert wird. Sie können dazu die Klasse tStack verwenden. Es versteht sich von selbst, dass Sie dann keine Begrenzung der Länge benötigen.

Makroprogrammierung mit #define

Präprozessor

#define min(a,b) a>b?b:a

Aus Sicht eines C++-Programmierers haben Makros folgende Nachteile:

• Da Makros reine Textersetzungen sind, die der Präprozessor vor dem eigentlichen Übersetzungslauf durchführt, kann der Compiler nicht kontrollieren, ob die Aufrufparameter einwandfrei sind.
• Sobald ein Makro etwas größer wird, werden die Ausdrücke schnell unübersichtlich, da es nicht möglich ist, Zwischenergebnisse in Variablen abzulegen.
• Es kann leicht zu falschen Prioritäten kommen, da die Parameter beim Aufruf nicht ausgewertet werden. Beispiel:

  [Tückisches Makro]

  #define  mul(a,b) a*b
  int a=-5;
  int c = mul(a+4,2);
  

  Das Ergebnis ist keineswegs -2, sondern 3! Der Grund ist, dass a+4 nicht beim Aufruf zu -1 umgerechnet wird, sondern textuell ersetzt wird:

  c = a+4*2;
  

  Daraus wird dann -5+8.

• Die Fehlermeldungen des Compilers zeigen meist nicht die Stelle im Makro an, die das Problem verursacht, sondern die Stelle, wo das Makro aufgerufen wird.
• Durch die Beschränkung auf den Rest der Zeile ist Makro-Code meist sehr gepackt und dadurch oft völlig unlesbar.