Template-Spezialitäten

#include <print>

// Klassentemplate
template <typename T>
class SaveData
{
    T data;     // Beliebiges Datum
public:
    // Standard-ctor
    SaveData()
    {
        data = T{};
    }
    // ctor mit abzulegendem Datum
    SaveData(const T& val)
    {
        data = val;
    }
    // Datum zurueckgeben
    T GetData() const
    {
        return data;
    }
};

// Funktionstemplate, erhaelt immer ein Objekt
// vom Typ des Klassentemplates SaveData
template <typename T>
void PrintTypeVal(const SaveData<T>& obj)
{
    // Datentyp und Wert des im Klassentemplate
    // abgelegten Datums ausgeben
    std::println("Template-Datentyp: {}, Datum: {}",
                 typeid(T).name(), obj.GetData());
}
int main()
{
    // int und float Datum in der Klasse ablegen
    SaveData intObj(1);
    SaveData floatObj(3.14f);
    // Datentyp und Datum ausgeben
    PrintTypeVal(intObj);
    PrintTypeVal(floatObj);
}

#include <print>
#include <typeinfo>

// 1. Klassentemplate
template <typename T>
class SaveData
{
    T data;     // Beliebiges Datum
public:
    // ctor mit abzulegendem Datum
    SaveData(const T& val) : data(val)
    { }
    // Datum zurueckgeben
    T GetData() const
    {
        return data;
    }
};

// 2. Klassentemplate
template <typename T>
class SaveData2
{
    T data;     // Beliebiges Datum
public:
    // ctor mit abzulegendem Datum
    SaveData2(const T& val) : data(val)
    { }
    // Datum zurueckgeben
    T GetData() const
    {
        return data * 2;
    }
};

// Funktionstemplate, erhaelt Objekte von
// verschiendenen Klassentemplates
template <typename T>
void PrintTypeVal(const T& obj)
{
    // Datentyp von T ausgeben
    std::println("Datentyp von T: {}", typeid(T).name());
    // Datentyp und Wert des im Klassentemplate
    // abgelegten Datums ausgeben
    std::println("Template-Datentyp: {}, Datum: {}",
        typeid(decltype(obj.GetData())).name(), obj.GetData());
}
int main()
{
    // int und float Datum in der Klasse ablegen
    SaveData  intObj(1);
    SaveData2 floatObj(3.14f);
    // Datentyp und Datum ausgeben
    PrintTypeVal(intObj);
    PrintTypeVal(floatObj);
}

#include <print>
#include <string>

// Basisklasse
template <typename T>
class Base
{
    T data;     // beliebiges Datum
public:
    // ctor mit abzulegendem Datum
    Base(const T& val): data(val)
    {}
    // Datum zurueckgeben
    virtual T GetData() const
    {
        return data;
    }
};

// Abgeleitete Klasse, Basisklassen-Template
// hat einen definierten Datentyp (hier int)
class SubNorm: public Base<int>
{
    std::string text;   // bel. Datum
public:
    // ctor
    SubNorm(const int val):
        Base(val), text("Basisdatentyp: fix")
    {}
    // Daten ausgeben
    void Print() const
    {
        auto res = GetData();
        std::println("{}, Daten: {}, Typ: {}",
                     text, res, typeid(res).name());
    }
};

// Abgeleitete Klasse, Basisklassen-Template
// kann verschiende Datentypen besitzen
template <typename T>
class SubTemp: public Base<T>
{
    std::string text;   // bel. Datum
public:
    // ctor mit abzulegendem Datum
    SubTemp(const T& val):
        Base<T>(val), text("Basisdatentyp: variable")
    {}
    // Daten ausgeben
    void Print() const
    {
        auto res = Base<T>::GetData();
        // Alternative:
        // auto res = this->GetData();
        std::println("{}, Daten: {}, Typ: {}",
                     text, res, typeid(res).name());
    }
};

