imported>RolandIllig: /* C */ Abschnitt entfernt, da die Implementierung mit Pointern unnötig kompliziert ist und auch nicht erläutert wird

2023-01-28T21:17:54Z

C: Abschnitt entfernt, da die Implementierung mit Pointern unnötig kompliziert ist und auch nicht erläutert wird

Neue Seite

{{Belege fehlen}}
'''Generische Programmierung''' ist ein Verfahren zur Entwicklung wiederverwendbarer [[Programmbibliothek|Software-Bibliotheken]]. Dabei werden [[Funktion (Programmierung)|Funktionen]] möglichst allgemein entworfen, um sie für unterschiedliche [[Datentyp]]en und [[Datenstruktur]]en verwenden zu können.

== Grundlegendes ==
Die Implementierung erfolgt bei einigen [[Programmiersprache]]n durch das Konzept [[generischer Typ]]en bzw. [[Template (C++)|Templates]] – so gestalten sich [[dynamische Programmiersprache]]n, bei denen sich der Typ einer Variable zur Laufzeit ändern darf, durch ihre verallgemeinerte [[Polymorphie (Programmierung)|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 [[Algorithmus|Algorithmen]] so weit wie möglich von den Datenstrukturen, mit denen sie arbeiten, getrennt werden.

== Beispiele ==
Ein Beispiel liefert die Maximum-Funktion
: <math>\max: T \times T \to T</math>,

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

Voraussetzung ist, dass <math>a</math> und <math>b</math> miteinander vergleichbar sind, der Ausdruck <math>a \le b</math> also definiert ist und eine [[Ordnungsrelation|Ordnung]] beschreibt.

=== C++ ===

==== Verwendung objektorientierter Mittel ====
Der [[Objektorientierte Programmierung|objektorientierte]] Ansatz funktioniert im Kontext statischer Typisierung nicht zufriedenstellend. Zwar lassen sich hier mit [[Schnittstelle (Objektorientierung)|Interfaces]] oder Mehrfachableitung [[Klasse (Objektorientierung)|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 (Objektorientierung)|Klasse]] <code>Vergleichbares</code> und leitet davon zum Beispiel für eine physikalische [[Simulation]] die Klassen <code>Laenge</code> und <code>Masse</code> ab (sagt also, dass sowohl Längen als auch die Masse etwas vergleichbares sind), so kann man zwar schreiben:

<syntaxhighlight lang="c++">
Vergleichbares& max(Vergleichbares& a, Vergleichbares& b) {
if (a < b) {
return b;
} else {
return a;
}
}
</syntaxhighlight>

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 [[Template (C++)|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

<syntaxhighlight lang="cpp">
template<typename T>
T max(T a, T b) {
if (a < b){
return b;
} else {
return a;
}
}
</syntaxhighlight>

Die so definierte Funktion <code>max()</code> 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 [[Standard Template Library|STL]] nicht direkt auf den Containern, sondern mit [[Iterator]]en. 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-Sharp|C#]] ähnelt den Templates in [[C++]]. Beispielsweise verwenden Klassen wie ''HashSet'', ''List'', ''Dictionary'' usw. [[Generischer Typ|generische Typen]] sehr gut. In C# werden spitze Klammern verwendet, um die Parametertypen in der generischen Klassendeklaration anzugeben. Im folgenden Beispiel wird ein [[Objekt (Programmierung)|Objekt]] einer generischen [[Klasse (Objektorientierung)|Klasse]] mit zwei Typparametern erstellt.<syntaxhighlight lang="c#">
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();
}
}
</syntaxhighlight>

==== Generische Methoden ====
Eine [[Methode (Programmierung)|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 (Programmierung)|Objekt]] einer generischen [[Klasse (Objektorientierung)|Klasse]] mit einer generische Methoden erstellt.<syntaxhighlight lang="c#">
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();
}
}
</syntaxhighlight>

== Generische Programmierung in verschiedenen Programmiersprachen ==
* Wie bereits erwähnt, wird die generische Programmierung in C++ durch Templates unterstützt.
* In [[Ada (Programmiersprache)|Ada]] gab es generische Typen vor der Einführung von Templates in C++. C++ Templates sind von Ada beeinflusst, unterscheiden sich aber in vielen Punkten.<ref name="Stroustrup94Design">Bjarne Stroustrup (1994):The Design and Evolution of C++. Kapitel 15 Templates. Addison-Wesley, Reading, Massachusetts, ISBN 978-0-201-54330-8.</ref>

