Template-Spezialitäten II

// Beispiel für Member-Templates

#include <fstream>
#include <iostream>
#include <sstream>
#include <limits>

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

// SaveFile implementiert eine Klasse zum sicheren Schreiben
// und Lesen von Daten aus eine Datei. Beim Einlesen der Daten
// wird der in der Datei mit abgelegte Datentyp mit dem einzulesenden
// Datentyp verglichen. Sind die Datentypen unterschiedlich,
// so wird eine Exception ausgelöst
class SaveFile
{
    std::fstream ioFile;
public:
    // ctor, öffnet Datei zum Lesen und Schreiben
    SaveFile(const char* fileName);
    // dtor, schliesst Datei
    ~SaveFile();
    // Reset setzt den Schreib- und Lesezeiger zurück
    void Reset();
    // Member-Template zum Schreiben des Datum
    template <typename T> void Write(const T& value);
    // Member-Template zum Einlesen eines Datums
    template <typename T> void Read(T& value);
};
// ctor, öffnet Datei zum Lesen und Schreiben
SaveFile::SaveFile(const char* fileName)
{
    ioFile.open(fileName,std::ios::in|std::ios::out|std::ios::trunc);
    if (!ioFile)
       throw string("Fehler beim Datei oeffnen!");
}
// dtor, schliesst Datei
SaveFile::~SaveFile()
{
    ioFile.close();
}
// Reset, setzt den Schreib- und Lesezeiger zurück
void SaveFile::Reset()
{
    ioFile.seekg(0);
    ioFile.seekp(0);
}
// Member-Template zum Schreiben des Datum
// Vor dem eigentlichen Datum wird der Datentyp mit
// in die Datei geschrieben. Trennzeichen zwischen
// Datentyp und Datum ist '@'
template <typename T>
void SaveFile::Write(const T& value)
{
    ioFile << typeid(T).name() << '@' << value << std::endl;
}
// Member-Template zum Einlesen eines Datums
template <typename T>
void SaveFile::Read(T& value)
{
    // Datentyp und Datum einlesen
    string inputLine;
    std::getline(ioFile, inputLine);
    // Suche nach @ um Datentyp zu extrahieren
    string::size_type delimiterPos = inputLine.find('@');
    if (delimiterPos == string::npos)
       throw string("Datentyp konnte nicht bestimmt werden!");
    // Datentyp extrahieren
    string inputDType;
    inputDType.assign(inputLine,0,delimiterPos);
    // Falls einzulesender Datentyp und Dateidatentyp nicht
    // identisch sind, Exception auslösen
    if (inputDType != typeid(T).name())
    {
        string err("Falscher Datentyp -> ist: ");
        err += inputDType + ", soll: " + typeid(T).name();
        throw err;
    }
    // Datentyp entfernen
    inputLine.erase(0,delimiterPos+1);
    // ASCII-Datum nach binär konvertieren
    std::istringstream is(inputLine);
    is >> value;
    if (is.fail())
       throw string("Fehler bei der Datenkonvertierung!");
}

// main() Funktion
int main()
{
    // Datei-Objekt definieren
    SaveFile testFile("test.dat");
    // 3 Daten in Datei schreiben
    char cVal = 'A';
    long double ldVal = 1.0;
    std::string anyString("Hier geht's ab!");
    testFile.Write(cVal);
    testFile.Write(ldVal);
    testFile.Write(anyString);
    // Daten zuruecksetzen damit Einlesen kontrolliert werden kann
    cVal = 0;
    ldVal = 0;
    anyString = "";
    // Dateizeiger zurücksetzen
    testFile.Reset();
    // Nun versuchen alle Daten wieder einzulesen
    // Zum Testen mal die 1. oder 2. Zeile auskommentieren
    try
    {
        testFile.Read(cVal);
        testFile.Read(ldVal);
        testFile.Read(anyString);
    }
    catch (const string& errMsg)
    {
        cout << "Fehler: " << errMsg << endl;
        exit(1);
    }
    // Eingelesen Daten zur Kontrolle ausgeben
    cout << "Eingelesene Daten: " << cVal
         << ',' << ldVal << ',' << anyString << endl;
}

// Beispiel zur Template-Spezialisierung

#include <iostream>
#include <limits>
#include <utility>
#include <string>

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

