Generics in C++: wozu sie dienen und wie man Templates verwendet

Einführung: Was sind Generics in C++ und warum werden sie benötigt?

In der Programmierung tritt oft die Aufgabe auf, Code zu schreiben, der mit verschiedenen Datentypen gleichermaßen gut funktioniert. Beispielsweise sollte eine Sortierfunktion für Arrays sowohl Ganzzahlen als auch Zeichenketten oder benutzerdefinierte Objekte sortieren können. Ohne einen Mechanismus für generische Programmierung (Generics) müsste man separate Funktionen für jeden Typ schreiben, was zu Code-Duplizierung, Fehlern und erschwerter Wartung führt.

In C++ wird dieses Problem durch Vorlagen (Templates) gelöst – ein leistungsstarkes Werkzeug, das die Erstellung generischer Funktionen und Klassen ermöglicht. Das Konzept von Generics wird in C++ genau durch Templates umgesetzt. Sie erlauben es dem Programmierer, einen Algorithmus oder eine Datenstruktur zu definieren, ohne sich auf einen bestimmten Typ festzulegen, und den Typ erst zur Compile-Zeit einzusetzen.

Die wichtigsten Vorteile der Verwendung von Templates:

• Reduzierung von Code-Duplizierung – eine Vorlage ersetzt viele überladene Funktionen.
• Typsicherheit – alle Typprüfungen werden zur Compile-Zeit durchgeführt.
• Leistung – Templates verursachen keine Laufzeit-Overhead, da der Code für jeden spezifischen Typ separat generiert wird.
• Flexibilität – es können komplexe generische Konstrukte erstellt werden, einschließlich Container (STL) und Algorithmen.

In diesem Artikel werden wir im Detail besprechen, wie man Templates in C++ verwendet, angefangen bei einfachen Beispielen bis hin zu fortgeschrittenen Techniken.

Grundlagen der Arbeit mit Funktions-Templates

Der einfachste Weg, sich mit Generics vertraut zu machen, ist das Schreiben einer Template-Funktion. Angenommen, wir benötigen eine Funktion, die den Maximalwert von zwei Werten ermittelt. Ohne Templates müsste man Überladungen für int, double, std::string usw. schreiben. Mit Templates wird dies einmal erledigt:

#include <iostream>#include <string>

// Funktions-Templatetemplate <typename T>T max(T a, T b) {    return (a > b) ? a : b;}

int main() {    std::cout << max(10, 20) << std::endl;          // int    std::cout << max(3.14, 2.71) << std::endl;      // double    std::cout << max("apple", "orange") << std::endl; // const char* (Zeichenkettenvergleich)    return 0;}

Hier deklariert das Schlüsselwort template eine Vorlage, und typename T (oder class T) definiert den Typparameter. Der Compiler generiert automatisch eine Version der Funktion für jeden verwendeten Typ. Wichtig zu beachten ist, dass die Typen den Operator > unterstützen müssen – andernfalls tritt ein Compiler-Fehler auf.

Man kann auch mehrere Typparameter angeben:

template <typename T1, typename T2>void printPair(T1 a, T2 b) {    std::cout << "(" << a << ", " << b << ")" << std::endl;}

// VerwendungprintPair(42, "Hello"); // (42, Hello)

Klassen-Templates: Erstellung universeller Container

Klassen-Templates ermöglichen die Erstellung generischer Datenstrukturen – dies ist die Grundlage der Standard Template Library (STL). Betrachten wir ein einfaches Beispiel einer Template-Klasse für ein dynamisches Array:

#include <iostream>#include <stdexcept>

template <typename T>class Array {private:    T* data;    size_t size;public:    Array(size_t sz) : size(sz) {        data = new T[size];    }        ~Array() {        delete[] data;    }        T& operator[](size_t index) {        if (index >= size) {            throw std::out_of_range("Index out of range");        }        return data[index];    }        size_t getSize() const {        return size;    }};

int main() {    Array<int> intArray(5);     // Array von Ganzzahlen    Array<double> doubleArray(3); // Array von Gleitkommazahlen