int main()
{
    // 3 Objekte anlegen
    SubNorm normObj(10);    // T der Basisklasse = int
    SubTemp<float> tplObj1(3.14f); // T der Basisklasse = float
    SubTemp<char> tplObj2('a');   // T der Basisklasse = char

    // Daten ausgeben
    normObj.Print();
    tplObj1.Print();
    tplObj2.Print();
}

#include <print>
#include <string>
#include <string_view>

using namespace std::string_literals;

// 1. Basisklasse
class Car
{
    std::string name;
public:
    Car(std::string_view _name) : name(_name)
    { }
    const std::string GetData() const
    {
        return "PKW: "s + name;
    }
};
// 2. Basisklasse
class Truck
{
    std::string name;
public:
    Truck(std::string_view _name) : name(_name)
    {
    }
    const std::string GetData() const
    {
        return "LKW: "s + name;
    }
};

// Abgeleitete Klasse
// Erhaelt Basisklasse als Templateparameter TBase
template <typename TBase>
class Vehicle : public TBase
{
    float weight;
public:
    // ctor, ruft per TBase() den ctor
    // der aktuellen Basisklasse auf
    Vehicle(std::string_view name, float _weight):
        TBase(name), weight(_weight)
    { }
    // Daten ausgeben
    void Print() const
    {
        std::println("{}, Gewicht: {}t", TBase::GetData(), weight);
    }

};

int main()
{
    // Basisklasse von Vehicle ist Car
    Vehicle<Car> carObj("Golf", 1.6f);
    // Basisklasase von Vehicle ist nun Truck
    Vehicle<Truck> truckObj("Actros", 42.0f);
    // Daten ausgeben
    carObj.Print();
    truckObj.Print();
}

#include <print>
#include <string>
#include <string_view>

using namespace std::string_literals;

// 1. Basisklassen-Template
template <typename T>
class BasisTpl1
{
    T data;
    std::string text;
public:
    BasisTpl1(T _data) : data(_data), text("BasisTpl1"s)
    {
    }
    const std::string GetData() const
    {
        return std::format("{} mit {} Datum: {}",
            text, typeid(T).name(), data);
    }
};
// 2. Basisklassen-Template
template <typename T>
class BasisTpl2
{
    T data;
    std::string text;
public:
    BasisTpl2(T _data) : data(_data), text("BasisTpl2"s)
    {
    }
    const std::string GetData() const
    {
        return std::format("{} mit {} Datum: {}",
            text, typeid(T).name(), data);
    }
};

// Abgeleitete Klasse
// Erhaelt Basisklassen-Template als Templateparameter TBase
template <typename TBase, typename TData>
class Sub : public TBase
{
    char seperator;
public:
    // ctor, ruft per TBase() den ctor des
    // aktuellen Basisklassen-Templates auf
    Sub(char sep, TData data) :
        TBase(data), seperator(sep)
    {
    }
    // Daten ausgeben
    void Print() const
    {
        std::println("Sub {} {}", seperator, TBase::GetData());
    }

};

int main()
{
    // Klasse Sub mit Basisklasse BasisTpl1<char>
    Sub<BasisTpl1<char>, char> obj1Tpl1('-', 'A');
    // Klasse Sub mit Basisklasse BasisTpl1<float>
    Sub<BasisTpl1<float>, float> obj2Tpl1('|', 3.14f);
    // Klasse Sub mit Basisklasse BasisTpl2<int>
    Sub<BasisTpl2<int>, int> obj1Tpl2(',', 10);
    // Daten ausgeben
    obj1Tpl1.Print();
    obj2Tpl1.Print();
    obj1Tpl2.Print();
}

#include <print>
#include <string>

// Klasse zur Ausgabe eines Bildes
class Image
{
    std::string imgName;    // Bildname
public:
    Image(std::string_view _imgName): imgName(_imgName)
    { }
    // Bild ausgeben
    void Print() const
    {
        std::println("Bild '{}'", imgName);
    }
};
// Klasse zur Ausgabe eines Textes
class Text
{
    std::string text;   // auszugebender Text
public:
    Text(std::string_view _text): text(_text)
    { }
    // Text ausgeben
    void Print() const
    {
        std::println("Text '{}'", text);
    }
};