* In [[ABAP]] gibt es ebenfalls generische Datentypen.
* In [[Java (Programmiersprache)|Java]] kommen generische Typen ab der Version 1.5 vor.
* In [[TypeScript]] und den .NET-Sprachen [[C-Sharp|C#]] und [[Visual Basic .NET|VB .NET]] (ab .NET 2.0) gibt es die [[Generischer Typ|generischen Typen]] (''generics'').
* In der Programmiersprache [[Eiffel (Programmiersprache)|Eiffel]] existieren generische Klassen.
* Die funktionale Programmiersprache [[ML (Programmiersprache)|ML]] (und Abkömmlinge wie [[Objective CAML|OCaml]]) sowie [[Haskell (Programmiersprache)|Haskell]] erlauben generische Programmierung. Typ-Polymorphie ist dort konzeptuelle Grundlage. Es lassen sich sogar Module generieren. Generische Module („parametric modules“) werden hier als Funktor bezeichnet. Man kann Funktoren Module als Parameter übergeben und erhält ein neues Modul als Ergebnis.
* In Programmiersprachen wie [[Python (Programmiersprache)|Python]], welche [[Datentyp]]en dynamisch verwalten und außerdem Operatoren unterstützen, kann praktisch jede Methode im Sinne der generischen Programmierung verwendet werden.
* Schließlich kann man auch die [[Makro]]s in [[C (Programmiersprache)|C]] zur generischen Programmierung benutzen, wenngleich sie ursprünglich nicht zu diesem Zweck eingeführt wurden.

== Softwaretechnik ==
Ein generisches [[Modellierung|Modell]] ist an spezifische Gegebenheiten einer konkreten Situation anpassbar; z. B. ein generisches [[Vorgehensmodell]] wie [[Wasserfallmodell|Wasserfall-]] oder [[Spiralmodell]] an ein konkretes [[Projekt]]. Dieser Vorgang wird im Bereich des [[Software-Engineering]] auch [[Tailoring]] genannt.

Ändert sich das generische Modell, kann man dessen Ausprägungen leicht anpassen, wenn der Weg vom Modell zur Ausprägung detailliert beschrieben ist und man nur die geänderten Elemente verfolgen muss. Bei nicht-generischen Modellen spricht man in diesem Zusammenhang auch von [[Überanpassung]].

== Siehe auch ==
* [[Generische Programmierung in Java]]
* [[Programmierparadigma]]

== Literatur ==
* R. Backhouse, P. Hoogendijk: ''Chapter 3. Generic properties of datatypes.'' In: Roland C. Backhouse (Hrsg.): ''Generic programming: advanced lectures.'' (Lecture Notes in Computer Science; 2793: Tutorial) Springer, Berlin 2003, ISBN 3-540-20194-7, S. 97–132.
* Stephanie Weirich, Chris Casinghino: ''Generic programming with dependent types.'' In: Jeremy Gibbons (Hrsg.): ''Generic and indexed programming: international spring school, SSGIP 2010, Oxford, UK, March 22 - 26, 2010; revised lectures.'' (Lecture Notes in Computer Science; 7470: Tutorial) Springer, Berlin 2012, ISBN 978-3-642-32201-3, S. 217–258.

== Weblinks ==
* [https://www.boost.org/community/generic_programming.html Generic Programming Techniques]
* [https://www.geeksforgeeks.org/generics-in-c/ Generics in C++]
* [https://www.geeksforgeeks.org/generics-in-java/ Generics in Java]
* [https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/types/generics Generic classes and methods]
* [https://www.tutorialsteacher.com/csharp/csharp-generics C# Generics]

== Einzelnachweise ==
<references />

[[Kategorie:Programmierparadigma]]
[[Kategorie:C++]]

Generische Programmierung - Versionsgeschichte

imported>RolandIllig: /* C */ Abschnitt entfernt, da die Implementierung mit Pointern unnötig kompliziert ist und auch nicht erläutert wird