Templates und Concepts

#include <iostream>
#include <string>

template <typename T>
T groesser(T a, T b) { return a > b ? a : b; }

template <typename T, typename U>
auto addiere(T a, U b) { return a + b; }

int main() {
    std::cout << groesser(3, 9) << ' ' << groesser(2.5, 1.5) << ' ' << groesser(std::string("a"), std::string("b")) << '\n';
    std::cout << addiere(1, 2.5) << ' ' << addiere(std::string("Ha"), "llo") << '\n';
    std::cout << groesser<double>(3, 2.5) << '\n';              // Typ explizit angeben
    return 0;
}

9 2.5 b
3.5 Hallo
3

#include <iostream>
#include <vector>
#include <stdexcept>

template <typename T>
class Stapel {
public:
    void push(const T& x) { daten_.push_back(x); }
    T pop() {
        if (daten_.empty()) throw std::out_of_range("Stapel leer");
        T x = daten_.back();
        daten_.pop_back();
        return x;
    }
    bool leer() const { return daten_.empty(); }
    std::size_t groesse() const { return daten_.size(); }
private:
    std::vector<T> daten_;
};

template <typename K, typename V>
struct Paar { K erstes; V zweites; };

int main() {
    Stapel<int> s;
    s.push(1); s.push(2); s.push(3);
    std::cout << s.pop() << s.pop() << ' ' << s.groesse() << '\n';
    Stapel<std::string> t;
    t.push("a");
    try { t.pop(); t.pop(); } catch (const std::out_of_range& e) { std::cout << e.what() << '\n'; }
    Paar<std::string, int> p{"Alter", 17};          // Typen werden erkannt (CTAD)
    std::cout << p.erstes << '=' << p.zweites << '\n';
    return 0;
}

32 1
Stapel leer
Alter=17

#include <iostream>
#include <concepts>
#include <vector>
#include <string>

template <typename T>
concept Zahl = std::integral<T> || std::floating_point<T>;

template <Zahl T>
T quadrat(T x) { return x * x; }

template <typename T>
concept HatGroesse = requires(const T& t) { { t.size() } -> std::convertible_to<std::size_t>; };

template <HatGroesse C>
std::size_t laenge(const C& c) { return c.size(); }

auto verdopple(std::integral auto x) { return x * 2; }          // Kurzschreibweise

int main() {
    std::cout << quadrat(5) << ' ' << quadrat(1.5) << '\n';
    std::cout << laenge(std::vector<int>{1, 2, 3}) << ' ' << laenge(std::string("Hallo")) << '\n';
    std::cout << verdopple(21) << '\n';
    // quadrat("text");   // Fehler: "text" erfüllt Zahl nicht - mit klarer Meldung
    return 0;
}

25 2.25
3 5
42

#include <iostream>

template <typename... Args>
auto summe(Args... args) { return (args + ...); }                // Fold Expression (C++17)

template <typename... Args>
void ausgeben(const Args&... args) { ((std::cout << args << ' '), ...); std::cout << '\n'; }

int main() {
    std::cout << summe(1, 2, 3, 4) << ' ' << summe(1.5, 2.5) << '\n';
    ausgeben("a", 1, 2.5, 'c');
    return 0;
}

10 4
a 1 2.5 c

#include <iostream>
#include <string>

template <typename T>
std::string beschreibe(const T&) { return "irgendwas"; }

template <>
std::string beschreibe<int>(const int& x) { return "int " + std::to_string(x); }       // Spezialfall

template <typename T>
std::string typ() {
    if constexpr (std::is_integral_v<T>) return "Ganzzahl";              // Auswahl zur Übersetzungszeit
    else if constexpr (std::is_floating_point_v<T>) return "Kommazahl";
    else return "anderes";
}

int main() {
    std::cout << beschreibe(5) << ", " << beschreibe(2.5) << '\n';
    std::cout << typ<int>() << ' ' << typ<double>() << ' ' << typ<std::string>() << '\n';
    return 0;
}

int 5, irgendwas
Ganzzahl Kommazahl anderes