Template-Spezialitäten I

// Beispiel für Default-Datentyp in Templates
// Realisiert ein dynamisches Feld
// ACHTUNG!! Werden in dem Feld Objektzeiger abgelegt
// so müssen die dazugehörigen Objekte explizit wieder
// zerstört werden.

#include <iostream>
#include <stdexcept>

// Demo-Klasse einbinden
#include "demo.h"

using std::cout;
using std::endl;

// Klasse implementiert einen gesicherten Zugriff auf
// ein Feld. Wird beim Schreiben über das Ende des Feldes
// hinausgegriffen, so wird das Feld entsprechend erweitert
// Standardmässig wird das Feld für die Ablage von int-
// Daten angelegt
template <typename T = int>
class DynArray
{
    T* data;        // Zeiger auf Datenfeld
    size_t size;    // Grösse des Datenfelds
  public:
    // ctor, reserviert optional ein Feld mit einer
    // bestimmten Anzahl von Elementen
    DynArray(size_t reserveData = 0);
    // dtor
    ~DynArray();
    // Indexoperator für Array-Zugriff
    T& operator[] (size_t index);
    // Ausgabe des DynArrays
    void PrintArray();
};
// ctor
// Standardmässig wird kein Feld allokiert und der Datenzeiger
// mit NULL initialisiert
template <typename T>
DynArray<T>::DynArray(size_t reserveData): data(NULL), size(0)
{
    // Falls Datenfeld angelegt werden soll
    if (reserveData)
    {
        // Datenfeld reservieren
        data = new T[reserveData];
        size = reserveData;
    }
}
// dtor, gibt reserviertes Feld frei
template <typename T>
DynArray<T>::~DynArray()
{
    delete [] data;
}
// Überladener Indexoperator für den Zugriff
// auf die Elemente im DynArray
template <typename T>
T& DynArray<T>::operator[] (size_t index)
{
    // Falls Index < 0 dann eine Standard-Exception auslösen
    if (index<0)
        throw std::range_error("Index kleiner 0!");
    // Falls Index grösser als die Anzahl der Feldelement
    if (index>=size)
    {
        // Neues Feld mit der Grösse 'Index+1' reservieren
        // +1 hier unbedingt notwendig, da z.B. der
        // Index 10 das 11. Element adressiert!
        T* newData = new T[index+1];
        // Bisherige Daten in neues Feld übernehmen
        for (size_t copyOld=0; copyOld<size; copyOld++)
            newData[copyOld] = data[copyOld];
        // Altes Feld nun entfernen
        delete [] data;
        // Und Zeige auf neues Feld abspeichern
        data = newData;
        // Nicht vergessen: die Grösse korrigieren
        size = index+1;
    }
    // Gewünschtes Element zurückliefern
    return data[index];
}
// Komplettes Feld ausgeben
template <typename T>
void DynArray<T>::PrintArray()
{
    for (size_t index=0; index<size; index++)
        cout << data[index] << ", ";
    cout << endl;
}

// main() Funktion
int main()
{
    // DynArray mit Default-Datentyp 'int' und 5 Elementen anlegen
    DynArray<> intArray(5);
    // 5. Element beschreiben
    intArray[4] = 44;
    // 7. Element beschreiben -> führt zur Erweiterung des DynArrays
    intArray[6] = 66;
    // Komplettes Feld ausgeben (7 Elemente)
    cout << "Und das komplette int-Feld:\n";
    intArray.PrintArray();

    // DynArray mit 3 Demo-Objekten anlegen
    DynArray<Demo> objArray(3);
    // 2. Element beschreiben
    objArray[1] = Demo("erstes Objekt");
    // Komplettes Feld ausgeben (3 Elemente)
    objArray.PrintArray();
    // 6. Element beschreiben -> führt zur Erweiterung des DynArrays
    objArray[5] = Demo("zweites Objekt");
    // Komplettes Feld ausgeben (6 Elemente)
    cout << "Und das komplette Demo-Feld:\n";
    objArray.PrintArray();
}

// Beispiel fuer non-type Template-Parameter

#include <iostream>
#include <stdexcept>
#include <sstream>
#include "demo.h"

using std::cout;
using std::endl;

// Template fuer SafeArray
// Defaultmässig wird ein int-Array mit 50 Einträgen realisiert
// HINWEIS: Das gleiche Verfahren könnte auch dafür verwendet
// werden, um nicht 0-basierende Arrays zu implementieren
template <typename T=int, int SIZE=50>
class SafeArray
{
    T array[SIZE];
  public:
    typedef T value_type;
    T& operator[](int index);
};
// Implementierung des überladenen Index-Operators
template <typename T, int SIZE>
T& SafeArray<T, SIZE>::operator[] (int index)
{
    // Falls Zugriff ausserhalb der Grenzen, out_of_range werfen
    if ((index<0) || (index>=SIZE))
    {
        std::ostringstream os;
        os << "SafeArray: Erlaubt [0," << SIZE << "), Index war " << index;
        throw std::range_error(os.str());
    }
    // Referenz auf Element zurückgeben
    return array[index];
}

