Generische Programmierung

Generische Programmierung ist ein Verfahren zur Entwicklung wiederverwendbarer Software-Bibliotheken. Dabei werden Funktionen möglichst allgemein entworfen, um sie für unterschiedliche Datentypen und Datenstrukturen verwenden zu können.

Grundlegendes

Die Implementierung erfolgt bei einigen Programmiersprachen durch das Konzept generischer Typen bzw. Templates – so gestalten sich dynamische Programmiersprachen, bei denen sich der Typ einer Variable zur Laufzeit ändern darf, durch ihre verallgemeinerte Polymorphie generisch. Von Sprachen, die solche Mechanismen bieten, sagt man auch, dass sie Generik erlauben.

Wesentlich bei der generischen Programmierung ist, dass die Algorithmen nicht für einen bestimmten Datentyp geschrieben werden, sondern nur bestimmte Anforderungen an die Typen stellen. Das Prinzip wird auch parametrische Polymorphie genannt.

Paradebeispiel ist die C++-Standardbibliothek der Programmiersprache C++, bei der die Algorithmen so weit wie möglich von den Datenstrukturen, mit denen sie arbeiten, getrennt werden.

Beispiele

Ein Beispiel liefert die Maximum-Funktion

\max :T\times T\to T

,

die für zwei gegebene Werte $a$ , $b$ desselben Typs den größeren Wert $\max\{a,b\}$ zurückgibt.

Voraussetzung ist, dass $a$ und $b$ miteinander vergleichbar sind, der Ausdruck $a\leq b$ also definiert ist und eine Ordnung beschreibt.

C

Neuschreiben der Algorithmen für jeden Datentyp

In klassischen Programmiersprachen wie C könnte man hier für jeden Datentyp eine Funktion programmieren, die jeweils das gleiche Ergebnis im entsprechenden Typ erzeugt.

Die folgenden Funktionen ermitteln von den beiden Zahlen a und b jeweils die größere, allerdings einmal als Integer und einmal als Float:

int maxInt(int a, int b) {
    if (a < b) {
        return b;
    } else {
        return a;
    }
}

float maxFloat(float a, float b) {
    if (a < b) {
        return b;
    } else {
        return a;
    }
}

Hierbei fällt auf, dass der Code an sich immer derselbe ist, nur die Typen unterscheiden sich.

Generische Programmierung

Hier wird der Typ durch den Präprozessor bestimmt.

#define Item int

Der Zieldatentyp in einer separaten Datei.

static Item maximum;

In derselben Datei befindet sich auch der Speichermechanismus.

static void save(void* tmp) {
    maximum = *((Item*) tmp);
}

Natürlich gibt es hier eine spezielle Vergleichsmethode für den Typ.

int compare(void* aa, void* bb) {
    if (*((Item*) aa) < *((Item*) bb)) {
        return -1;
    } else {
        return 0;
    }
}

Der generische Algorithmus zur Wiedergabe des Maximums.

void max(void *aa, void *bb, void save(void*)) {
    if (compare(aa, bb)) {
        save (bb);
    } else {
        save (aa);
    }
}

Die Funktion max ist hiermit komplett generisch. Man bemerkt, dass die Funktionen save und compare einen konkreten Datentyp verwenden, diese werden aber später, da sie nicht zur Grammatik des Algorithmus gehören, gekapselt.

C++

Verwendung objektorientierter Mittel

Der objektorientierte Ansatz funktioniert im Kontext statischer Typisierung nicht zufriedenstellend. Zwar lassen sich hier mit Interfaces oder Mehrfachableitung Klassen um „andere“ Datentypen erweitern, sodass sich mittels Polymorphie das Verhalten der generischen Programmierung zum Teil nachbauen lässt, allerdings wird die vollständige Unabhängigkeit von unterschiedlichen Typen (bzw. Klassen) damit nicht umgesetzt, weil es sich bei diesen Techniken auch nicht strenggenommen um objektorientierte Techniken handelt.

Definiert man in der Programmiersprache C++ eine Klasse Vergleichbares und leitet davon zum Beispiel für eine physikalische Simulation die Klassen Laenge und Masse ab (sagt also, dass sowohl Längen als auch die Masse etwas vergleichbares sind), so kann man zwar schreiben:

Vergleichbares& max(Vergleichbares& a, Vergleichbares& b) {
    if (a < b) {
        return b;
    } else {
        return a;
    }
 }

aber es gibt immer noch zwei Probleme:

Zunächst, dass der Ergebnistyp nur „Vergleichbares“ ist; man muss dem Compiler also beim Aufruf explizit sagen, dass das Maximum zweier Längen wieder eine Länge ist (sofern man dessen Längeneigenschaften benutzen will, was wahrscheinlich ist), vor allem aber,
dass diese Funktion es erlaubt, das Maximum einer Länge und einer Masse zu „bestimmen“, obwohl diese Operation keinen physikalischen Sinn hat.

Templates

