imported>Gerbil am 1. Juli 2025 um 15:17 Uhr

2025-07-01T15:17:00Z

Neue Seite

Eine '''Funktion''' ({{enS|''function''}}) ist in der [[Informatik]] und in verschiedenen [[Höhere Programmiersprache|höheren Programmiersprachen]] die Bezeichnung eines Programmkonstrukts, mit dem der [[Programmcode|Programm-Quellcode]] [[Strukturierte Programmierung|strukturiert]] werden kann, sodass Teile der [[Funktionalität (Produkt)|Funktionalität]] des [[Computerprogramm|Programms]] [[Wiederverwendbarkeit|wiederverwendbar]] sind. Das besondere Merkmal einer Funktion (im Vergleich zum ähnlichen Konstrukt der [[Prozedur (Programmierung)|Prozedur]]) ist, dass die Funktion ein Resultat direkt zurückgibt und deshalb in [[Ausdruck (Programmierung)|Ausdrücken]] verwendet werden kann. Die genaue Bezeichnung und Details ihrer Ausprägung sind in verschiedenen [[Programmiersprache]]n unterschiedlich.

Funktionen gelten als spezielle Varianten von [[Unterprogramm]]en.

Nicht zu verwechseln ist das Programmkonstrukt ‚Funktion‘ mit anderen Bedeutungen des Ausdrucks ‚[[Funktion]]‘, beispielsweise mit Funktionen im Sinn der [[Funktion (Organisation)|Organisation]] oder der [[Systemtheorie]] oder mit [[Funktion (Objekt)|Funktion]] im Sinne von Aufgabe.

== Funktionale Programmierung ==
Das Konzept einer [[Funktion (Mathematik)|Funktion]] im Sinne der Mathematik ist in der [[Funktionale Programmierung|funktionalen Programmierung]] am deutlichsten umgesetzt. Hier stellen Funktionen Abbildungsvorschriften dar. Eine Funktion besteht dann aus einer Reihe von Definitionen, die diese Vorschrift beschreiben.

=== Beispiele ===
In [[Haskell (Programmiersprache)|Haskell]] würde man zum Beispiel schreiben:

<syntaxhighlight lang="haskell">
max :: Int -> Int -> Int
max a b | a > b = a
| otherwise = b
</syntaxhighlight>

Diese Schreibweise erinnert an die mathematische Definition des Maximums zweier Zahlen.

Ein funktionales Programm besteht ausschließlich aus Funktionsdefinitionen und besitzt keine Kontrollstrukturen wie Schleifen. Wichtigstes Hilfsmittel für die funktionale Programmierung ist daher die [[Rekursion]].