// Allgemeines Template für die Ablage
// von Werten mit Wertebereiche (min/max)
template <typename T>
class Parameter
{
    T   value;      // Wert
    T   minValue;   // zulässiger Wertebereich
    T   maxValue;
  public:
    // ctor
    Parameter(const T& v);
    // Wertebereich setzen
    std::pair<T,T> SetMinMax(const T& min, const T& max);
    // Anzeige der Daten
    void Show() const;
};
// ctor
template <typename T>
Parameter<T>::Parameter(const T& v): value(v)
{
    // Standardmässig ist zulässiger Bereich der
    // gesamte Bereich des Datentyps
    minValue = std::numeric_limits<T>::min();
    maxValue = std::numeric_limits<T>::max();
}
// Wertebereich setzen
// Memberfunktion liefert ursprünglichen Bereich als pair zurück
template <typename T>
std::pair<T,T> Parameter<T>::SetMinMax(const T& min, const T& max)
{
    std::pair<T,T> oldMinMax = std::make_pair(minValue, maxValue);
    minValue = min;
    maxValue = max;
    return oldMinMax;
}
// Anzeige der Daten
template <typename T>
void Parameter<T>::Show() const
{
    cout << "Datentyp: " << typeid(T).name() << '\n';
    cout << "Wert: " << value
         << ", Min/Max: (" << minValue << '/' << maxValue << ")\n";
    cout << "---------------------------" << endl;
}

// Spezialisiertes Template für string-Datentyp
// enthält kein Bereich
template<>
class Parameter<string>
{
    string value;   // string
  public:
    Parameter(const string& s);
    void Show();
};
// Definition der Memberfunktionen des spezialisierten Templates
// Beachten Sie, dass die Memberfunktionen keine Template-Deklarationen
// besitzen!
Parameter<string>::Parameter(const string& s): value(s)
{}
void Parameter<string>::Show()
{
    cout << "Der String hat den Inhalt: " << value << endl;
}

// main() Funktion
int main()
{
    // int und float Parameter-Objekte definieren
    Parameter<int> intParam(10);
    Parameter<float> floatParam(-10.0f);

    // Daten ausgeben
    intParam.Show();
    floatParam.Show();
    // Für floats neuen Bereich setzen
    std::pair<float,float> fMinMax;
    fMinMax = floatParam.SetMinMax(-100.0f, 100.0f);
    floatParam.Show();
    // Bisherigen Bereich ausgeben
    cout << "Urspruenglicher float-Bereich war: (" << fMinMax.first
         << '/' << fMinMax.second << '\n' << endl;

    // string Parameter-Objekt definieren
    // Der Aufruf von SetMinMax() würde zur Compile-Zeit
    // zu einem Fehler führen!
    Parameter<string> stringParam("Dies ist der C-String");
    stringParam.Show();
}

// Beispiel für partielle Template-Spezialisierung

#include <iostream>
#include <fstream>
#include <iomanip>
#include <queue>
#include <string>

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

// Template-Klasse für das Aufsammeln von Daten die auf
// Anforderung in einen Stream übertragen werden können
// TOut ist der stream in den die Daten geschrieben werden
// und TData der Datentyp der Daten
template <typename TOut, typename TData>
class Collector
{
    TOut& out;                    // Referenz auf Ausgabestream
    std::queue<TData> data;       // Queue mit Daten
  public:
    // ctor, initialisiert Ausgabestream-Referenz
    Collector(TOut& out_): out(out_)
    {}
    // Datum hinzufügen
    void AddData(TData data_)
    {
        data.push(data_);
    }
    // Daten aus der Queue übertragen. Es wird immer das
    // High-Byte zuerst ausgegeben
    void Transmit()
    {
        // Ausgabe in Hex und mit führender 0
        out << std::hex << std::setfill('0');
        // Alle Daten aus der Queue ausgeben
        while (!data.empty())
        {
            // char-Zeiger auf aktuelles Datum setzen
            char* ptr = reinterpret_cast<char*>(&data.front());
            // Zeiger auf High-Byte setzen
            ptr += sizeof(TData)-1;
            // Nun alle Bytes nacheinander ausgeben, von High-Byte nach Low-Byte
            for (size_t byteCount=0; byteCount<sizeof(TData); byteCount++)
                out << std::setw(2) << static_cast<int>(*ptr--);
            out << ',';
            // Element aus Queue nach der Übertragung entfernen
            data.pop();
        }
        // Ausgabe wieder auf 'normal' zurückstellen
        out << std::dec << std::setfill(' ');
        out << endl;
    }
};
// Partiell spezialisiertes Template für den Datentyp string
// Strings werden niemals von High-Byte nach Low-Byte übertragen
template <typename TOut>
class Collector<TOut, string>
{
    TOut& out;
    std::vector<string> data;
  public:
    Collector(TOut& out_): out(out_)
    {}
    void AddData(const string& data_)
    {
        data.push_back(data_);
    }
    // Vereinfachte Version für string
    void Transmit()
    {
        for (typename std::vector<string>::iterator iter=data.begin(); iter!=data.end(); ++iter)
            out << *iter << ',';
        out << endl;
    }
};

