C++ 09: Function Templates & Class Templates

📐 1. Funktions-Templates (template<typename T>)

Templates ermöglichen es, Algorithmen unabhängig von konkreten Datentypen zu formulieren. Zur Compile-Zeit generiert der C++-Compiler (Monomorphisierung) für jeden verwendeten Typ eine optimierte Maschinenbauform:

#include <iostream>
#include <string>

// Generische Minimum-Funktion
template <typename T>
T min_value(T a, T b) {
    return (a < b) ? a : b;
}

// Mehrere Template-Parameter
template <typename T, typename U>
auto add_heterogeneous(T a, U b) -> decltype(a + b) {
    return a + b;
}

int main() {
    std::cout << min_value(10, 20) << "\n";          // T = int
    std::cout << min_value(3.14, 2.71) << "\n";      // T = double
    std::cout << min_value<std::string>("Alpha", "Beta") << "\n"; // Explizit
}

📦 2. Klassen-Templates & Non-Type Template Parameters (NTTP)

Klassen können generisch über Datentypen und über compile-zeitliche Konstanten (wie Array-Größen) parametrisiert werden:

#include <cstddef>
#include <stdexcept>

// T = Datentyp, Size = Compile-Zeit Konstante (NTTP)
template <typename T, std::size_t Size>
class StaticStack {
private:
    T data_[Size];
    std::size_t top_{0};

public:
    void push(const T& item) {
        if (top_ >= Size) throw std::overflow_error("Stack Overflow");
        data_[top_++] = item;
    }

    T pop() {
        if (top_ == 0) throw std::underflow_error("Stack Underflow");
        return data_[--top_];
    }

    [[nodiscard]] std::size_t capacity() const { return Size; }
    [[nodiscard]] std::size_t size() const { return top_; }
};

🔍 3. Explizite Template-Spezialisierung

Manchmal erfordern spezifische Datentypen (z.B. bool oder const char*) eine spezialisierte Behandlung:

// Primäres Template
template <typename T>
struct TypeFormatter {
    static std::string format(const T& val) {
        return "Generic: " + std::to_string(val);
    }
};

// Vollständige Spezialisierung für std::string
template <>
struct TypeFormatter<std::string> {
    static std::string format(const std::string& val) {
        return "String: \"" + val + "\"";
    }
};

// Spezialisierung für bool
template <>
struct TypeFormatter<bool> {
    static std::string format(const bool& val) {
        return val ? "Bool: TRUE" : "Bool: FALSE";
    }
};

📑 4. Cheat-Sheet: C++ Template Konzepte

🎯 Aufgaben & Checkliste in aufgabe.cpp