Funktionen sind in funktionalen Programmiersprachen Objekte, mit denen wie mit beispielsweise Zahlen oder Listen gearbeitet werden kann. So können Funktionen [[Parameter (Informatik)#Argumente|Argument]]e und Funktionswerte (Ergebnisse, Rückkehrwerte) anderer Funktionen sein. Eine Funktion, die eine andere Funktion als Argument erwartet, nennt man [[Funktion höherer Ordnung]]. Ein Beispiel hierfür ist das <code>map</code>-Funktional:

<syntaxhighlight lang="haskell">
map :: (a -> b) -> [a] -> [b]
map f [] = []
map f (x : xs) = f x : map f xs
</syntaxhighlight>

<code>map</code> nimmt als Argument eine Funktion von <code>a</code> nach <code>b</code>, wobei <code>a</code> und <code>b</code> beliebige Typen sind (''Typvariablen'') und liefert als Ergebnis eine neue Funktion, die Listen von <code>a</code> in Listen von <code>b</code> abbildet, indem nämlich <code>f</code> auf jedes Element der Liste <code>a</code> angewendet wird.

== Imperative Programmierung ==
Zwar dienen auch in der imperativen Programmierung Funktionen im Prinzip dazu, aufgrund einer Reihe von ''Argumenten'' ein ''Resultat'' zu berechnen, aber durch die Verwendung von [[Variable (Programmierung)#Variablen in einer Blockstruktur|globalen Variablen]] kann eine Funktion mehr Argumente empfangen, als aus ihrer Argumentliste ersichtlich ist, und kann auf diesem Weg auch mehr als ein Resultat abliefern. Änderungen in den globalen Variablen einer Funktion werden häufig als ''Nebeneffekt'' bezeichnet. Damit gerät das Konzept der Funktion in die Nähe der [[Prozedur (Programmierung)|Prozedur]], bei der solche „Nebenwirkungen“ in Wirklichkeit die beabsichtigten Hauptwirkungen sind (siehe dazu [[Wirkung (Informatik)|Wirkung in der Informatik]]). Das führt dazu, dass Programmiersprachen oft eine irreführende Terminologie verwenden: In [[C (Programmiersprache)|C]] wird beispielsweise generell nur von Funktionen gesprochen; Prozeduren sind dort Funktionen mit dem Rückgabetyp <code>void</code>; in [[Modula-2]] dagegen werden auch Funktionen mit dem Schlüsselwort <code>procedure</code> definiert.

=== Direktes Verwenden des Ergebnisses ===
Im Gegensatz zu Prozeduren geben Funktionen einen Wert zurück, der direkt verwendet werden kann. Prozeduren, die keinen Rückgabewert haben, können nur indirekt Ergebnisse liefern, indem entweder [[Referenzparameter]] oder globale Variablen verändert werden.

Die Programmiersprache [[Pascal (Programmiersprache)|Pascal]] bietet eine explizite Unterscheidung für Funktionen und Prozeduren. Eine Funktion <code>increment</code>, welche eine Zahl um eins erhöht, kann folgendermaßen definiert werden:<syntaxhighlight lang="pascal">
function increment(variable: Integer): Integer;
begin
increment := variable + 1;
end;
</syntaxhighlight>Bei einer Prozedur kann das Berechnungsergebnis nur indirekt zurückgegeben werden wie beispielsweise über Referenzparameter.<syntaxhighlight lang="pascal">
procedure increment(variable: Integer, var reference: Integer);
begin
reference := variable + 1;
end;
</syntaxhighlight>Während das Ergebnis bei einem Funktionsaufruf direkt genutzt werden kann, muss das Ergebnis bei einer Prozedur zuerst in einer Variablen gespeichert werden, da die Variable als Parameter übergeben wird.<syntaxhighlight lang="pascal">
program main;
var
variable: Integer;
begin
// Aufruf einer Funktion
writeln(increment(3));

// Aufruf einer Prozedur
increment(3, variable);
writeln(variable);
end;
</syntaxhighlight>

=== Beispiele ===
==== Pascal ====
[[Pascal (Programmiersprache)|Pascal]] unterscheidet zwischen Funktionen und Prozeduren:
* Funktionen werden mit dem Schlüsselwort <code>function</code> deklariert und liefern einen Rückgabewert mit einem definierten Typ. Funktionsaufrufe stehen innerhalb von Ausdrücken. Die Festlegung des Rückgabewerts erfolgt durch eine (Pseudo-)Zuweisung an den Funktionsnamen. Als Nebenwirkung können Funktionen aber den Zustand des Programms verändern, indem nämlich globale Variablen neue Werte erhalten.
* [[Prozedur (Programmierung)|Prozeduren]] werden mit dem Schlüsselwort <code>procedure</code> deklariert und haben keinen definierten Rückgabewert. Ihre Wirkung kann sich deshalb nur in den Änderungen globaler Variablen zeigen.

Beispiel einer Funktionsvereinbarung in Pascal:

<syntaxhighlight lang="pascal">
function summe(a: Integer; b: Integer): Integer;
begin
summe := a + b;
end;
</syntaxhighlight>

Beispiel eines Funktionsaufrufs in Pascal:
<syntaxhighlight lang="pascal">
ergebnis := summe(1, 2);
</syntaxhighlight>

Funktionen und Prozeduren sind in Pascal im Gegensatz zu C schachtelbar. Dies bedeutet, dass sie weitere Funktionen und Prozeduren enthalten können.

Argumente werden normalerweise als [[Wertparameter]] übergeben ''(call / pass by value)''. Der Wert einer Variablen, die einer Funktion (oder Prozedur) als Argument übergeben wird, wird durch deren Ausführung nicht verändert. Es ist aber auch möglich, mit dem Schlüsselwort <code>var</code> die Übergabe als [[Referenzparameter|Referenz]] (call by reference) festzulegen. Dadurch wird nicht der Wert einer Variablen übergeben, sondern ihre Adresse.

==== C ====
Argumente werden prinzipiell immer als [[Wertparameter]] übergeben ''(call / pass by value)''. Soll eine übergebene Variable verändert werden, so übergibt man deren Adresse, also einen [[Zeiger (Informatik)|Pointer]]. Die Bestimmung des Rückgabewertes geschieht durch eine <code>return</code> Anweisung. Funktionen in C sind nicht schachtelbar. Allerdings liefern einige C-Compiler nicht standardisierte Erweiterungen aus, welche eine Schachtelung ermöglichen.

Beispiel einer Funktionsvereinbarung in [[C (Programmiersprache)|C]]:

<syntaxhighlight lang="c">
int summe(int a, int b) {
return a + b;
}
</syntaxhighlight>

Beispiel eines Funktionsaufrufs in C:
<syntaxhighlight lang="c">
ergebnis = summe(1, 2);
</syntaxhighlight>

== Automatisierungstechnik: SPS-Programmierung ==
In der Automatisierungstechnik werden bei der [[Speicherprogrammierbare Steuerung|SPS]]-Programmierung ''Funktionen (FCs)'' sowie ''[[Funktionsbausteinsprache|Funktionsbausteine]] (FBs)'' als ''bibliotheksfähige Bausteine'' verwandt.

== Literatur ==
* Siegfried Grohmann, Dirk Papendieck, OStR Peter Westphal-Nagel: ''Automatisierungstechnik mit Simatic S7. Programmierprojekte für die berufliche Aus- und Weiterbildung.'' 3., überarbeitete und aktualisierte Auflage, Elektronik-Praktiker-Verlag (EPV), Duderstadt 2009, ISBN 978-3-936318-75-3, 160 Seiten.

[[Kategorie:Programmierkonzept]]
[[Kategorie:Unterprogramm]]
[[Kategorie:Programmiersprachelement]]

Funktion (Programmierung) - Versionsgeschichte

imported>Gerbil am 1. Juli 2025 um 15:17 Uhr