// main() Funktion
int main()
{
    // Für Datenausgabe in Datei muss bei der Definition
    // eines Collector-Objekts der Ausgabestream 'cout'
    // durch 'outFile' ersetzt werden
    // std::ofstream outFile("test.dat");

    // Collector für numerische Daten definieren
    Collector<std::ostream, int> intCol(cout);
    intCol.AddData(1);
    intCol.AddData(2);
    intCol.AddData(0x11223344);
    intCol.Transmit();
    // Collector für string definieren
    Collector<std::ostream, std::string> stringCol(cout);
    stringCol.AddData(string("Eins"));
    stringCol.AddData(string("Zwei"));
    stringCol.AddData(string("Drei"));
    stringCol.Transmit();
}

// Beispiel für partielle Template-Spezialisierung
// aufgrund eines bestimmten Wertes

#include <iostream>
#include <iomanip>
#include <string>
#include <algorithm>

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

// Klassen-Template für allgemeine Matrix
// T = Datentyp der Elemente
// r = Anzahl der Zeilen
// c = Anzahl der Spalten
template <typename T, int r, int c>
class matrix
{
    T **data;      // Zeiger-Zeiger(!) auf dyn. 2D-Feld
    int col;       // Spalten
    int row;       // Zeilen
  public:
    // ctor, reserviert 2D-Feld dynamisch
    matrix()
    {
        row = r;   // Zeilen/Spalten merken
        col = c;
        // 2D-Feld dyn. reservieren
        data = new T*[row];
        for (int i=0; i<row; i++)
            data[i] = new T[col];
    }
    // Memberfunktionen zum Setzen eines Matrix-Elements
    // Zeilen/Spalten-Nr. beginnen ab 1!
    void SetData(int row_, int col_, T val)
    {
        if ((col_<1) || (col_>col) ||
            (row_<1) || (row_>row))
            throw "Falsch Zeile oder Spalte";
        data[row_-1][col_-1] = val;
    }
    // Matrix transponieren (Zeilen/Spalten vertauschen)
    void Transpose()
    {
        cout << "Transponiere rechteckige Matrix\n";
        // Neues 2D-Feld anlegen mit vertauschter Grösse
        // Spalte->Zeile, Zeile->Spalte
        T **temp;
        temp = new T*[col];
        for (int i=0; i<col; i++)
            temp[i] = new T[row];
        // Matrix transponieren
        for (int ri=0; ri<row; ri++)
            for (int ci=0; ci<col; ci++)
                temp[ci][ri] = data[ri][ci];
        // Alte Matrix nun löschen
        for (int i1=0; i1<row; i1++)
            delete [] data[i1];
        delete [] data;
        // Zeiger auf neue Matrix abspeichern
        data = temp;
        // Zeilen/Spalten Anzahl vertauschen
        std::swap(col,row);
    }
    // Matrix ausgeben
    void Print()
    {
        for (int ri=0; ri<row; ri++)
        {
            for (int ci=0; ci<col; ci++)
                cout << std::setw(5) << data[ri][ci];
            cout << endl;
        }
    }
};

// Partiell spezialisierte Matrix für eine quadratische
// Matrix (Zeilen=Spalten)
template <typename T, int s>
class matrix<T,s,s>
{
    T **data;      // dyn. 2D-Feld
    int size;      // Grösse der quadratischen Matrix
  public:
    // ctor, reserviert dyn. 2D-Feld
    matrix()
    {
        size = s;
        data = new T*[size];
        for (int i=0; i<size; i++)
            data[i] = new T[size];
    }
    // Memberfunktionen zum Setzen eines Matrix-Elements
    // Zeilen/Spalten-Nr. beginnen ab 1!
    void SetData(int row_, int col_, T val)
    {
        if ((col_<1) || (col_>size) ||
            (row_<1) || (row_>size))
            throw "Falsch Zeile oder Spalte";
        data[row_-1][col_-1] = val;
    }
    // Matrix transponieren
    // Bei quadratischen Matrizen muss kein temporäres 2D-Feld
    // angelegt werden; es können direkt die Matrix-Elemente
    // vertauscht werden
    void Transpose()
    {
        cout << "Transponiere quadratische Matrix\n";
        for (int ri=0; ri<size-2; ri++)
            for (int ci=ri+1;ci<=size-1; ci++)
                std::swap(data[ci][ri],data[ri][ci]);
    }
    // Matrix ausgeben
    void Print()
    {
        for (int ri=0; ri<size; ri++)
        {
            for (int ci=0; ci<size; ci++)
                cout << std::setw(5) << data[ri][ci];
            cout << endl;
        }
    }
};