Generische Programmierung, beispielsweise in C++ über Templates realisiert, verbindet nun die Flexibilität des Makros mit der Typsicherheit und den anderen Eigenschaften der Funktion. Die generische Implementierung von max in C++ ist

template<typename T>
T max(T a, T b) {
    if (a < b){
        return b;
    } else {
        return a;
    }
}

Die so definierte Funktion max() kann nun für alle Typen mit Vergleichsoperator verwendet werden.

Ein weiterer Vorteil ist, dass man nicht explizit bei der Definition sagen muss, dass ein Typ vergleichbar ist (zum Beispiel durch Ableiten von einer entsprechenden Klasse), sondern man muss nur sicherstellen, dass er die nötigen Eigenschaften hat (in diesem Fall einen operator < mit korrekter Semantik). Auf diese Weise können auch Typen mit der Funktion verwendet werden, die in Unkenntnis der Funktion entworfen wurden (beispielsweise die eingebauten Typen der Programmiersprache).

Ein Algorithmus sollte dabei stets möglichst wenig vom Typ fordern. So arbeiten die Algorithmen der STL nicht direkt auf den Containern, sondern mit Iteratoren. Auf diese Weise werden sie weitgehend unabhängig von den genauen Eigenschaften des speziellen Containers und können teilweise sogar direkt auf Ein- und Ausgabeströmen arbeiten.

C#

Generische Programmierung

Generische Programmierung in der Programmiersprache C# ähnelt den Templates in C++. Beispielsweise verwenden Klassen wie HashSet, List, Dictionary usw. generische Typen sehr gut. In C# werden spitze Klammern verwendet, um die Parametertypen in der generischen Klassendeklaration anzugeben. Im folgenden Beispiel wird ein Objekt einer generischen Klasse mit zwei Typparametern erstellt.

using System;

// Deklariert eine Klasse mit zwei Typparametern T und U
class Test<T, U>
{
    T object1; // Deklariert ein Objekt vom Typ T
    U object2; // Deklariert ein Objekt vom Typ U

    // Konstruktor der Klasse, der die zwei Objekte initialisiert
    public Test(T object1, U object2)
    {
        this.object1 = object1;
        this.object2 = object2;
    }

    // Methode, die die zwei Objekte auf der Konsole ausgibt
    public void Write()
    {
        Console.WriteLine(object1);
        Console.WriteLine(object2);
    }
}

// Hauptklasse, die die Hauptmethode enthält
class TestClass
{
	// Hauptmethode die das Programm ausführt
    public static void Main(string[] args)
    {
        Test<string, DateTime> testObject = new Test<string, DateTime>("Willkommen bei Wikipedia!", DateTime.Now); // Aufruf des Konstruktors
        testObject.Write(); // Aufruf der Methode, Ausgabe auf der Konsole

        Console.ReadLine();
    }
}

Generische Methoden

Eine Methode, die mit den Typparametern für ihren Rückgabetyp oder ihren Rückgabeparameter deklariert wird, wird als generische Methode bezeichnet. Im folgenden Beispiel wird ein Objekt einer generischen Klasse mit einer generische Methoden erstellt.

using System;
using System.Collections.Generic;

// Deklariert eine Klasse mit einem Typparameter T
class Test<T>
{
	private List<T> list = new List<T>(); // Deklariert eine Liste mit dem Typparameter T
	
	// Diese Methode fügt am angegebenen Index ein Element in die Liste ein
	public void Insert(int index, T item)
	{
		list.Insert(index, item);
	}
	
	// Diese generische Methode gib das Element am angegebenen Index zurück
	public T Get(int index)
	{
		if (index >= 0 && index < list.Count)
		{
			return list[index];
		}
		return default(T); // Wenn der Index nicht in der Liste ist, wird der Standardwert vom Typ zurückgegeben
	}
	
	// Diese Methode gibt die Liste Zeile für Zeile zurück
	public override string ToString()
	{
		string text = "";
		for (int i = 0; i < list.Count; i++) // for-Schleife, die die Elemente durchläuft
		{
			text += list[i] + "\r\n";
		}
		return text;
	}
}

// Hauptklasse, die die Hauptmethode enthält
class TestClass
{
	// Hauptmethode die das Programm ausführt
	public static void Main(string[] args)
	{
		Test<string> testObject = new Test<string>(); // Aufruf des Standard-Konstruktors mit dem Typparameter string
		// Fügt drei Elemente in die Liste ein
		testObject.Insert(0, "Werde Mitglied bei Wikipedia!");
		testObject.Insert(1, "Willkommen bei Wikipedia!");
		testObject.Insert(2, "Wie gefällt dir Wikipedia?");
		Console.WriteLine(testObject.ToString()); // Aufruf der Methode, Ausgabe aller drei Elemente auf der Konsole
		Console.WriteLine(testObject.Get(1)); // Aufruf der Methode, Ausgabe des zweiten Elements auf der Konsole
		
		Console.ReadLine();
	}
}