// Voll-spezifiziertes SafeArray für Demo-Objekte und 10 Elemente
typedef SafeArray<Demo,10> arrayType1;
// Standard SafeArrey für 50 int-Elemente
typedef SafeArray<> arrayType2;

// main() Funktion
int main()
{
    // Array mit Demo-Objekten definieren
    arrayType1 myArray;
    // Zugriff testen, die zweite Anweisung greift über das Array hinaus
    try
    {
        myArray[0] = Demo("Element 0");
        cout << "1. Element: " << myArray[0] << endl;
        arrayType1::value_type anyVal = myArray[99];
    }
    catch(std::range_error& ex)
    {
        cout << ex.what() << endl;
    }

    // Default Safe-Array für int-Daten mit 50 Elemente definieren
    arrayType2 yourArray;
    // Zugriff testen, die zweite Anweisung führt einen Zugriff
    // vor das erste Element durch
    try
    {
        arrayType2::value_type anyVal = yourArray[49];
        yourArray[-1] = 10;
    }
    catch(std::range_error& ex)
    {
        cout << ex.what() << endl;
    }
}

// Beispiel zur expliziten Typ-Angabe bei Funktions-Templates

#include <iostream>

using std::cout;
using std::endl;

// Funktions-Template zur byteweisen 'Übertragung' eines
// Wertes in ASCII-Form
template <typename T>
void SendTo(std::ostream& os, T value)
{
    // Datentyp ausgeben
    os << "sending bytes: ";
    os << typeid(T).name() << ' ';
    // char-Zeiger auf Datenbeginn aufsetzen
    const char* p = reinterpret_cast<const char*>(&value);
    // Alle Bytes durchlaufen
    for (size_t i=0; i<sizeof(T); i++)
    {
        // Low-Nibble nach ASCII konvertieren
        char lowNibble = (*p)&0x0f;
        lowNibble = (lowNibble>9) ? lowNibble+0x57 : lowNibble|0x30;
        // Heigh-Nibble nach ASCII konvertieren
        char highNibble = ((*p)>>4)&0x0f;
        highNibble = (highNibble>9) ? highNibble+0x57 : highNibble|0x30;
        // Datum in ASCII-Form 'übertragen'
        os << highNibble << lowNibble << ' ';
        // Zeiger auf nächstes Byte
        p++;
    }
    cout << endl;
}

// main() Funktion
int main()
{
    // Auszugebende Daten
    int intVal = 10;
    char charVal = 0x41;   // entspricht 'A'

    // Aufruf der Template-Funktion
    // Der Template-Datentyp ergibt sich aus dem Datentyp des Parameters
    SendTo(cout,intVal);
    SendTo(cout,charVal);

    // Aufruf der Template-Funktion mit Literalen
    // Standardmässig werden Literale als ints behandelt
    // Soll SendTo(...) mit anderem Datentyp aufgerufen werden,
    // so kann entweder der Datentyp explizit festgelegt werden
    // (2. Aufruf) oder aber der Template-Datentyp explizit
    // angegeben werden (3. + 4. Aufruf)
    SendTo(cout,0x61);
    SendTo(cout,0x61L);
    SendTo<char>(cout,0x61);
    SendTo<short>(cout,0x1234);
}

// Beispiel zur expliziten Typ-Angabe bei Funktions-Templates

#include <iostream>

using std::cout;
using std::endl;

// Funktions-Template zur byteweisen 'Übertragung' eines
// Wertes in ASCII-Form
template <typename T>
void SendTo(std::ostream& os, T value)
{
    // Datentyp ausgeben
    os << "sending bytes: ";
    os << typeid(T).name() << ' ';
    // char-Zeiger auf Datenbeginn aufsetzen
    const char* p = reinterpret_cast<const char*>(&value);
    // Alle Bytes durchlaufen
    for (size_t i=0; i<sizeof(T); i++)
    {
        // Low-Nibble nach ASCII konvertieren
        char lowNibble = (*p)&0x0f;
        lowNibble = (lowNibble>9) ? lowNibble+0x57 : lowNibble|0x30;
        // Heigh-Nibble nach ASCII konvertieren
        char highNibble = ((*p)>>4)&0x0f;
        highNibble = (highNibble>9) ? highNibble+0x57 : highNibble|0x30;
        // Datum in ASCII-Form 'übertragen'
        os << highNibble << lowNibble << ' ';
        // Zeiger auf nächstes Byte
        p++;
    }
    cout << endl;
}