// Klasse zur Ausgabe einer Seite
class PrintPage
{
    int pageNum;    // Seitennummer
public:
    // ctor, gibt Seitennummer aus
    PrintPage(): pageNum(1)
    {
        std::println("--- Seite {} ---", pageNum);
    }
    // Ausgabe des uebergebenen Objekts
    // Das Objekt muss die Methode Print() definieren
    template <typename T>
    void PrintPg(const T& obj) const
    {
        obj.Print();
    }
    // Neue Seite ausgeben
    void NewPage()
    {
        std::println("--- Seite: {} ---", ++pageNum);
    }
};

int main()
{
    // 2 Bildobjekte und ein Textobjekt
    Image imgObj1{"Bild1"}, imgObj2{"Bild2"};
    Text  txtObj{ "Ich bin ein Textobjekt" };
    // Objekt fuer Ausgabe
    PrintPage thePage;

    // Ein Bild- und Textobjekt ausgeben
    thePage.PrintPg(imgObj1);
    thePage.PrintPg(txtObj);
    // Neue Seite
    thePage.NewPage();
    // Bild auf neuer Seite ausgeben
    thePage.PrintPg(imgObj2);
}

... Klasse Image und Text wie zuvor

// Klasse zur Ausgabe einer Seite
template <typename TPage>
class PrintPage
{
    int pageNum;    // Seitennummer
    TPage prefix;   // Seitenbeschriftung
public:
    // ctor, gibt Seitennummer aus
    PrintPage(TPage pref) : pageNum(1), prefix(pref)
    {
        std::println("--- {} {} ---", prefix,pageNum);
    }
    // Ausgabe des uebergebenen Objekts
    // Das Objekt muss die Methode Print() definieren
    template <typename Tobj>
    void PrintPg(const Tobj& obj) const
    {
        obj.Print();
    }
};

int main()
{
    // 2 Bildobjekte und ein Textobjekt
    Image imgObj1{ "Bild1" }, imgObj2{ "Bild2" };
    Text  txtObj{ "Ich bin ein Textobjekt" };
	
    // Objekt fuer Ausgabe mit char-Prefix
    PrintPage thePageNum('#');
    // Ein Bild- und Textobjekt ausgeben
    thePageNum.PrintPg(imgObj1);
    thePageNum.PrintPg(txtObj);
	
    // Neue Ausgabe mit const char-Prefix 
    PrintPage thePageString("Seite: ");
    thePageString.PrintPg(imgObj2);
}

#include <print>
#include <string>
using namespace std::string_literals;

// Klassentemplate zur Ablage von beliebige Datenelementen
template <typename pType>
class VArray
{
    pType *pData = nullptr; // Zeiger auf Datenfeld
    size_t noOfElements;    // Anzahl der Daten
    int index = 0;          // Datenfeld Index
public:
    // Variadischer ctor
    // Erhaelt die Daten als parameter pack
    template <typename ...args>
    VArray(args ... plist)
    {
        // Anzahl der Elemente berechnen
        noOfElements = sizeof...(plist);
        // Datenfeld anlegen
        pData = new pType[noOfElements];
        // Daten ins Feld übernehmen (fold Expression!)
        ((pData[index++] = plist), ...);
    }
    // dtor, gibt Datenfeld wieder frei
    ~VArray()
    {
        delete[] pData;
    }
    // Ausgabe der Daten
    void Print()
    {
        for (size_t i = 0; i < noOfElements; i++)
            std::print("{}, ", pData[i]);
        std::println("");
    }
};

int main()
{
    // Feld mit int-Daten anlegen und ausgeben
    VArray<int> intArray{ 1,2,3,4 };
    std::println("intArray:");
    intArray.Print();

    // Feld mit strings anlegen und ausgeben
    VArray<std::string> sArray{ "eins"s, "zwei"s, "drei"s };
    std::println("sArray:");
    sArray.Print();
}