// main() Funktion
int main()
{
    // Rechteckige Matrix anlegen
    matrix<short,3,4> rectMat;
    // Und mit Werten belegen
    for (int r=1; r<=3; r++)
        for (int c=1; c<=4; c++)
            rectMat.SetData(r,c,c*10+r);
    // Matrix ausgeben
    cout << "Ausgangsmatrix:\n";
    rectMat.Print();
    // Matrix transponieren und ausgeben
    rectMat.Transpose();
    cout << "Transponierte Matrix:\n";
    rectMat.Print();

    // Quadratische Matrix anlegen
    matrix<double,4,4> sqrMat;
    // Und mit Werten belegen
    for (int r=1; r<=4; r++)
        for (int c=1; c<=4; c++)
            sqrMat.SetData(r,c,double(r*100+c)/10.0);
    // Matrix ausgeben
    cout << "\nAusgangsmatrix:\n";
    sqrMat.Print();
    // Matrix transponieren und ausgeben
    sqrMat.Transpose();
    cout << "Transponierte Matrix:\n";
    sqrMat.Print();
}

// Beispiel zu Template-Template Parameter

#include <iostream>
#include <string>
#include "demo.h"

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

// Templates zur Reservierung von Speicher.
// Templates werden nachher als Parameter eines weiteren
// Templates verwendet um die Art der Speicherreservierung
// zu bestimmen
// Hinweis: Die Templates sind jetzt vom Typ struct da
// alle Memberfunktionen public sind
// 1. Speicherreservierung mittels new
template <class T>
struct NewAlloc
{
    static T* Create()
    {
        cout << "NewAlloc::Create()" << endl;
        return new T;
    }
    static void Destroy(T *ptr)
    {
        cout << "NewAlloc::Destroy()" << endl;
        delete ptr;
    }
};
// 2. Speicherreservierung mittels malloc
// In der Praxis könnte z.B anstelle von malloc(...) die
// Reservierung von Speicher in einem bestimmten Bereich
// (z.B. shared-Memory) erfolgen
template <class T>
struct MallocAlloc
{
    static T* Create()
    {
        cout << "MallocAlloc::Create()" << endl;
        void *pMem = std::malloc(sizeof(T));
        // Wenn mit malloc Speicher fuer Objekte reserviert
        // wird, so muss der ctor des Objekts explizit mit
        // dem placement-new Operator aufgerufen werden
        if (pMem != NULL)
           return new(pMem) T;
        return NULL;
    }
    static void Destroy(T* ptr)
    {
        cout << "MallocAlloc::Destroy()" << endl;
        // Explizter Aufruf des dtors erforderlich!
        ptr->~T();
        free(ptr);
    }
};

// Template zum Abspeichern von Daten
// Template erhaelt als ersten Parameter den Datentyp des Datums
// und als zweiten Parameter das Template zur Reservierung des
// Speichers. Das Template zur Speicherreservierung erhaelt seinen
// Template-Parameter automatisch aus dem Datentyp-Parameter
template <typename T, template <typename> class TAlloc=NewAlloc >
class StoreData
{
    T* pData;      // Zeiger auf das abzulegende Datum
  public:
    StoreData()
    {
        // Aufruf der entsprechenden Create()-Memberfunktion
        // TAlloc ist Klassen-Template!
        pData = TAlloc<T>::Create();
    }
    ~StoreData()
    {
        // Aufruf der entsprechenden Destroy() Memberfunktion
        TAlloc<T>::Destroy(pData);
    }
    // Datum setzen
    void SetData(const T& data)
    {
        *pData = data;
    }
    // Datum ausgeben
    void PrintData()
    {
        cout << "Datum: " << *pData << endl;
    }
};

// main() Funktion
int main()
{
    // Platz fuer int-Wert mit malloc anlegen
    cout << "int mit MallocAlloc:\n";
    StoreData<int, MallocAlloc> intParam;
    intParam.SetData(10);
    intParam.PrintData();
    // Platz fuer string-Wert mit new anlegen
    cout << "\nstring mit NewAlloc:\n";
    StoreData<string, NewAlloc> stringParam;
    stringParam.SetData("Another string");
    stringParam.PrintData();
    // Platz fuer float-Wert mit Default-Allokierung anlegen
    cout << "\nfloat mit Default-Template:\n";
    StoreData<float> floatParam;
    floatParam.SetData(3.1416f);
    floatParam.PrintData();
    // Platz fuer Demo-Objekt mit malloc anlegen
    cout << "\nDemo mit MallocAlloc:\n";
    StoreData<Demo, MallocAlloc> classParam;
    classParam.PrintData();
    classParam.SetData(Demo("A new string"));
    classParam.PrintData();
    // Ab hier wird wieder aufgeräumt
    cout << "\nUnd alles wieder entfernen:\n";
}