// Spezialisierung für 'Übertragung' von Daten die
// über einen Zeiger referenziert werden
template <typename T>
void SendTo(std::ostream& os, T* value)
{
    os << "sending bytes: ";
    os << typeid(T).name() << ' ';
    // char-Zeiger auf Datenbeginn aufsetzen
    const char* p = reinterpret_cast<const char*>(value);
    // Alle Bytes durchlaufen
    for (size_t i=0; i<sizeof(T); i++)
        {
        // Low-Byte nach ASCII konvertieren
        char lowByte = (*p)&0x0f;
        lowByte = (lowByte>9) ? lowByte+0x57 : lowByte|0x30;
        // Heigh-Byte nach ASCII konvertieren
        char highByte = ((*p)>>4)&0x0f;
        highByte = (highByte>9) ? highByte+0x57 : highByte|0x30;
        // Datum in ASCII-Form 'übertragen'
        os << highByte << lowByte << ' ';
        // Zeiger auf nächstes Byte
        p++;
    }
    cout << endl;
}

// main() Funktion
int main()
{
    // Auszugebende Daten
    int intVal = 10;
    char charVal = 0x41;   // entspricht 'A'

    // Aufruf der Template-Funktion
    // Der Template-Datentyp ergibt sich aus dem Datentyp des Parameters
    SendTo(cout,intVal);
    SendTo(cout,charVal);

     // Aufruf der spezialisierten Template-Funktion
    SendTo(cout,&intVal);
    SendTo(cout,&charVal);
}

// Templates als Funktionsparameter

#include <iostream>
#include <stack>
#include <queue>
using std::cout;
using std::endl;
using std::stack;
using std::priority_queue;

// Template-Funktion zur Übertragung der Container
// stack und priority_queue
// Nach dem Verlassen der Funktion ist der übergebene
// Container geleert!!
template <typename T>
void SendTo(std::ostream& os, T& container)
{
    os << "sending bytes: ";
    // Kompletten Container leeren
    while(!container.empty())
    {
        // Einen Wert aus dem Container holen. Der aktuelle Datentyp
        // im Container ist als typedef value_type schon definiert
        typename T::value_type actVal = container.top();
        // Wert nun byteweise ausgeben
        char *ptr = reinterpret_cast<char*>(&actVal);
        for (size_t i=0; i<sizeof(typename T::value_type); i++)
            os << static_cast<int>(*(ptr++)) << ',';
        // Element aus Container entfernen
        container.pop();
    }
    os << endl;
}

// main() Funktion
int main()
{
    // int-Stack erzeugen und füllen
    stack<int> intVector;
    for (int i=0; i<5; i++)
        intVector.push(i);
    // Vektor jetzt byteweise an cout übertragen
    SendTo(cout,intVector);

    // short-Priority-Queue erzeugen und füllen
    priority_queue<short> shortQueue;
    for (int x=0; x<3; x++)
        shortQueue.push(x+10);
    // und ebenfalls an cout übertragen
    SendTo(cout, shortQueue);
}

// Beispiel für Templates als Basis-Klasse

#include <iostream>
#include <limits>

using std::cout;
using std::endl;

// Basisklassen-Template für 'normalen' Drehschalter
// Default-Datentyp des Button ist int
template <typename T=int>
class SpinButton
{
  protected:
    T value;       // akt. Wert
    T minValue;    // min. Wert
    T maxValue;    // max. Wert
  public:
    SpinButton()
    {
        minValue = std::numeric_limits<T>::min();
        maxValue = std::numeric_limits<T>::max();
        value = minValue;
    }
    void ShowProperties()
    {
        cout << "Datentyp: " << typeid(T).name() << '\n';
        cout << "Min/Max: (" << minValue << '/' << maxValue;
        cout << "), akt. Wert: " << value << endl;
    }
    void StepUp()
    {
        if (value < maxValue)
           value++;
    }

};

// Von der Template-Klasse SpinButton abgeleitete Klasse
// ImageSpinButton. Datentyp des Werts von SpinButton ist
// unsigned int. Die in der Basisklasse definierte Eigenschaft
// value dient als Imagelisten-Index.
class ImageSpinButton: public SpinButton<unsigned int>
{
    const char* const *imList;   // ACHTUNG! char-Zeiger Feld!
  public:
    ImageSpinButton(const char* const il[]): imList(il)
    {
        // Anzahl der Images in der Liste bestimmen
        maxValue = minValue;
        while(*(il+maxValue) != NULL)
            maxValue++;
        maxValue--;
    }
    void ShowProperties()
    {
        cout << "Datentyp: " << typeid(*this).name() << '\n';
        cout << "Min/Max: (" << minValue << '/' << maxValue;
        cout << "), akt. Image: " << imList[value] << endl;
    }
};

// main() Funktion
int main()
{
    // Spinbutton mit Default-Datentyp definieren
    SpinButton<> intSpin;
    intSpin.ShowProperties();
    intSpin.StepUp();
    intSpin.ShowProperties();

    // Imageliste für Image-Spinbutton
    const char* const imageList1[] =
          {"Image one","Image two","Image three",NULL};
    // Image-Spinbutton definieren
    ImageSpinButton ImageSpin(imageList1);
    ImageSpin.ShowProperties();
    ImageSpin.StepUp();
    ImageSpin.ShowProperties();
}