#include <print>

template <typename T>
class Store
{
    T data;     // bel. Datum
public:
    // ctor
    Store(T _data): data(_data)
    { }
    // Addiert toAdd zum Datum
    void Add(const T& toAdd)
    {
        data += toAdd;
    }
    // Liefert Datum zurueck
    const T& GetData() const
    {
        return data;
    }
};

int main()
{
    Store intObj{10};       // int-Datum ablegen
    Store floatObj{3.14f};  // float-Datum ablegen
    // Daten ausgeben
    std::println("intObj: {}, floatObj: {}",
                 intObj.GetData(), floatObj.GetData());
    // Zu den Daten Werte addieren
    intObj.Add(10);
    floatObj.Add(3.14f);
    // und Daten ausgeben
    std::println("intObj: {}, floatObj: {}",
                 intObj.GetData(), floatObj.GetData());

}

#include <print>
#include <charconv>
#include <exception>

// Allgemeines Klassentemplate
template <typename T1, typename T2>
class CAny
{
    T1 data;
public:
    // ctor
    CAny(T1 _data) : data(_data)
    { }
    // Gibt akt. Wert plus value zurueck
    T1 Add(T2 value)
    {
        return data + value;
    }
};
// Spezialisiertes Template fuer den Fall
// dass ein textueller Wert addiert wird
template <typename T1>
class CAny<T1, const char*>
{
    T1 data;
public:
    // ctor
    CAny(T1 _data) : data(_data)
    { }
    // Addiert textuellen Wert
    T1 Add(const char* charValue)
    {
        // Text nach numerisch
        T1 value;
        auto res = std::from_chars(charValue, charValue + 99, value);
        // Bei Konvertierungsfehler, Ausnahme ausloesen
        if (res.ec != std::errc())
        {
            auto errText = std::format("Ungueltiger C-String '{}' in Add()",
                                        charValue);
            throw std::invalid_argument{ errText };
        }
        // akt. Wert plus numerischen Wert
        return data + value;
    }
};

int main()
{
    // Zwei Objekte definieren
    // 1. Objekt addiert short+short
    // 2. Objekt addiert int+"Textwert"
    CAny<short, short> obj1{ 10 };
    CAny<int, const char*> obj2{ 100 };
    // Ausnahmebehandlung
    try
    {
        std::println("obj1{{10}}+100={}", obj1.Add(100));
        std::println("obj2{{100}}+\"33\"={}", obj2.Add("33"));
        // Add("Anton") loest eine Ausnahme aus!
        std::println("obj2{{100}}+\"33\"={}", obj2.Add("Anton"));
    }
    catch (std::exception& ex)
    {
        std::println("FEHLER! {}", ex.what());
    }
}

#include <print>
// Allg. Template fuer Felder mit mehr als 10 Elemente
// Der non-type Parameter BIG ist true, wenn SIZE>10
template <typename T, int SIZE, bool BIG=(SIZE>10)>
class StoreData
{
    T* data;
public:
    // ctor, legt Feld dynamisch an
    StoreData(T(&_data)[SIZE])
    {
        data = new T[SIZE];
        for (int index = 0; index < SIZE; index++)
            data[index] = _data[index];
    }
    ~StoreData()
    {
        delete[] data;
        std::println("Feld geloescht!");
    }
    void Print()
    {
        std::println("Dynamisches Feld:");
        for (int index = 0; index < SIZE; index++)
            std::print("{}, ", data[index]);
        std::println("");
    }
};
// Spezialisiertes Template fuer mit bis zu 10 Elemente
// Spezialisierung erfolgt ueber den non-type Parameter
// BIG gleich false
template <typename T, int SIZE>
class StoreData<T, SIZE, false>
{
    T data[SIZE];   // statische Feld
public:
    StoreData(T(&_data)[])
    {
        for (int index = 0; index < SIZE; index++)
            data[index] = _data[index];
    }
    void Print()
    {
        std::println("Statisches Feld:");
        for (int index = 0; index < SIZE; index++)
            std:: print("{}, ", data[index]);
        std::println("");
    }
};
int main()
{
    // Kleines Feld mit 4 Elemente abspeichern
    int iArray[]{ 1,2,3,4 };
    StoreData obj1{ iArray };
    obj1.Print();
    // Grosses Feld mit 12 Elemente abspeichern
    float var[12]{};
    StoreData obj2{ var };
    obj2.Print();
}

#include <print>

class Complex
{
    float real;
    float imag;
public:
    Complex(float r, float i) : real(r), imag(i)
    {}
    // friend-Deklaration erforderlich, damit das
    // Template auf die Eigenschaften zugreifen kann
    friend struct std::formatter<Complex>;
};

// Spezialisertes formatter-Template fuer
// den Datentyp Complex
template<>
struct std::formatter<Complex>

{
    constexpr auto parse(auto& ctx)
    {
        // Formatspezifikation analysieren
        // hier noch nicht erforderlich
        return ctx.begin();
    }
    auto format(const Complex& s,
        std::format_context& ctx) const
    {
        // format_to() zur formatierten Ausgabe aufrufen
        // Formatierte Daten in Puffer den ctx.out() liefert
        return std::format_to(ctx.out(),
            "{:.2f}r+{:.2f}i ", s.real, s.imag);

    }
};

int main()
{
    Complex obj(1.2f, 3.4f);
    // Das ist die gewuenschte Ausgabe
    std::println("Complex: {}", obj);
}

#include <print>

class Complex
{
    float real;
    float imag;
public:
    Complex(float r, float i) : real(r), imag(i)
    {}
    // friend-Deklaration erforderlich, damit das
    // Template auf die Eigenschaften zugreifen kann
    friend struct std::formatter<Complex>;
};

// Spezialisertes formatter-Template fuer
// den Datentyp Complex
template <>
struct std::formatter<Complex>
{
private:
    // Formatoptionen
    enum class ftype { REAL, IMAG, COMPLETE }
    outType = ftype::COMPLETE;
public:
    constexpr auto parse(auto& ctx)
    {
        // Verweise auf Beginn und Ende der Formatoption
        auto iter{ ctx.begin() };
        const auto end{ ctx.end() };
        // Wenn kein Formatspezifierer angegeben
        if ((iter == end) || (*iter == '}'))
        {   // Alles ausgegeben
            outType = ftype::COMPLETE;
            return iter;
        }
        switch (*iter)  // Formatierungsoption auswerten
        {               // und abspeichern
        case 'i':
            outType = ftype::IMAG;
            break;
        case 'r':
            outType = ftype::REAL;
            break;
        case 'c':
            outType = ftype::COMPLETE;
            break;
        default:
            throw std::format_error{ "Ungueltiges Format!" };
        }
        // Naechstes Zeichen muss eine } sein
        ++iter;
        if ((iter != end) && (*iter != '}'))
            throw std::format_error{ "Ungueltiges Format!" };
        return iter;
    }
    auto format(const Complex& s, std::format_context& ctx) const
    {
      // Formatierte Daten in Puffer
      switch (outType)
      {
         using enum ftype;
      case COMPLETE:
         return std::format_to(ctx.out(),
                       "{:.2f}r+{:.2f}i", s.real, s.imag);
      case REAL:
         return std::format_to(ctx.out(), "{:.2f}r", s.real);
      case IMAG:
         return std::format_to(ctx.out(), "{:.2f}i", s.imag);
       }
    }
};
int main()
{
    Complex obj(1.2f, 3.4f);
    // Das ist die gewuenschte Ausgabe
    std::println("Complex std : {}", obj);
    std::println("Complex real: {:r}", obj);
    std::println("Complex imag: {:i}", obj);
    std::println("Complex r+i : {:c}", obj);
}